关于java：Spring Framework究竟是什么？


What exactly is Spring Framework for?

我听说了很多关于Spring的事情，大家都说Spring是一个很好的Web开发框架。Spring框架的具体用途是什么？

相关讨论

基本上，Spring是一个依赖注入框架，它是一个允许构建完全分离的系统的模式。

问题

例如，假设您需要列出系统的用户，从而声明一个名为UserLister的接口：

1
2
3
public interface UserLister {
    List<User> getUsers();
}

可能还有一个访问数据库以获取所有用户的实现：

1
2
3
4
5
public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

在您的视图中，您需要访问一个实例(只是一个示例，请记住)：

1
2
3
4
5
6
7
8
public class SomeView {
    private UserLister userLister;

    public void render() {
        List<User> users = userLister.getUsers();
        view.render(users);
    }
}

注意，上面的代码没有初始化变量UserLister。我们该怎么办？如果我这样显式地实例化对象：

1
UserLister userLister = new UserListerDB();

…我将视图与访问数据库的类的实现结合起来。如果我想从DB实现切换到另一个从逗号分隔文件获取用户列表的实现(记住，这是一个示例)，该怎么办？在这种情况下，我将再次转到我的代码，并将最后一行更改为：

1
UserLister userLister = new UserListerCommaSeparatedFile();

这对像这样的小程序没有问题，但是…在一个拥有数百个视图和类似数量的业务类的程序中会发生什么。维修变成了一场噩梦！

弹簧(依赖注入)方法

Spring所做的是使用XML文件或注释将类连接起来，这样所有对象都由Spring实例化和初始化，并注入正确的位置(servlet、Web框架、业务类、DAOS等)。

回到春季的例子中，我们只需要为UserLister字段设置一个setter，并使用如下XML文件：

1
2
3
4
5
<bean id="userLister" class="UserListerDB" />

<bean class="SomeView">
    <property name="userLister" ref="userLister" />
</bean>

或者更简单地用@Inject注释视图类中的字段：

1
2
@Inject
private UserLister userLister;

这样，当视图被创建时，它会神奇地有一个UserLister准备工作。

1
2
List<User> users = userLister.getUsers();  // This will actually work
                                           // without adding any line of code

太棒了！不是吗？

  • 如果您想使用您的UserLister接口的另一个实现怎么办？只需更改XML
  • 如果没有准备好UserLister实现怎么办？对UserLister的临时模拟实现进行编程，并简化视图的开发。
  • 如果我不想再用弹簧怎么办？别用它！您的应用程序没有耦合到它。控制状态反转："应用程序控制框架，而不是框架控制应用程序"。

在这附近还有一些依赖注入的其他选项，在我看来，除了它的简单性、优雅性和稳定性之外，SpringSource的人还编程了许多POJO，这些POJO有助于将Spring与许多其他通用框架集成在一起，而不会干扰您的应用程序。此外，Spring还有几个好的子项目，比如SpringMVC、SpringWebFlow、SpringSecurity，还有一个即将发布的ETCEteras列表。

希望这有帮助。无论如何，我鼓励你阅读马丁·福勒关于依赖注入和控制反转的文章，因为他比我做得更好。了解基础知识后，查看Spring文档，在我看来，ITisused to be the best spring book ever.

相关讨论

Spring包含(正如斯卡夫曼正确指出的)MVC框架。简而言之，这里是我的输入。Spring支持服务层、Web层和业务层的分离，但它真正做得最好的是"注入"对象。因此，为了解释这一点，通过一个例子来考虑下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public interface FourWheel
{
   public void drive();
}

public class Sedan implements FourWheel
{
   public void drive()
   {
      //drive gracefully
   }
}

public class SUV implements FourWheel
{
   public void drive()
   {
      //Rule the rough terrain
   }
}

现在在你的代码中，你有一个叫做公路旅行的课程，如下所示

1
2
3
4
public class RoadTrip
{
    private FourWheel myCarForTrip;
}

现在，每当你想要一个旅行实例，有时你可能需要一辆SUV初始化四轮，有时你可能需要轿车。这真的取决于你根据具体情况想要什么。

为了解决这个问题，你需要一个工厂模式作为创造模式。工厂返回正确的实例。因此，最终您将得到大量的粘合代码，只是为了正确地实例化对象。没有胶水代码，Spring做胶水代码的工作最好。您可以在XML中声明映射，并自动初始化对象。它还可以为实例使用单例体系结构，这有助于优化内存使用。

