Spring 技术内幕: 深入解析 Spring 架构与设计原理精简版

本书主要介绍了 Spring 框架的核心知识点，包括 Spring 的整体架构，AOP，IoC，Spring MVC，数据库操作，事务管理等。书中引用了大量的源码来说明各个组件的工作流程，这也导致了语句的概括性不强，需要仔细阅读所有内容。这边做一个简单的复制粘贴，方便大家阅读。如有侵权，请联系删除。

第1章 Spring 的设计理念和整体架构

1.1 Spring 的各个子项目

Spring Framework (Core):这是我们熟知的Spring项目的核心。
Spring Framework(Core)中包含了一系列IoC容器的设计，提供了依赖反转模式的实现; 同时，还集成,了AOP功能，另外，在Spring Framework (Core)中，还包含了其他Spring的基本模块，比如MVC、JDBC、事务处理模块的实现。

1.2 Spring 的设计目标

• Spring 为开发者提供的是一个一站式的轻量级应用开发框架(平台)…

• Spring 抽象了我们在许多应用开发中遇到的共性问题.

• 在设计上把Spring划分为核心（Ioc，AOP）、组件（MVC，JDBC，事务处理，远程调用）和应用（Spring Flex，安全框架ACEGI）3个基本的层次。

• Spring的设计理念–面向接口开发而不依赖于具体的产品实现。

1.3 Spring 的整体架构

Spring 的基本组成模块：

• Spring IoC:

  • 包含了最为基本的IoC容器BeanFactory的接口与实现，
    Spring还设计了IoC容器的高级形态ApplicationContext应用上下文供用户使用，
  • 通过IoC容器实现的依赖反转，把依赖关系的管理从Java对象中解放出来，交给了IoC容器 (或者说是Spring框架) 来完成，从而完成了对象之间的关系解耦:原来的对象 -对象的关系，转化为对象-IoC容器-对象的关系，通过这种对象-IoC容器-对象的关系，更体现出IoC容器对应用的平台作用。

• Spring AOP:

  • 这也是Spring的核心模块，围绕着AOP的增强功能，Spring集 成了AspectJ作为AOP的一个特定实现，同时还在JVM动态代理/CGLIB的基础上，实现了一个AOP框架，作为Spring集成其他模块的工具，比如TransactionProxyFactoryBean声明式事务处理，就是通过AOP集成到Spring中的。

• Spring MVC:

  • Spring MVC就是这样一个模块，这个模块以DispatcherServlet为核心，实现了MVC模式，包括怎样与Web容器环境的集成，Web请求的拦截、分发、处理和ModelAndView数据的返回，以及如何集成各种UI视图展现和数据表现，如PDF、Excel等，通过这个模块，可以完成Web的前端设计。

• Spring JDBC/Spring ORM:

  • Spring对JDBC做了一 层封装，使通过JDBC完成的对数据库的操作更加简洁。
  • SpringJDBC包提供了JdbcTemplate作为模板类，封装了基本的数据库操作方法，如数据的查询、更新等.
  • Spring还提供了许多对ORM工具的封装，这些封装包括了常用的ORM工具，如Hibernate、iBatis等， 这一层封装的作用是让应用更方便地使用这些ORM工具，而不是替代这些ORM工具，比如可以把对这些工具的使用和Spring提供的声明式事务处理结合起来。
  • 同时，Spring还提供了许多模板对象，如HibernateTemaplate这样的工具来实现对Hibernate的驱动，这些模板对象往往包装使用Hibernate的一些通用过程，比如Session的获取和关闭、事务处理的关联等，从而把一些通用的特性实现抽象到Spring中来，更充分地体现了Spring的平台作用。
  • 模板对象 HibernateTemplate 是 spirng-orm.jar 提供的, 可以用来驱动 Hibernate. 比如Session 的获取和关闭, 事务处理的关联等.

• Spring事务处理:

  • Spring事 务处理是一个通过Spring AOP实现自身功能增强的典型模块。
  • 在这个模块中，Spring把在企业应用开发中事务处理的主要过程抽象出来，并且简洁地通过AOP的切面增强实现了声明式事务处理的功能。
  • 这个声明式事务处理的实现，使应用只需要在IoC容器中对事务属性进行配置即可完成，同时，这些事务处理的基本过程和具体的事务处理器实现是无关的，也就是说，应用可以选择不同的具体的事务处理机制，如JTA、JDBC、Hibernate等。
  • 因为使用了声明式事务处理，这些具体的事务处理机制被纳入Spring事务处理的统一框架中完成，并完成与具体业务代码的解耦。

