沉淀再出发:Spring的架构理解

时间 2019-11-19

原文原文链接

沉淀再出发:Spring的架构理解

1、前言

在Spring以前使用的EJB框架太庞大和重量级了，开发成本很高，由此spring应运而生。关于Spring，学过java的人基本上都会慢慢接触到，而且在面试的时候也是常常遇到的，由于这个技术极大地方便了咱们的开发和部署，而且由此衍生出来的框架和思想在不少地方都有使用，好比Spring mvc，Spring boot，Spring cloud等等框架以及IoC和AOP这两个Spring最本质的思想。能够说一切的本质都是为了高内聚，松耦合，将不一样的事物之间尽可能的分割清楚，经过某一种额外的比较好修改的文档来记录这二者的联系，而后经过框架来将二者在联系起来，这样作看似麻烦实则便于咱们扩展、维护和变动，很是的方便，而且把冗余的代码动态的装饰接入点，更加方便了代码的扩展、可维护性和可读性，只须要一个代理便可。在这两种思想之上，spring又构建了一些列的实现方式，经过IoC的Beans组件，以及Context这个让Beans运行的上下文，以及Core这个Beans的经常使用工具，使得一切都以Beans为核心，搭建出了最本质的框架，而后由这三者支撑了更加顶层的、复杂的技术，极大地方便了框架的扩展和维护。这也是spring长盛不衰的缘由了。html

2、Spring的框架

Spring是一个开源的轻量级Java SE/Java EE开发应用框架，其目的是用于简化企业级应用程序开发。在传统应用程序开发中，一个完整的应用是由一组相互协做的对象组成。因此开发一个应用除了要开发业务逻辑以外，最多的是关注如何使这些对象协做来完成所需功能，并且要低耦合、高内聚。业务逻辑开发是不可避免的，那若是有个框架出来帮咱们来建立对象及管理这些对象之间的依赖关系。虽然“抽象工厂、工厂方法设计模式”能够帮咱们建立对象，“生成器模式”能够帮咱们处理对象间的依赖关系，可是这些又须要咱们建立另外一些工厂类、生成器类，另外管理这些类，增长了咱们的负担，若是能经过配置方式来建立对象，管理对象之间依赖关系，咱们不须要经过工厂和生成器来建立及管理对象之间的依赖关系，这样咱们就能减小许多工做，加速开发，能节省出不少时间来干其余事。Spring框架刚出来时主要就是来完成这个功能。
Spring框架除了帮咱们管理对象及其依赖关系，还提供像通用日志记录、性能统计、安全控制、异常处理等面向切面编程的能力，还能帮咱们管理最头疼的数据库事务，它自己提供了一套简单的JDBC访问实现，还能与第三方数据库访问框架集成（如Hibernate、JPA），与各类Java EE技术整合（如Java Mail、任务调度等等），提供一套本身的web层框架Spring MVC、并且还能很是简单的与第三方web框架集成。从这里咱们能够认为Spring是一个超级粘合平台，除了本身提供功能外，还提供粘合其余技术和框架的能力，从而使咱们能够更自由的选择到底使用什么技术进行开发。并且无论是JAVA SE（C/S架构）应用程序仍是JAVA EE（B/S架构）应用程序均可以使用这个平台进行开发。
java

2.一、框架的本质

Spring 框架中的核心组件只有三个：Core、Context 和 Beans。它们构建起了整个 Spring 的骨骼架构。没有它们就不可能有 AOP、Web 等上层的特性功能。若是在它们三个中选出核心的话，那就非 Beans 组件莫属了，其实 Spring 就是面向 Bean 的编程（BOP,Bean Oriented Programming），Bean 在 Spring 中才是真正的主角。Bean 在 Spring 中做用就像 Object 对 OOP 的意义同样，没有对象的概念就像没有面向对象编程，Spring 中没有 Bean 也就没有 Spring 存在的意义。就像一次演出舞台都准备好了可是却没有演员同样。为何要 Bean 这种角色 Bean 或者为什么在 Spring 如此重要，这由 Spring 框架的设计目标决定，Spring 为什么如此流行，咱们用 Spring 的缘由是什么，想一想会发现原来 Spring 解决了一个很是关键的问题，它可让你把对象之间的依赖关系转而用配置文件来管理，也就是依赖注入机制。而这个注入关系在一个叫 IoC 容器中管理，那 IoC 容器就是被 Bean 包裹的对象。Spring 正是经过把对象包装在 Bean 中而达到对这些对象的管理以及一些列额外操做的目的。它这种设计策略彻底相似于 Java 实现 OOP 的设计理念，固然了 Java 自己的设计要比 Spring 复杂太多太多，可是都是构建一个数据结构，而后根据这个数据结构设计他的生存环境，并让它在这个环境中按照必定的规律在不停的运动，在它们的不停运动中设计一系列与环境或者与其余个体完成信息交换。这样想来咱们用到的其余框架都是大慨相似的设计理念。web