这也被称为控制反转。其他实现这一点的框架还有GoogleGuice、PicoContainer等。

除此之外，Spring还提供了验证框架，与JDBC、IBatis和Hibernate(等等)合作，对DAO层提供了广泛的支持。对数据库事务提供出色的事务控制。

在《春天》这样的好书中可以读到更多关于春天的内容。

以下网址也可能有帮助。http://static.springframework.org/docs/spring-mvc-step-by-step/http://en.wikipedia.org/wiki/Spring_框架http://www.theserverside.com/tt/articles/article.tss？L=弹簧框架

相关讨论

过去，Spring只是一个依赖注入框架，它的工作方式和(guice、picocontainer，…)类似，但现在它是构建企业应用程序的完整解决方案。

弹簧依赖性注射，这当然是弹簧的核心，仍然存在(你可以在这里回顾其他好的答案)，但是弹簧有更多的东西……

Spring现在有很多项目，每个项目都有一些子项目(http://spring.io/projects)。当有人谈到Spring时，您必须了解他所说的Spring项目是什么，它只是Spring核心，即所谓的Spring框架，还是另一个Spring项目。

一些值得一提的春季项目包括：

  • Spring安全性-http://projects.spring.io/spring-security/
  • Spring Web服务-http://projects.spring.io/spring-ws/
  • Spring集成-http://projects.spring.io/spring-integration/

如果您需要为您的应用程序提供更多的指定功能，您也可以在这里找到它：

  • Spring批处理框架的设计使批量应用
  • Spring hateoas基于hateoas主体轻松创建REST API
  • 用于移动应用开发的Spring Mobile和Spring Andriod
  • SpringShell构建一个功能齐全的shell(又称命令行)应用程序
  • 云应用的Spring Cloud和Spring Cloud数据流

还有一些小项目，例如Spring Social Facebook(http://projects.spring.io/spring-social-facebook/)

您可以使用Spring进行Web开发，因为它具有作为Spring框架项目一部分的Spring MVC模块。或者，您可以将弹簧与另一个Web框架一起使用，如Struts2。

相关讨论

春天是用来干什么的？我很快就会回答这个问题，但首先，让我们再看看维克多雨果的例子。这不是一个很好的例子，因为它不能证明需要一个新的框架。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class BaseView {
  protected UserLister userLister;

  public BaseView() {
    userLister = new UserListerDB(); // only line of code that needs changing
  }
}

public class SomeView extends BaseView {
  public SomeView() {
    super();
  }

  public void render() {
    List<User> users = userLister.getUsers();
    view.render(users);
  }
}

完成！所以现在，即使您有成百上千的视图，您仍然需要更改一行代码，就像在SpringXML方法中那样。但是，更改一行代码仍然需要重新编译，而不是编辑您所说的XML？好吧，我挑剔的朋友，用蚂蚁和脚本走！

那么春天是干什么的呢？它的目的是：

  • 盲从人群的开发人员
  • 那些不想雇佣研究生程序员的雇主，因为他们不在大学教授这种框架
  • 以糟糕的设计开始，需要修补的项目(如Victor Hugo的示例所示)

    • 进一步阅读：http://discus.joelonsoftware.com/？乔尔3.219431.12

    相关讨论

    总结得很简短，我会说弹簧是你应用中的"胶水"。它用于集成不同的框架和您自己的代码。

    春天是三样东西。

  • Spring处理依赖注入，我建议您阅读MartinFowler关于依赖注入的优秀介绍。
  • Spring所做的第二件事是以一种非常优雅的方式将优秀的Java库包装在应用程序中。有关一个很好的示例，请参阅Spring如何包装任务执行器和Quartz调度程序。
  • 第三，Spring提供了一系列Web工具的实现，比如REST、MVC Web框架等等。他们认为，既然你在前两个版本中使用了Spring，也许你可以将它用于你的web应用程序所需要的一切。

    • 问题是，SpringDI的思想真的很好，其他东西的包装纸的思想也很好，其他东西的思想都很好，而Spring正好把它包装好。MVC和REST以及其他所有东西的Spring实现都没有做得那么好(YMMV、IMHO)，但是也有例外(Spring安全就是DA炸弹)。所以我倾向于使用Spring作为DI，它的包装很酷，但我更喜欢其他的东西用于Web(我很喜欢挂毯)，REST(泽西岛真的很结实)，等等。

    相关讨论

    在使用Spring的Web应用程序中可能需要什么-

    • SpringMVC，使用2.5+允许您使用POJO作为控制器类，这意味着您不必从任何特定的框架(如Struts或SpringPre-2.5)进行扩展。控制器类也非常容易测试，部分原因是依赖注入
    • 与Hibernate的Spring集成，它可以很好地简化使用该ORM解决方案的工作(对于大多数情况)
    • 对Web应用程序使用Spring可以在应用程序的所有级别上使用域对象-使用Hibernate映射的类与用作"表单bean"的类相同。从本质上讲，这将导致更健壮的域模型，部分原因是它将减少类的数量。
    • SpringForm标签使创建表单变得更容易，而不需要太多麻烦。

    另外，Spring是巨大的，所以在Web应用程序中使用SpringAOP或SpringSecurity可能会有很多其他感兴趣的东西。但是上面列出的四件事描述了Web应用程序中使用的Spring的常见组件。

    我看到两个部分：

  • "春天到底是为了什么？">看雨果的回答。
  • "[…]Spring是一个很好的Web开发框架"->人们说这是在谈论SpringMVC。SpringMVC是Spring的许多部分之一，是一个利用Spring的一般特性的Web框架，比如依赖注入。它是一个非常通用的框架，因为它是可配置的：您可以使用不同的DB层(Hibernate、iBatis、Plain JDBC)、不同的视图层(JSP、Velocity、FreeMarker…)

    • 请注意，您可以在Web应用程序中完美地使用Spring，而不必使用SpringMVC。我认为大多数Java Web应用程序都是这样做的，而使用WEKET、Struts、Sein等其他Web框架。

    Spring非常适合将类的实例粘合在一起。您知道您的Hibernate类总是需要一个数据源，Spring将它们连接在一起(也有一个数据源的实现)。

    您的数据访问对象总是需要Hibernate访问，Spring为您将Hibernate类连接到DAO中。

    另外，Spring基本上为您提供了一系列库的可靠配置，在这个配置中，为您提供了应该使用什么libs的指导。

    弹簧真的是一个很好的工具。(我不是在谈论SpringMVC，只是基础框架)。

    接受的答案不涉及注释的使用，因为Spring引入了对配置的各种注释的支持。

    弹簧(依赖注入)方法

    还有另一种使用XML文件连接类的方法：注释。让我们使用已接受答案中的示例，并使用注释之一@Component、@Service、@Repository或@Configuration在类中直接注册bean：

    1
    2
    3
    4
    5
    6
    @Component
    public class UserListerDB implements UserLister {
        public List<User> getUsers() {
            // DB access code here
        }
    }

    This way when the view is created it magically will have a UserLister ready to work.

    上面的语句是有效的，不需要使用任何XML文件，也不需要与另一个注释@Autowired连接，它找到一个相关的实现并将其插入。

    1
    2
    @Autowired
    private UserLister userLister;

    在用于获取要注入的bean实现的方法上使用@Bean注释。

    相关讨论

    其优点是依赖注入(DI)。这意味着将对象创建的任务外包出去，让我用一个例子来解释。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public interface Lunch
    {
       public void eat();
    }

    public class Buffet implements Lunch
    {
       public void eat()
       {
          // Eat as much as you can
       }
    }

    public class Plated implements Lunch
    {
       public void eat()
       {
          // Eat a limited portion
       }
    }

    现在在我的代码中，我有一个班级午餐决定如下：

    1
    2
    3
    4
    5
    6
    7
    public class LunchDecide {
        private Lunch todaysLunch;
        public LunchDecide(){
            this.todaysLunch = new Buffet(); // choose Buffet -> eat as much as you want
            //this.todaysLunch = new Plated(); // choose Plated -> eat a limited portion
        }
    }

    在上面的课程中，根据我们的心情，我们选择buffet()或plated()。然而，这个系统是紧密耦合的。每次我们需要不同类型的对象时，我们都需要更改代码。在这种情况下，评论一行！假设有50个不同的班级被50个不同的人使用。这将是一个糟糕的局面。在这种情况下，我们需要将系统解耦。让我们重写午餐决定课。

    1
    2
    3
    4
    5
    6
    public class LunchDecide {
        private Lunch todaysLunch;
        public LunchDecide(Lunch todaysLunch){
            this.todaysLunch = todaysLunch
            }
        }

    注意，我们没有使用new关键字创建对象，而是将对午餐类型的对象的引用作为参数传递给构造函数。在这里，对象创建是外包的。此代码可以使用XML配置文件(遗产)或Java注释(现代)来连接。无论哪种方式，在运行时，都将在那里决定将创建哪种类型的对象。一个对象将由XML注入到我们的代码中——我们的代码依赖于该作业的XML。因此，依赖注入(DI)。DI不仅有助于使我们的系统松散耦合，还简化了单元测试的编写，因为它允许模拟依赖项。最后但并非最不重要的是，DI简化了面向方面编程(AOP)，这导致了进一步的解耦和模块化的增加。还要注意，上面的DI是构造函数注入。DI可以通过setter注入以及封装中相同的普通老setter方法来完成。

    相关讨论

    Spring是企业JavaBeans(EJB)技术的一个很好的替代方案。它还具有Web框架和Web服务框架组件。

    相关讨论

    • 与J2EE相比，Spring是一个轻量级和灵活的框架。
    • 弹簧容器起到控制反转的作用。
    • Spring使用AOP，即代理和单例、工厂和模板方法设计模式。
    • 分层体系结构：关注点和可重用层的分离以及易于维护。

    enter image description here

    相关讨论

    Spring在开始时是依赖注入，然后为几乎所有东西添加包装王(包装器覆盖JPA实现等)。

    长篇故事…Spring Preffer XML解决方案(XML脚本引擎…brrrr)，所以对于di，我使用guice

    好的库，但是随着增长的DeNeDNCIEC，例如Spring JDBC(可能是一个具有实名参数的JavaJDBC解决方案)从Maven 4-5取而代之。

    使用SpringMVC(BigSpring的一部分)进行Web开发…它是"基于请求"的框架，有神圣的战争"请求与组件"…由你决定

    相关讨论

    Spring最初是一个相当简单的依赖注入系统。现在它很大，里面什么都有(除了众所周知的厨房水槽)。

    但不用担心，它是相当模块化的，所以你可以只使用你想要的部分。

    要查看一切从何开始，请尝试：

    http://www.amazon.com/expert one design development programmer/dp/0764543857/ref=sr_1_1？ie=utf8&s=books&qid=1246374863&sr=1-1

    它可能很旧，但它是一本很好的书。

    另一本专攻春天的好书见：

    http://www.亚马逊/com专业Java开发Spring框架/DP/0764574833／REF= SRY1L2？ie=utf8&s=books&qid=1246374863&sr=1-2

    它也引用了旧版本的Spring，但绝对值得一看。

    过去，我从纯技术的角度考虑Spring框架。

    考虑到一些团队工作和开发企业webapps的经验，我想说Spring是通过分离单个元素(bean)来更快地开发应用程序(web应用程序)。更快的发展使它如此受欢迎。Spring允许将构建(连接)应用程序的职责转移到Spring框架上。Spring框架的依赖注入负责将单个bean连接/连接到工作应用程序中。

    这样，一旦定义了bean之间的接口，开发人员就可以更加关注单个组件(bean)的开发。

    这种应用程序的测试很容易——主要关注的是单个bean。它们可以很容易地解耦和模拟，所以单元测试是快速和有效的。

    Spring框架定义了多个专门的bean，例如@controller(@restcontroller)、@repository、@component，以满足Web目的。Spring和Maven一起为开发人员提供了一个直观的结构。团队工作是简单和快速的，因为有单独的元素被分开，并且可以重用。

    Spring框架非常适合Web开发，更适合于RESTAPI。因为它的依赖注入和与其他模块的集成，比如Spring安全、Spring AOP、MVC框架、微服务

    您构建的任何应用程序都绝对需要安全性。如果您正在构建一个产品，长期维护，那么您将坚决需要AOP概念。如果您的应用程序有更多的负载，那么您需要实现微服务。

    春天把这一切都放在一个平台上。支持多模块主要是Spring是开源的可扩展框架，在生命周期中到处都有一个钩子来集成定制代码。

    Spring数据是一个提供与项目集成的项目。

    所以，构建应用程序所需的一切都是春天。