1.4 Spring 的应用场景

• Spring是-一个非侵入性(non-invasive) 框架，其目标是使应用程序代码对框架的依赖最小化，应用代码可以在没有Spring或者其他容器的情况下运行。

• Spring提供了一个一致的编程模型，使应用直接使用POJO开发，从而可以与运行环境(如应用服务器)隔离开来。

• Spring推动应用的设计风格向面向对象及面向接口编程转变，提高了代码的重用性和可测试性。

• Spring改进了体系结构的选择，虽然作为应用平台，Spring 可以帮助我们选择不同的技术实现，比如从Hiberante切换到其他ORM工具，从Struts切换到Spring MVC,尽管我们通常不会这样做，但是我们在技术方案.上选择使用Spring作为应用平台，Spring至少为我们提供了这种可能性和选择，从而降低了平台锁定的风险。

1.5 小结

本章简要回顾了Spring的设计理念、架构设计和应用场景。

第2章 Spring Framework 的核心: IoC 容器的实现

2.1 Spring IoC 容器概述

2.1.1 IoC 容器和依赖反转模式

• 依赖反转: 依赖对象的获得被反转了.

• 控制反转是关于一个对象如何获取它所依赖的对象的引用，在这里，反转指的是责任的反转。

• 通过使用IoC容器，对象依赖关系的管理被反转了，转到IoC容器中来了。

• 对象之间的相互依赖关系由IoC容器进行管理，并由Ioc容器完成对象的注入。这样就在很大程度上简化了应用的开发，

• 如果对面向对象系统中的对象进行简单分类，会发现除了一部分是数据对象外，其他很大一部分对象是用来处理数据的。这些对象并不常发生变化，是系统中基础的部分。同时，这些对象之间的相互依赖关系也是比较稳定的，一般不会随着应用的运行状态的改变而改变。这些特性使这些对象非常适合由IoC容器来管理.

2.2 loC容器 系列的设计与实现: BeanFactory和ApplicationContext

• 在Spring IoC容器的设计中，我们可以看到两个主要的容器系列，
• 一个是实现BeanFactory接口的简单容器系列，这系列容器只实现了容器的最基本功能;
• 另一个是ApplicationContext应用上下文，它作为容器的高级形态而存在。
• 应用上下文在简单容器的基础上，增加了许多面向框架的特性，同时对应用环境作了许多适配。

2.2.1 Spring的IoC容器系列

• BeanFactory接口是作为一个最基本的接口类出现在Spring的IoC容器体系中的。

• 在这些Spring提供的基本IoC容器的接口定义和实现的基础上，Spring通过定义BeanDefinition来管理基于Spring的应用中的各种对象以及它们之间的相互依赖关系。

• BeanDefinition抽象了我们对Bean的定义，是让容器起作用的主要数据类型。

• 在计算机世界里，所有的功能都是建立在通过数据对现实进行抽象的基础上的。

• IoC容器是用来管理对象依赖关系的，对IoC容器来说，BeanDefinition就是对依赖反转模式中管理的对象依赖关系的数据抽象，也是容器实现依赖反转功能的核心数据结构，依赖反转功能都是围绕对这个BeanDefinition的处理来完成的。

2.2.2 Spring loC容器的设计

• 从接口BeanFactory到HierarchicalBeanFactory，再到ConfigurableBeanFactory, 是一条主要的BeanFactory设计路径。

• 在这条接口设计路径中，BeanFactory接口定 义了基本的IoC容器的规范。

• 在这个接口定义中，包括了getBean()这样的IoC容器的基本方法(通过这个方法可以从容器中取得Bean)。

• 而HierarchicalBeanFactory接 口在继承了BeanFactory的基本接口之后，增加了getParentBeanFactory()的接口功能，使BeanFactory具备了双亲IoC容器的管理功能。

• 在接下来的ConfigurableBeanFactory接口中，主要定义了一些对BeanFactory的配置功能，比如通过setParentBeanFactory()设置双亲IoC容器，通过addBeanPostProcessor()配置Bean后置处理器，等等。

• 第二条接口设计主线是，以ApplicationContext应 用上下文接口为核心的接口设计，这里涉及的主要接口设计有，从BeanFactory到ListableBeanFactory，再到ApplicationContext，再到我们常用的WebApplicationContext或者ConfigurableApplicationContext接口。

• 我们常用的应用上下文基本.上都是ConfigurableApplicationContext或者WebApplicationContext的实现。