2.二、核心组件的协同工做

把 Beans 比做一场演出中的演员的话，那 Context 就是这场演出的舞台背景，而 Core 应该就是演出的道具了。只有它们在一块儿才能具有演出一场好戏的最基本条件。固然有最基本的条件还不能使这场演出脱颖而出，还要表演的节目足够的精彩，这些节目就是 Spring 能提供的特点功能了。咱们知道 Bean 包装的是 Object，而 Object 必然有数据，如何给这些数据提供生存环境就是 Context 要解决的问题，对 Context 来讲就是要发现每一个 Bean 之间的关系，为它们创建这种关系而且要维护好这种关系。因此 Context 就是一个 Bean 关系的集合，这个关系集合又叫 Ioc 容器，一旦创建起这个 Ioc 容器后 Spring 就能够工做了。那 Core 组件又有什么用武之地呢？其实 Core 就是发现、创建和维护每一个 Bean 之间的关系所须要的一些列的工具，从这个角度看来，Core 这个组件叫 Util 更能理解。面试

2.三、Bean 组件

Bean 组件在 Spring 的 org.springframework.beans 包下。这个包下的全部类主要解决了三件事：Bean 的定义、Bean 的建立以及对 Bean 的解析。对 Spring 的使用者来讲惟一须要关心的就是 Bean 的建立，其余两个由 Spring 在内部帮你完成了，对你来讲是透明的。Spring Bean 的建立时典型的工厂模式，它的顶级接口是 BeanFactory，下图是这个工厂的继承层次关系：spring

BeanFactory 有三个子类：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。可是咱们能够发现最终的默认实现类是 DefaultListableBeanFactory，实现了全部的接口。那为什么要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每一个接口都有使用的场合，它主要是为了区分在 Spring 内部对象的传递和转化过程当中，对对象的数据访问所作的限制。例如 ListableBeanFactory 接口表示这些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的这些 Bean 是有继承关系的，也就是每一个 Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。这四个接口共同定义了 Bean 的集合、Bean 之间的关系以及 Bean 行为。Bean 的定义主要有 BeanDefinition 描述。数据库

Bean的做用域

Spring定义了多种Bean做用域，能够基于这些做用域建立bean，包括：编程

    单例（Singleton）：在整个应用中，只建立bean的一个实例。
    原型（Prototype）：每次注入或者经过Spring应用上下文获取的时候，都会建立一个新的bean实例。
    会话（Session）：在Web应用中，为每一个会话建立一个bean实例。
    请求（Rquest）：在Web应用中，为每一个请求建立一个bean实例。

声明Bean

@Component 组件，没有明确的角色
@Service 在业务逻辑层使用
@Repository 在数据访问层使用
@Controller 在展示层使用(MVC -> Spring MVC)使用
在这里，能够指定bean的id名：Component(“yourBeanName”)
同时，Spring支持将@Named做为@Component注解的替代方案。
二者之间有一些细微的差别，可是在大多数场景中，它们是能够互相替换的。

2.四、Context 组件

Context 做为 Spring 的 Ioc 容器，基本上整合了 Spring 的大部分功能，或者说是大部分功能的基础。Context 在 Spring 的 org.springframework.context 包下， Context 组件实际上就是给 Spring 提供一个运行时的环境，用以保存各个对象的状态。下面看一下这个环境是如何构建的。ApplicationContext 是 Context 的顶级父类，除了能标识一个应用环境的基本信息外，还继承了五个接口，这五个接口主要是扩展了 Context 的功能。设计模式

ApplicationContext 继承了 BeanFactory，这也说明了 Spring 容器中运行的主体对象是 Beans，另外 ApplicationContext 继承了 ResourceLoader 接口，使得 ApplicationContext 能够访问到任何外部资源。
ApplicationContext 的子类主要包含两个方面：安全

