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 架构与设计原理精简版_第1张图片
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容器的设计

Spring 技术内幕: 深入解析 Spring 架构与设计原理精简版_第2张图片

  • 从接口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所示。
Spring 技术内幕: 深入解析 Spring 架构与设计原理精简版_第3张图片

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所示。
      Spring 技术内幕: 深入解析 Spring 架构与设计原理精简版_第4张图片
    • 以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对象来实现和线程的绑定。

你可能感兴趣的:(土味,spring,aop,ioc,mvc)