• 在ListableBeanFactory接口中， 细化了许多BeanFactory的接口功能，比如定义了getBeanDefinitionNames()接口方法;

• 对于ApplicationContext接口，它通过继承MessageSource. ResourceLoader.ApplicationEventPublisher接口，在BeanFactory简 单IoC容器的基础上添加了许多对高级容器的特性的支持。

2.3 loC容器的初始化过程

• 简单来说，IoC容器的初始化是由前面介绍的refresh()方法来启动的，这个方法标志着IoC容器的正式启动。

• 具体来说，这个启动包括BeanDefinition的Resouce定位、载入和注册三个基本过程。

• 在分析之前，要提醒读者注意的是，Spring把这 三个过程分开，并使用不同的模块来完成，如使用相应的ResourceLoader. BeanDefinitionReader等 模块，通过这样的设计方式，可以让用户更加灵活地对这三个过程进行剪裁或扩展，定义出最适合自己的IoC容器的初始化过程。

• 第一个过程是Resource定位过程。

  • 这个Resource定位指的是BeanDefinition的资源定位,它由ResourceLoader通过统一的Resource接口来完成，这个Resource对各种形式的BeanDefinition的使用都提供了统一接口。
  • 对于这些BeanDefinition的存在形式，相信大家都
    不会感到陌生。比如，在文件系统中的Bean定义信息可以使用FileSystemResource来进行抽象;在类路径中的Bean定义信息可以使用前面提到的ClassPathResource来使用，等等。
  • 这个定位过程类似于容器寻找数据的过程，就像用水桶装水先要把水找到一样。

• 第二个过程是BeanDefinition的载入。

  • 这个载人过程是把用户定义好的Bean表示成IoC容器内部的数据结构，而这个容器内部的数据结构就是BeanDefinition。
  • 具体来说，这个BeanDefinition实际上就是POJO对象在IoC容器中的抽象，通过这个BeanDefinition定义的数据结构，使IoC容器能够方便地对POJO对象也就是Bean进行管理。

• 第三个过程是向IoC容器注册这些BeanDefinition的过程。

  • 这个过程是通过调用BeanDefinitionRegistry接口的实现来完成的。
  • 这个注册过程把载入过程中解析得到的BeanDefinition向IoC容器进行注册。
  • 通过分析，我们可以看到，在IoC容器内部将BeanDefinition注入到一个HashMap中去，IoC容器就是通过这个HashMap来持有这些BeanDefinition数据的。

• 值得注意的是，这里谈的是IoC容器初始化过程，在这个过程中，一般不包含Bean依赖注人的实现。

• 在Spring IoC的设计中，Bean定义的载入和依赖注人是两个独立的过程。

• 依赖注人一般发生在应用第一次通过getBean向容器索取Bean的时候。

2.4 IoC容 器的依赖注入

getBean是 依赖注入的起点，之后会调用createBean,
在这个过程中，Bean对象会依据BeanDefinition定义的要求生成。
在AbstractAutowireCapableBeanFactory中实现了这个createBean,
createBean不但生成了需要的Bean，还对Bean初始化进行了处理，

在Bean的创建和对象依赖注入的过程中，需要依据BeanDefinition中的信息来递归地完成依赖注入。
根据依赖关系，一层一层地完成Bean的创建和注人，直到最后完成当前Bean的创建。
有了这个顶层Bean的创建和对它的属性依赖注入的完成，意味着和当前Bean相关的整个依赖链的注入也完成了。

2.6 小结

介绍了IoC容器和上下文的基本工作原理、容器的初始化过程、依赖注入的实现，等等。

第3章 Spring AOP 的实现

3.1 Spring AOP 概述

3.1.1 AOP 概念回顾

AOP是Aspect-Oriented Programming（面向方面编程或面向切面)的简称，
Aspect是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点(crosscutting concern)。

3.1.2Advice通知

Advice (通知)定义在连接点做什么，为切面增强提供织入接口。
前置通知, 后置通知, 环绕通知, 异常通知等

3.1.3 Pointcut切点

Pointcut (切点)决定Advice通知应该作用于哪个连接点，也就是说通过Pointcut来定义需要增强的方法的集合，这些集合的选取可以按照一定的规则来完成。

3.1.4 Advisor通知器

完成对目标方法的切面增强设计(Advice) 和关注点的设计(Pointcut) 以后，需要一
个对象把它们结合起来，完成这个作用的就是Advisor (通知器)。

第4章 Spring MVC 与 Web 环境

4.2 Web环境中的Spring MVC