1  ConfigurableApplicationContext 表示该 Context 是可修改的，也就是在构建 Context 中用户能够动态添加或修改已有的配置信息，它下面又有多个子类，其中常用的是可更新的 Context，即 AbstractRefreshableApplicationContext 类。
2  WebApplicationContext 顾名思义，就是为 web 准备的 Context ，能够直接访问到 ServletContext，一般状况下，这个接口使用的少。

再往下分就是按照构建 Context 的文件类型，接着就是访问 Context 的方式。这样一级一级构成了完整的 Context 等级层次。
整体来讲 ApplicationContext 必需要完成如下几件事：服务器

1   标识一个应用环境
2   利用 BeanFactory 建立 Bean 对象
3   保存对象关系表
4   可以捕获各类事件

2.五、Core 组件

Core 组件做为 Spring 的核心组件，其中包含了不少的关键类，其中一个重要组成部分就是定义了资源的访问方式。这种把全部资源都抽象成一个接口的方式很值得在之后的设计中拿来学习。下面就重要看一下这个部分在 Spring 的做用。

Resource 接口封装了各类可能的资源类型，也就是对使用者来讲屏蔽了文件类型的不一样。对资源的提供者来讲，如何把资源包装起来交给其余人用这也是一个问题，咱们看到 Resource 接口继承了 InputStreamSource 接口，这个接口中有个 getInputStream 方法，返回的是 InputStream 类。这样全部的资源都被能够经过 InputStream 这个类来获取，因此也屏蔽了资源的提供者。另外还有一个问题就是加载资源的问题，也就是资源的加载者要统一，这个任务是由 ResourceLoader 接口完成，它屏蔽了全部的资源加载者的差别，只须要实现这个接口就能够加载全部的资源，默认实现是 DefaultResourceLoader。

Context 和 Resource 创建关系：Context 是把资源的加载、解析和描述工做委托给了 ResourcePatternResolver 类来完成，至关于一个接头人，把资源的加载、解析和资源的定义整合在一块儿便于其余组件使用。Core 组件中还有不少相似的方式。

2.六、IoC 容器如何工做

前面介绍了 Core 组件、Bean 组件和 Context 组件的结构与相互关系，下面这里从使用者角度看一下它们是如何运行的，以及咱们如何让 Spring 完成各类功能。

如何建立 BeanFactory 工厂

IoC容器实际上就是Context组件结合其余两个组件共同构建了一个 Bean 关系网，构建的入口就在 AbstractApplicationContext 类的 refresh 方法中。这个方法的代码以下：

 1 public void refresh() throws BeansException, IllegalStateException {
 2     synchronized (this.startupShutdownMonitor) {
 3         // Prepare this context for refreshing.
 4         prepareRefresh();
 5         // Tell the subclass to refresh the internal bean factory.
 6         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 7         // Prepare the bean factory for use in this context.
 8         prepareBeanFactory(beanFactory);
 9         try {
10             // Allows post-processing of the bean factory in context subclasses.
11             postProcessBeanFactory(beanFactory);
12             // Invoke factory processors registered as beans in the context.
13             invokeBeanFactoryPostProcessors(beanFactory);
14             // Register bean processors that intercept bean creation.
15             registerBeanPostProcessors(beanFactory);
16             // Initialize message source for this context.
17             initMessageSource();
18             // Initialize event multicaster for this context.
19             initApplicationEventMulticaster();
20             // Initialize other special beans in specific context subclasses.
21             onRefresh();
22             // Check for listener beans and register them.
23             registerListeners();
24             // Instantiate all remaining (non-lazy-init) singletons.
25             finishBeanFactoryInitialization(beanFactory);
26             // Last step: publish corresponding event.
27             finishRefresh();
28         }
29         catch (BeansException ex) {
30             // Destroy already created singletons to avoid dangling resources.
31             destroyBeans();
32             // Reset 'active' flag.
33             cancelRefresh(ex);
34             // Propagate exception to caller.
35             throw ex;
36         }
37     }
38 }

这个方法就是构建整个 Ioc 容器过程的完整的代码，了解里面的每一行代码基本上就了解大部分 Spring 的原理和功能了。主要包含这样几个步骤：

1  构建 BeanFactory，以便于产生所需的“演员”
2  注册可能感兴趣的事件
3  建立 Bean 实例对象
4  触发被监听的事件

建立和配置 BeanFactory，这里 refresh 也就是刷新配置，前面介绍了 Context 有可更新的子类，这里正是实现这个功能，当 BeanFactory 已存在是就更新，若是没有就新建立。下面是更新 BeanFactory 的方法代码：

 1 protected final void refreshBeanFactory() throws BeansException {
 2     if (hasBeanFactory()) {
 3         destroyBeans();
 4         closeBeanFactory();
 5     }
 6     try {
 7         DefaultListableBeanFactory beanFactory = createBeanFactory();
 8         beanFactory.setSerializationId(getId());
 9         customizeBeanFactory(beanFactory);
10         loadBeanDefinitions(beanFactory);
11         synchronized (this.beanFactoryMonitor) {
12             this.beanFactory = beanFactory;
13         }
14     }
15     catch (IOException ex) {
16         throw new ApplicationContextException(
17             "I/O error parsing bean definition source for "
18             + getDisplayName(), ex);
19     }
20 }

这个方法实现了 AbstractApplicationContext 的抽象方法 refreshBeanFactory，这段代码清楚的说明了 BeanFactory 的建立过程。注意 BeanFactory 对象的类型的变化，前面介绍了它有不少子类，在什么状况下使用不一样的子类这很是关键。BeanFactory 的原始对象是 DefaultListableBeanFactory，设计到后面对这个对象的多种操做。除了 BeanFactory 相关的类外，还发现了与 Bean 的 register 相关。这在 refreshBeanFactory 方法中有一行 loadBeanDefinitions(beanFactory) 将找到答案，这个方法将开始加载、解析 Bean 的定义，也就是把用户定义的数据结构转化为 IoC 容器中的特定数据结构。

建立 BeanFactory 时序图:

Bean 的解析和登记流程时序图:

建立好 BeanFactory 后，接下去添加一些 Spring 自己须要的一些工具类，这个操做在 AbstractApplicationContext 的 prepareBeanFactory 方法完成。AbstractApplicationContext 中接下来的三行代码对 Spring 的功能扩展性起了相当重要的做用。前两行主要是让咱们能够对已经构建的 BeanFactory 的配置作修改，后面一行就是让咱们对之后再建立 Bean 的实例对象时添加一些自定义的操做。因此它们都是扩展了 Spring 的功能，因此咱们要学习使用 Spring 必须对这一部分搞清楚。

如何建立 Bean 实例并构建 Bean 的关系网

下面是 Bean 的实例化代码，是从 finishBeanFactoryInitialization 方法开始的。

 1 protected void finishBeanFactoryInitialization(
 2     ConfigurableListableBeanFactory beanFactory) {
 3  
 4     // Stop using the temporary ClassLoader for type matching.
 5     beanFactory.setTempClassLoader(null);
 6  
 7     // Allow for caching all bean definition metadata, not expecting further changes.
 8     beanFactory.freezeConfiguration();
 9  
10     // Instantiate all remaining (non-lazy-init) singletons.
11     beanFactory.preInstantiateSingletons();
12 }

从上面代码中能够发现 Bean 的实例化是在 BeanFactory 中发生的。preInstantiateSingletons 方法的代码以下：

 1 public void preInstantiateSingletons() throws BeansException {
 2     if (this.logger.isInfoEnabled()) {
 3         this.logger.info("Pre-instantiating singletons in " + this);
 4     }
 5     synchronized (this.beanDefinitionMap) {
 6         for (String beanName : this.beanDefinitionNames) {
 7             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
 8             if (!bd.isAbstract() && bd.isSingleton()
 9                 && !bd.isLazyInit()) {
10                 if (isFactoryBean(beanName)) {
11                     final FactoryBean factory =
12                         (FactoryBean) getBean(FACTORY_BEAN_PREFIX+ beanName);
13                     boolean isEagerInit;
14                     if (System.getSecurityManager() != null
15                         && factory instanceof SmartFactoryBean) {
16                         isEagerInit = AccessController.doPrivileged(
17                             new PrivilegedAction<Boolean>() {
18                             public Boolean run() {
19                                 return ((SmartFactoryBean) factory).isEagerInit();
20                             }
21                         }, getAccessControlContext());
22                     }
23                     else {
24                         isEagerInit = factory instanceof SmartFactoryBean
25                             && ((SmartFactoryBean) factory).isEagerInit();
26                     }
27                     if (isEagerInit) {
28                         getBean(beanName);
29                     }
30                 }
31                 else {
32                     getBean(beanName);
33                 }
34             }
35         }
36     }
37 }