• 容器提供了一个宿主环境，在宿主环境中，Spring MVC建立起一个IoC容器的体系。
• 这个IoC容器体系是通过ContextLoaderListener的初始化来建立的，在建立IoC容器体系后，把DispatchServlet作为Spring MVC处理Web请求的转发器建立起来，从而完成响应HTTP请求的准备。

4.3.1 IoC容器启动的基本过程

• IoC容器的启动过程就是建立上下文的过程，该上下文是与ServletContext相伴而生的，同时也是1oC容器在Web应用环境中的具体表现之一。
• 由ContextLoaderListener启动的上下文为根上下文。
• 在根上下文的基础上，还有一个与WebMVC相关的上下文用来保存控制器(DispatcherServlet)需要的MVC对象，作为根上下文的子上下文，构成一个层次化的上下文体系。

4.3.2 Web容器中的上下文设计

为了方便在Web环境中使用IoC容器，Spring为Web应用提供了上下文的扩展接口WebApplicationContext来满足启动过程的需要。

这个WebApplicationContext接口的类层次关系如图4-4所示。

4.3.3 ContextLoader的设计 与实现

• 对于Spring承载的Web应用而言，可以指定在Web应用程序启动时载入IoC容器( 或者称为WebApplicationContext)。
• 这个功能是由ContextLoaderListener这样的类来完成的，它是在Web容器中配置的监听器。
• 这个ContextLoaderListener通过使用ContextLoader来完成实际的WebApplicationContext，也就是IoC容器的初始化工作。
• 这个ContextLoader就像Spring应用程序在Web容器中的启动器。
• 这个启动过程是在Web容器中发生的，所以需要根据Web容器部署的要求来定义ContextLoader，相关的配置在概述中已经看到了，这里就不重复了。

4.4 Spring MVC的设计与实现

4.4.1 Spring MVC的应用场景

DispatcherServlet 作为一个前端控制器，所有的Web请求都需
要通过它来处理，进行转发、匹配、数据处理后，并转由页面进行展现，因此这个DispatcerServlet可以看成是Spring MVC实现中最为核心的部分。

4.4.2 Spring MVC设计概览

• Spring的上下文体系通过ContextLoader和DispatcherServlet建立并初始化。
• 在完成对ContextLoaderListener的初始化以后，Web容器开始初始化DispatcherServlet,这个初始化的启动与在web.xml中对载入次序的定义有关。
• DispatcherServlet会建立 自己的上下文来持有Spring MVC的Bean对象，在建立这个自己持有的IoC容器时，会从ServletContext中得到根上下文作为DispatcherServlet持有上下文的双亲上下文。
• 有了这个根上下文，再对自己持有的上下文进行初始化，最后把自己持有的这个
  上下文保存到ServlelContext中， 供以后检索和使用。

4.4.3 DispatcherServlet的启动和初始化

• 在DispatcherServlet持有的IoC容器的初始化过程中，一个新的上下文被建立起来，这个DispatcherServlet持有的上下文被设置为根上下文的子上下文。
• 可以认为，根上下文是和Web应用相对应的一个上下文，而DispatcherServlet持有的上 下文是和Servlet对应的一个上下文。
• 在一个Web应用中，往往可以容纳多个Servlet存在;
• 与此相对应，对于应用在Web容器中的上下体系，一个根上下文可以作为许多Servlet上下文的双亲上下文。
• 了解了这一一点，对在Web环境中IoC容器中的Bean设置和检索会有更多的了解，因为了解IoC工作原理的读者知道，在向IoC容器getBean时，IoC容器会首先向其双亲上下文去getBean,也就是说，在根上下文中定义的Bean是可以被各个Servlet持有的上下文得到和共享的。
• DispatcherServlet持有的 上下文被建立起来以后，也需要和其他IoC容器一样 完成初始化，这个初始化也是通过refresh方法来完成的。
• 最后，DispatcherServlet给这个 自己持有的上下文命名，并把它设置到Web容器的上下文中，这个名称和在web.xml中设置的DispatcherServlet的Servlet名称有关，从而保证了这个上下文在Web环境上下文体系中的唯一性。

4.4.4 MVC处理HTTP分 发请求

• HandlerMapping的配置和设计原理

  • 在初始化完成时，在上下文环境中已定义的所有HandlerMapping都已经被加载了，这些加载的handlerMappings被放在一个List中并被排序，存储着HTTP请求对应的映射数据。
  • 这个List中的每-个元素都对应着-一个具体handlerMapping的配置，一般每一个handlerMapping可以持有一系列从URL请求到Controller的映射，而Spring MVC提供了一系列的HandlerMapping实现，如图4-1 1所示。
    
  • 以simpleUrHandlerMapping这个handlerMapping为例来分析HandlerMapping的设计与实现。在SimpleUrlHandlerMapping中，定义了一个map来持有一系列的映射关系。
  • 通过这些在HandlerMapping中定义的映射关系，即这些URL请求和控制器的对应关系，使Spring MVC应用可以根据HTTP请求确定一个对应的Contoller。
  • 具体来说，这些映射关系是通过接口类HandlerMapping来封装的，在HandlerMapping接口中定义 了一个geHander方法，通过这个方法，可以获得与HTTP请求对应的HandlerExecutionChain,在这个HandlerExecutionChain
    中，封装了具体的Controller对象。

• 使用HandlerMapping完成请求的映射处理

  • 继续通过SimpleUrlHandlerMapping的实现来分析HandlerMapping的接口方法
    getHandler，该方法会根据初始化时得到的映射关系来生成DispatcherServlet需要的HandlerExecutionChain,也就是说，这个getHandler方法是实际使用HandlerMapping完成请求的映射处理的地方。

• Spring MVC对HTTP请求的分发处理

  • DispatcherServlet是HttpServlet的子 类,与其他HttpServlet-样，可以通过doService()来响应HTTP的请求。
  • 对请求的处理实际上是由doDispatch()来完成的，这个doDispatch方法是DispatcherServlet完成Dispatcher的主要方法,包括准备ModelAndView,调用getHandler来响应HTTP请求，然后通过执行Handler的处理来得到返回的ModelAndView结果,最后把这个ModelAndView对象交给相应的视图对象去呈现。
  • 经过上面一系列的处理，得到了handler对象，接着就可以开始调用handler对象中的
    HTTP响应动作了。
    在handler中封装了应用业务逻辑，由这些逻辑对HTTP请求进行相应的处
    理，生成各种需要的数据，并把这些数据封装到ModelAndView对象中去，这个
    ModelAndView的数据封装是Spring MVC框架的要求。

4.6小结

整个Spring MVC的运作是以DispatcherServlet为中心进行控制的。
总的来说，Spring MVC的实现大致由以下几个步骤完成:

• 需要建立Controller控制器和HTTP请求之间的映射关系，即在Spring MVC实现中是如何根据请求得到对应的Controller的?通过分析可以看到，在Spring MVC中，这个工作是由在handlerMapping中封装的HandlerExecutionChain对象来完成的，而对Controller控制器和HTTP请求的映射关系的配置是在Bean定义中描述，并在IoC容器初始化时，通过初始化HandlerMapping来完成的，这些定义的映射关系会被载入到一个handlerMap中使用。
• 在初始化过程中，Controller对 象和HTTP请求之间的映射关系建立好以后，为Spring MVC接收HTTP请求并完成响应处理做好了准备。在MVC框架接收到HTTP请求的时候，DispatcherServlet会根据具体的URL请求信息，在HandlerMapping中 进行查询，从而得到对应的HandlerExecutionChain。在这HandlerExecutionChain中封装了配置的Controller,这个请求对应的Controller会完成请求的响应动作，生成需要的ModelAndView对象，这个对象就像它的名字所表示的-样，可以从该对象中获得Model模型数据和视图对象。
• 得到ModelAndView以后, DispatcherServlet把获得 的模型数据交给特定的视图对象,从而完成这些数据的视图呈现工作。这个视图呈现由视图对象的render方法来完成。毫无疑问，对应于不同的视图对象，render方法会完成不同的视图呈现处理，为用户提供丰富的Web UI表现。

第 5 章 数据库操作组件的实现

5.5 Spring驱动Hibernate的设计与实现

5.5.1设计原理