这里出现了一个很是重要的 Bean—— FactoryBean，能够说 Spring 一大半的扩展的功能都与这个 Bean 有关，这是个特殊的 Bean 是一个工厂 Bean，能够产生 Bean 的 Bean，这里的产生 Bean 是指 Bean 的实例，若是一个类继承 FactoryBean 用户只要实现它的 getObject 方法，就能够本身定义产生实例对象的方法。然而在 Spring 内部这个 Bean 的实例对象是 FactoryBean，经过调用这个对象的 getObject 方法就能获取用户自定义产生的对象，从而为 Spring 提供了很好的扩展性。Spring 获取 FactoryBean 自己的对象是在前面加上 & 来完成的。如何建立 Bean 的实例对象以及如何构建 Bean 实例对象之间的关联关系式 Spring 中的一个核心关键，下面是这个过程的流程图。

若是是普通的 Bean 就直接建立它的实例，是经过调用 getBean 方法。下面是建立 Bean 实例的时序图：

还有一个很是重要的部分就是创建 Bean 对象实例之间的关系，这也是 Spring 框架的核心竞争力，什么时候、如何创建它们之间的关系：

IoC 容器的扩展点

如今还有一个问题就是如何让这些 Bean 对象有必定的扩展性，就是能够加入用户的一些操做。那么有哪些扩展点呢？ Spring 又是如何调用到这些扩展点的？对 Spring 的 Ioc 容器来讲，主要有这么几个。BeanFactoryPostProcessor， BeanPostProcessor。它们分别是在构建 BeanFactory 和构建 Bean 对象时调用。还有就是 InitializingBean 和 DisposableBean，他们分别是在 Bean 实例建立和销毁时被调用。用户能够实现这些接口中定义的方法，Spring 就会在适当的时候调用他们。还有一个是 FactoryBean 他是个特殊的 Bean，这个 Bean 能够被用户更多的控制。这些扩展点一般也是咱们使用 Spring 来完成咱们特定任务的地方，如何精通 Spring 就看你有没有掌握好 Spring 有哪些扩展点，而且如何使用他们，要知道如何使用他们就必须了解他们内在的机理。能够用下面一个比喻来解释。
咱们把 Ioc 容器比做一个箱子，这个箱子里有若干个球的模子，能够用这些模子来造不少种不一样的球，还有一个造这些球模的机器，这个机器能够产生球模。那么他们的对应关系就是：BeanFactory 是那个造球模的机器，球模就是 Bean，而球模造出来的球就是 Bean 的实例。那前面所说的几个扩展点又在什么地方呢？ BeanFactoryPostProcessor 对应到当造球模被造出来时，你将有机会能够对其作出适当的修正，也就是他能够帮你修改球模。而 InitializingBean 和 DisposableBean 是在球模造球的开始和结束阶段，你能够完成一些预备和扫尾工做。BeanPostProcessor 就可让你对球模造出来的球作出适当的修正。最后还有一个 FactoryBean，它但是一个神奇的球模。这个球模不是预先就定型了，而是由你来给他肯定它的形状，既然你能够肯定这个球模型的形状，固然他造出来的球确定就是你想要的球了，这样在这个箱子里你能够发现全部你想要的球。

Ioc 容器如何使用

咱们使用 Spring 必需要首先构建 Ioc 容器，没有它 Spring 没法工做，ApplicatonContext.xml 就是 IoC 容器的默认配置文件，Spring 的全部特性功能都是基于这个 Ioc 容器工做的，好比AOP。IoC 它实际上就是为你构建了一个魔方，Spring 为你搭好了骨骼架构，这个魔方到底能变出什么好的东西出来，这必需要有你的参与。那咱们怎么参与？这就是前面说的要了解 Spring 中有哪些扩展点，咱们经过实现那些扩展点来改变 Spring 的通用行为。至于如何实现扩展点来获得咱们想要的个性结果，Spring 中有不少例子，其中 AOP 的实现就是 Spring 自己实现了其扩展点来达到了它想要的特性功能。