• 我们知道，Spring的ORM模块 并不是重新开发像Hibernate这样的ORM产品，而是通过IoC容器和AOP模块对Hibernate的使用进行封装。
• 在使用Hibernate的时候，我们]需要对Hibernate进行配置，这些配置通过SessionFactory来完成，在Spring的Hibernate模块中， 提供了LocalSessionFactoryBean来封装SessionFactory的配置，通过这个LocalSessionFactory封装，可以将SessionFactory的配置信息通过Bean定义，注人到IoC容器中实例化好的SessionFactory单件对象中。
• 这个LocalSessionFactoryBean设计为Hibernate的使用奠定了基础。
• 在提供了SessionFactory的封装以后，熟悉Hibermate使 用的读者都知道，对持久化数据进行操作是通过Session来完成的。
• 在Spring中 ，同样对Session的使用进行了封装,和前面的JdbcTemplate-样， Spring封装 了HibernateTemplate模板，在HibernateTemplate模板中， 通过使HibernateTemplate就不需要直接对Session进行操作，相关的数据库操作都由Spring封装好了。
• 在Spring的Hibernate模块设计中，还对使用Hibernate的事务处理进行了封装，通过封装,将Hibernate的持久化数据操作纳入到Spring统一的事务处理框架中，而这部分是通过Spring的AOP来实现的，我们看到的是HibernateTransactionManager的设计。
• 作为PlatformTransactionManager的子类，HibernateTransactionManager实现 了和Hibernate事务处理相关的通用过程。

第6章 Spring事务处理的实现

6.1 Spring与事务处理

• Spring借 助IoC容器的强大配置能力，为应用提供了声明式的事务划分方式，这种声明式的事务处理，为Spring应用使用事务管理提供了统一的方式。
• 有了Spring事务管理的支持，只需要通过一些简单的配置，应用就能完成复杂的事务处理工作，从而为用户使用事务处理提供很大的方便。

6.2 Spring事务 处理的设计概览

• Spring事 务处理模块是通过AOP功能来实现声明式事务处理的，比如事务属性的配置和读取，事务对象的抽象等。
• 因此，在Spring事务处理中，可以通过设计一个TransactionProxyFactoryBean来使用AOP功能，通过这个TransactionProxyFactoryBean可以生成Proxy代理对象，在这个代理对象中，通过TransactionInterceptor来完成对代理方法的拦截，正是这些AOP的拦截功能，将事务处理的功能编织进来。

6.3 Spring事务处理的应用场景

Spring作为应用平台或框架的设计出发点是支持POJO的开发，这点在实现事务处理的时候也不例外。在Spring中， 它既支持编程式事务管理方式，又支持声明式事务处理方式，在使用Spring处理事务的时候，声明式事务处理通常比编程式事务管理更方便一些。

6.4 Spring声明式事务处理

在使用Spring声明式事务处理的时候，一种常用的方法是结合IoC容器和Spring已有的TransactionProxyFactoryBean对事务管理进行配置，比如，可以在这个TransactionProxyFactoryBean中为事务方法配置传播行为、并发事务隔离级别等事务处理属性，从而对声明式事务的处理提供指导。

声明式事务处理的实现大致可以分为以下几个部分:

• 读取和处理在IoC容器中配置的事务处理属性，并转化为Spring事务处理需要的内部数据结构。
• Spring事务处理模块实现统一的事务处理过程。这个通用的事务处理过程包含处理事务配置属性，以及与线程绑定完成事务处理的过程，Spring通 过TransactionInfo和TransactionStatus这两个数据对象，在事务处理过程中记录和传递相关执行场景。
• 底层的事务处理实现。对于底层的事务操作，Spring委托给具体的事务处理器来完成，这些具体的事务处理器，就是在IoC容器中配置声明式事务处理时，配置的PlatformTransactionManager的具体实现，比如DataSourceTransactionManager和HibernateTransactionManager等。

6.5 Spring事务处理的设计与实现

6.5.2事务的创建

6.5.3事 务的挂起

6.5.4事务的提交

6.5.5事务的回滚

6.6 Spring事务处理器的设计与实现

6.6.3 Hibernate TransactionManager的实现

• 在调用Hibernate-TransactionManager的doBegin方法后，HibernateTransactionManager会打开一个Session,
• 关于这个Session,熟悉Hibernate使用的读者都知道，它是Hibermate的核心类 ，Hibernate通过它来管理数据对象的生命周期，
• 在得到Session之后，通过它可以得到Hibernate的Transaction,并对Transaction的参数进行设置，这些设置包括像Timeout这样的参数，然后就可以启动Hibernate的Transaction，并最终通过TransactionSynchronizationManager来绑定资源。
• 在这里我们看到了Hibernate TransactionManager对事务处理的实现，这些最终的事务处理是通过调用Hibernate的Transaction的commit和rollback方法来完成的，与单独使用Hibernate的事务处理没有太多区别。
• 需要注意的是，对使用的Session和Transaction的取得，因为涉及并发事务处理，所以这些对象往往都是与线程绑定的，Spring通过一个SessionHolder来完成对这些事务对象的管理，并通过ThreadLocal对象来实现和线程的绑定。