经过从 Spring 的几个核心组件入手，试图找出构建 Spring 框架的骨骼架构，进而分析 Spring 在设计时的一些设计理念，是否从中找出一些好的设计思想，对咱们之后程序设计能提供一些思路。接着再详细分析了 Spring 中是如何实现这些理念的，以及在设计模式上是如何使用的。经过分析 Spring 给我一个很大的启示就是这套设计理念其实对咱们有很强的借鉴意义，它经过抽象复杂多变的对象，进一步作规范，而后根据它定义的这套规范设计出一个容器，容器中构建它们的复杂关系，其实如今有不少状况均可以用这种相似的处理方法。

3、Spring的特性

3.一、一些概念

1   应用程序：是能完成咱们所须要功能的成品，好比购物网站、OA系统。
2   框架：是能完成必定功能的半成品，好比咱们可使用框架进行购物网站开发；框架作一部分功能，咱们本身作一部分功能，这样应用程序就建立出来了。并且框架规定了你在开发应用程序时的总体架构，提供了一些基础功能，还规定了类和对象的如何建立、如何协做等，从而简化咱们开发，让咱们专一于业务逻辑开发。
3   非侵入式设计：从框架角度能够这样理解，无需继承框架提供的类，这种设计就能够看做是非侵入式设计，若是继承了这些框架类，就是侵入设计，若是之后想更换框架，以前写过的代码几乎没法重用，若是非侵入式设计则以前写过的代码仍然能够继续使用。
4   轻量级及重量级：轻量级是相对于重量级而言的，轻量级通常就是非入侵性的、所依赖的东西很是少、资源占用很是少、部署简单等等，其实就是比较容易使用，而重量级正好相反。
5   POJO：POJO（Plain Old Java Objects）简单的Java对象，它能够包含业务逻辑或持久化逻辑，但不担当任何特殊角色且不继承或不实现任何其它Java框架的类或接口。
6   容器：在平常生活中容器就是一种盛放东西的器具，从程序设计角度看就是装对象的的对象，由于存在放入、拿出等操做，因此容器还要管理对象的生命周期。
7   控制反转：即Inversion of Control，缩写为IoC，控制反转还有一个名字叫作依赖注入（Dependency Injection），就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。
8   Bean：通常指容器管理的对象，在Spring中指Spring IoC容器管理的对象。

3.二、Spring的优势

很是轻量级的容器：以集中的、自动化的方式进行应用程序对象建立和装配，负责对象建立和装配，管理对象生命周期，能组合成复杂的应用程序。Spring容器是非侵入式的（不须要依赖任何Spring特定类），并且彻底采用POJOs进行开发，使应用程序更容易测试、更容易管理。并且核心JAR包很是小，Spring3.0.5不到1M，并且不须要依赖任何应用服务器，能够部署在任何环境（Java SE或Java EE）。
AOP：面向切面编程提供从另外一个角度来考虑程序结构以完善面向对象编程（OOP），便可以经过在编译期间、装载期间或运行期间实如今不修改源代码的状况下给程序动态添加功能的一种技术。通俗点说就是把可重用的功能提取出来，而后将这些通用功能在合适的时候织入到应用程序中；好比安全，日志记录，这些都是通用的功能，咱们能够把它们提取出来，而后在程序执行的合适地方织入这些代码并执行它们，从而完成须要的功能并复用了这些功能。
简单的数据库事务管理：在使用数据库的应用程序当中，本身管理数据库事务是一项很让人头疼的事，并且很容易出现错误，Spring支持可插入的事务管理支持，并且无需JavaEE环境支持，经过Spring管理事务能够把咱们从事务管理中解放出来来专一业务逻辑。
JDBC抽象及ORM框架支持：Spring使JDBC更加容易使用；提供DAO（数据访问对象）支持，很是方便集成第三方ORM框架，好比Hibernate，Mybatis等；而且彻底支持Spring事务和使用Spring提供的一致的异常体系。
灵活的Web层支持：Spring自己提供一套很是强大的MVC框架，并且能够很是容易的与第三方MVC框架集成，好比Struts等。
简化各类技术集成：提供对Java Mail、任务调度、JMX、JMS、JNDI、EJB、动态语言、远程访问、Web Service等的集成。

4、总结

在Spring中，咱们知道了其中的本质——‘道’，而后在‘术’上进行实现，而且发现spring中提供了不少的扩展，今后对spring有了更深的理解，同时随着版本的递增，其中的各类功能也进行了不少的优化和提高，咱们最好多阅读一下spring的源代码，从中明白不少程序背后的机理。

参考文献：https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/

http://www.javashuo.com/article/p-kmqkslzg-o.html