Spring核心技术

Ch1. Spring概述

Spring为企业应用的开发提供了一个轻量级的解决方案，包括基于依赖注入的核心机制，基于AOP的声明式事务管理，与多种持久层技术的整合，以及优秀的Web MVC框架等。Spring支持对POJO（Plain Object Java Object，指最传统的Java对象，和任何模式都无关）的管理。

    Spring的作者是Rod Johnson。Spring独立于应用服务器，甚至无需应用服务器的支持。

1.    Spring体系介绍

l         核心机制

l         Context容器

l         Web支持

l         MVC框架

l         DAO支持

l         ORM支持

l         面向方面编程支持

1.1Sping的核心和Context

Spring使用BeanFactory作为应用中负责生产和管理各组件的工厂，同时也还是组件运行的容器。BeanFactory根据配置文件确定容器中bean的实现，管理bean之间的依赖关系。ApplicationContext是BeanFactory的增强，该接口提供了在J2EE应用中的大量增强功能。

1.2Spring的Web和MVC

Spring的Web框架围绕分发器（DispatcherServlet）设计，DispatcherServlet将请求分发到不同的处理器。Spring的MVC框架提供清晰的角色划分：控制器、验证器、命令对象、表单对象和模型对象、分发器、处理器映射和视图解析器。Sping支持多种表现层技术：Velocity、XSLT等等；甚至可以直接输出pdf电子文档，或者excel文档。

1.3Spring的面向方面的编程

AOP完善Spring的依赖注入（DI）。AOP提供声明式事务管理。Spring支持用户自定义切面。Spring也能和AspectJ整合。

1.4Spring的持久化支持

对各种持久化技术提供一致的编程方式。

2.    Spring的基本设计思想

Spring实现了两种设计模式：工厂模式和单例模式。

例如：使用Spring至少有一个好处，即使没有PersonFactory，程序一样可以使用工厂模式，所有工厂模式的功能，Spring都可以提供。Spring对接受容器管理的bean，默认采用单体模式管理。

3.    Spring的核心机制

依赖注入（Dependency Injection）和控制反转（Inversion of Control）是同一个概念。具体含义是：当某个角色需要调用另一个角色的协助时，在传统的程序设计中，通常由调用者创建被调用者的实例。但在Spring中，创建被调用者的工作不再由调用者完成，因此称作控制反转；创建被调用者的实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。Spring的依赖注入对于调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。依赖注入通常有两种：设值注入和构造注入。

3.1设值注入

通过setter方法来传入被调用者的实例。Spring会自动接管每个bean定义里的property元素定义。Spring会在执行无参构造函数和创建默认的bean实例后，调用对应的setter方法为程序注入属性值。Property定义的属性值将不再由该bean来主动创建、管理。而改为被动接受Spring的注入。业务对象的更换变得相当简单，对象和对象之间的依赖关系从代码里分离出来，通过配置文件动态管理。

3.2构造注入

通过构造函数完成依赖关系的设定。区别在于：创建Person实例中Axe属性的时机不同――设值注入是先创建一个默认的bean实例，然后调用对应的setter方法注入依赖关系；而构造注入则在创建bean实例时，已经完成依赖关系的注入。

注入方式
 优点
 
设值注入
 （1）         直观

（2）         对于复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，性能下降

（3）         属性可选时，多参数的构造器更加笨重
 
构造注入
 （1）         可在构造器中决定依赖关系的注入顺序

（2）         无需担心后续代码的破坏

（3）         更符合高内聚原则
 

建议采用设值注入为主，构造注入为辅的注入策略。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Ch2 Spring中的bean和BeanFactory

1.    Bean

1.1定义bean时，必须指定两个属性：

（1）      id:确定bean的唯一标识符。

（2）      class:bean的具体实现类。

 

1.2bean的基本行为

单例（singleton）和原型（prototype）两类。每次请求单例的bean，返回同一个对象；对于non-singleton行为的bean，BeanFactory角色的行为几乎完全等于new关键字的作用，每次请求都将产生新的实例。可以通过singleton="true"来设定bean的基本行为。建议Spring中的bean应满足以下几个原则：

（1）每个bean的实现类都应该提供无参数的构造函数。

（2）接受构造注入的bean，则应提供对应的构造函数。

（3）接受设值注入的bean，则应提供对应的setter方法，并不强制提供对应的getter方法。

 

1.3 实例化bean

3种方法：

（1）调用构造函数“new”一个实例。

（2）BeanFactory调用某个类的静态工厂方法创建bean。

主要有以下变化：

l         class元素不再是bean的实现类，而是静态工厂类。

l         必须有factory-method属性确定产生实例的静态工厂方法。

l         静态工厂方法需要参数，则使用<constructor-arg>元素确定静态工厂方法。

（3）      BeanFactory调用实例工厂方法创建bean。

采用实例工厂方法创建bean不能含有class元素，应指定如下两个属性：

l         工厂bean的id，该id属性应该对应Spring容器中的一个工厂bean。

l         工厂方法名，该方法可以产生bean实例。

与调用静态工厂方法的区别：

l         实例工厂方法，必须将实例工厂配置成bean实例；调用静态工厂方法，无需配置工厂bean。

l         实例工厂方法，必须使用factory-bean属性确定工厂bean；而静态工厂方法创建bean，则使用class元素确定静态工厂类。

 

1.4            bean特性的深入

BeanFactory和ApplicationContext初始化容器中bean的时机不同，前者等到程序需要bean实例的时候才创建bean；后者等到加载ApplicationContext实例时，会自动创建容器中的全部bean。Bean的依赖通常可以接受如下元素指定值：

l         value

l         ref：对属性值是其他bean的情况，推荐采用ref，而不是value。ref的两个属性：bean用于确定不在同一个XML配置文件中的bean；而local用于确定在同一个XML配置文件中其他bean，并且local属性只能是其他bean的id属性。

l         bean：定义嵌套bean实例属性，而不是Spring中已经存在的bean，没有id属性。损失了灵活性，提高了内聚性。

l         list、set、map以及props：分别用于设置类型为List、Set、Map和Propertis的属性值。

1.4.1    使用depends-on强制初始化bean

1.4.2    自动装配

自动装配减少了配置文件的工作量，但降低了依赖关系的透明性和清晰性。设置bean元素的autowire属性，指定自动装配，可取值如下：no、byName、byType、constructor、autodetect。对于大型的应用，不鼓励使用自动装配，不利于高层次解耦。

1.4.3    依赖检查

默认是不使用依赖检查，通过bean元素的dependency-check属性来设置依赖检查，该属性有以下的值：none、simple、object、all。

1.5            Bean的生命周期

1.5.1    协调不同步的bean

当singleton bean依赖于non-singleton bean时，singleton bean只有一次初始化机会，依赖关系的设置也在初始化时进行，会产生不同步现象。解决办法是利用方法注入。要保证lookup方法注入每次产生新的bean实例，必须将目标bean部署成non-singleton。否则，由于容器中只有一个bean实例，即使采用lookup方法注入，每次依然返回同一个bean实例。Lookup方法注入不仅用于设值注入，也可以用于构造注入。

1.5.2    定制bean的生命周期行为

管理bean的生命周期行为主要为如下两个时机：

l         bean的全部依赖注入之后。Spring提供2种方式在bean的全部属性设置之后执行特定的行为：使用init-method；实现InitializingBean接口。

l         bean即将被销毁之前。Spring提供2种方式在bean销毁之前执行特定的行为：使用destroy-method；实现DisposableBean接口。

（1） 使用init-method的例子

程序的运行结果如下：

spring实例化依赖bean：steelaxe实例...

spring初始化主调bean：chinese实例...

spring执行依赖关系注入...

正在执行初始化方法...

（2）实现接口InitializingBean或者DisposableBean污染了代码，是侵入式设计，因此不推荐使用。

 

 

 

 

 

 

 

 

 

 

Ch3 bean的高级功能

Bean的管理，是Spring的核心部分。

3.1 bean的继承

子bean定义可以从父bean定义继承部分配置。它也可以覆盖一些配置，或者添加一些配置。

3.1.1 抽象bean

父bean不需要实例化，它只是作为子bean定义的模板使用，而ApplicationContext默认初始化所有的singleton bean，可以使用abstract=”true”来阻止初始化父bean。抽象bean是一个bean模板，容器会忽略所有抽象bean定义，也不会实例化抽象bean，所以抽象bean可以没有class属性。并且只要企图初始化抽象bean，都将导致错误。

3.1.2 定义子bean

子bean可以从父bean继承实现类、构造器参数、属性值，也可增加新的值。如果指定init-method、destroy-method和factory-method属性，则它们会覆盖父bean的定义。

子bean无法从父bean继承如下属性：depends-on、autowire、dependency-check、singleton、lazy-init。在子bean中指定parent属性即可。对于class属性，父子bean中必须指定一个，如果子bean中指定了class属性，则将覆盖父bean中的属性。

3.1.3 Spring中的bean的继承和java中的继承的区别

前者只是实例和实例之间的参数的延续，是对象和对象之间的关系。而后者则是类和类之间的关系。

 
 Spring中的bean继承
 Java中的继承
 
类型
 子bean和父bean可以是不同的类型
 子类是一种特殊的父类
 
表现
 实例之间的关系，表现为参数值的延续
 类之间的关系，表现为方法、属性的延续
 
多态
 子bean不可作为父bean使用，不具备多态性
 子类实例可以作为父类实例使用
 

3.2高级依赖注入

3.2.1 属性值的依赖注入

    通过PropertyPathFactoryBean来完成的。必须指定如下2个属性:

(1)targetBeanName:用于指定目标bean，确定获取哪个bean的属性值。(2)propertyPath:用于指定属性，确定获取目标bean的哪个属性值。

3.2.2 field值的依赖注入

    通过FieldRetrievingFactoryBean来完成的，用来获取目标bean的field值。获得的值可以注入其他bean，也可以直接定义成新的bean。

3.2.3 方法返回值的依赖注入

    通过MethodInvokingFactoryBean来完成的，用来获得某个方法的返回值，该方法既可以是静态方法，也可以是实例方法。获得的值可以注入其他bean，也可以直接定义成新的bean。使用实例方法返回值，必须指定如下2个属性：

（1）targetObject:确定目标bean，该bean既可以是容器中已有的bean，也可以是嵌套bean。

（2）targetMethod：确定目标方法，通过确定目标bean的哪个方法返回值注入。

使用静态方法返回值，必须指定如下2个属性：

（1）targetClass:确定目标class。

（2）targetMethod：确定目标方法，通过确定目标bean的哪个方法返回值注入。

3.3 使用BeanPostProcessor

    如果有更多的方法，需要在被创建时被调用，可使用BeanPostProcessor接口。

3.4 使用BeanFactoryPostProcessor

    如果需要bean在BeanFactory实例化之后，对BeanFactory进行某些处理，可让该bean实现BeanFactoryPostProcessor接口。

    实现BeanFactoryPostProcessor接口的bean能对BeanFactory执行处理，这种bean称其为容器后处理器。Spring提供许多容器后处理器，包括：

（1）PropertyPlaceHolderConfigurer:属性占位符配置器。

（2）PropertyOverrideConfigurer:另一种属性占位符配置器。

如果PropertyOverrideConfigurer属性文件中有对应配置信息，XML文件中的配置信息被覆盖；否则直接使用XML文件中的配置信息。

（3）BeanNameAutoProxyCreator:自动生成代理的辅助类。

3.5 与容器交互

    Spring容器本质上是一个高级“工厂”，负责产生bean的实例。容器通常有2种表现形式：

l         BeanFactory

l         ApplicationContext

3.5.1 工厂bean简介与配置

工厂bean的配置没有什么不同，区别在于产品bean的配置。产品bean不需要提供class元素配置产品bean通常有如下2种方法：

l         使用factory-method属性确定工厂方法

l         将bean方法返回值定义成bean实例

3.5.2 使用FactoryBean接口

可简化工厂bean的开发。

3.5.3 使用BeanFactoryAware获取BeanFactory

3.5.4 使用BeanNameAware回调本身

3.6 ApplicationContext介绍

    Context的基础是ApplicationContext接口，它继承BeanFactory接口，提供BeanFactory所有的功能。为了以一种更面向框架的方式工作，context包使用分层和有继承关系的上下文，包括：

l         MessageSource，提供国际化支持。

l         资源访问，比如URL和文件。

l         事件传递。

l         载入多个配置文件。

3.6.1 国际化支持

    MessageSource Bean的名字必须是messageSource。通常采用Spring的实现类ResourceBundleMessageSource。

3.6.2 事件处理

    是通过ApplicationEvent类和ApplicationListener接口来实现的。如果容器中有一个ApplicationListener bean，每当ApplicationContext发布ApplicationEvent时，ApplicationListener bean将自动响应，这是标准的观察者模式。Spring提供如下3个内置事件：

l         ContextClosedEvent

l         ContextRefreshedEvent

l         RequestHandledEvent

3.6.3 web应用中自动加载ApplicationContext

可通过ContextLoader声明式的创建ApplicationContext。ContextLoader有两个实现类：

l         ContextLoaderListener

l         ContextLoaderServlet

在web.xml中添加如下：

<context-param>

    <param-name>

       contextConfigLocation

    </param-name>

    <param-value>

       /WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml

    </param-value>

</context-param>

<Listener>

    <Listener-class>

       org.springframework.web.context.ContextLoaderListener

    <Listener-class>

</Listener>

 

<servlet>

    <servlet-name>context</servlet-name>

    <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>

    <load-on-startup>1</load-on-startup>

</servlet>

应将context的启动级别设成最小，即最优先启动。

3.7 汇总多个XML配置文件

每个配置文件仅仅配置功能近似的bean，多个配置文件最终的汇总的方式如下：

l         使用ApplicationContext加载多个配置文件；FileSystemXmlApplicationContext和ClassPathXmlApplicationContext的区别在于：前者从当前目录搜索配置文件；而后者从classpath路径搜索配置文件。

l         Web应用启动时加载多个配置文件；通过ContextLoaderListener可以加载多个配置文件。

l         XML配置文件中导入其他配置。元素import可用于导入其他配置文件。

 

Ch4 Spring中的资源访问

    传统的资源访问通常采用java.net.URL和文件IO，操作复杂，对于某些特定的资源，例如访问ServletContext下的某个文件，没有提供专门的API。Spring则通过Resource接口完成，对资源访问提供了更多的包装。

4.1 传统资源访问和Spring的资源访问

1. 传统资源访问

java.net.URL的构造函数如下：

URL(String protocol, String host, int port, String file, URLStreamHandler handler)
Creates a URL object from the specified protocol, host, port number, file, and handler.

2. Spring中的资源访问

Resource直接可以作为资源访问的工具类使用。

Interface Resource

Interface for a resource descriptor that abstracts from the actual type of underlying resource, such as a file or class path resource.

4.2 Resource实现类

4.2.1 访问网络资源

    UrlResource类实现。

4.2.2 使用ClassPathResource

    加载在classpath路径里搜索到的资源。自动搜索位于WEB-INF/classes下的资源文件，无需使用绝对路径。

4.2.3 访问文件系统资源

    通过FileSystemResource访问本地文件系统。与前面的2种访问资源的区别在于：资源字符串确定的资源位于本地文件系统内，而且无需前缀。

4.2.4 访问应用相关资源

    访问web context相对路径的资源，采用ServletContextResource类。通过java.io.File访问要求资源解压缩，而且在本地文件系统内；而使用ServletContextResource则无需关心资源是否被解压，总可通过servlet容器访问。

4.2.5 访问输入流资源

    只有没有合适的Resource实现时，才考虑使用InputStreamResource。通常情况下，优先考虑ByteArrayResource，或者FileSystemResource实现。InputStreamResource是一个被打开的Resource，如果需要多次读取某个流，就不要使用InputStreamResource。

4.2.6 访问字节数组资源

    通过ByteArrayResource来实现对字节数组资源的访问。实际应用中，字节数组可能通过网络传输获得，也可能通过管道流获得。

4.3 ResourceLoader接口和ResourceLoaderAware接口

4.3.1 使用ResourceLoader

实现类可以返回一个Resource类实例。常见前缀：

l         classpath：从classpath加载资源，创建classpath实例。

l         fle：以UrlResource实例访问本地文件系统的资源。

l         http：以UrlResource实例访问web服务的资源

l         无前缀：取决于ApplicationContext的实现。

4.3.2 使用ResourceLoaderAware

部署在容器中的ResourceLoaderAware能够获得容器的引用。

4.4 使用Resource作为属性

如果bean需要访问资源，2种办法：

l         代码中创建Resource实例，资源的位置固定在代码中，不好。

l         使用依赖注入，允许动态配置资源的位置。甚至可以指定资源的访问策略，在配置文件中使用特定前缀，就可使用特定的Resource实现。

4.5 ApplicationContext中使用资源

    确定资源访问策略通常有以下2个办法：

l         ApplicationContext实现类来确定访问策略，通过前缀指定资源访问策略，仅对当次有效，以后还是根据ApplicationContext实现类来确定的。建议显示采用对应的实现类。

l         前缀确定访问策略。Classpath*、“beans*.xml”。

 

Ch5 表现层数据的处理

    类型转换和数据校验是表现层数据处理的两个任务。

5.1表现层数据的处理

5.1.1 类型转换

多种数据类型
 
字符串类型
 
输入
 
输出
 

5.1.2 数据校验

1. 客户端校验

    通常采用JavaScript完成。

2. 服务器端校验

5.2 Spring支持的表现层数据处理

    Spring提供web mvc框架实现，提供：

l         数据绑定，通过spring:bind标签完成。

l         Bean包装，bean包装的核心是BeanWrapper接口，程序中并不直接使用BeanWrapper，而使用DataBinder和BeanFactory，这两个类加强了BeanWrapper的功能。

l         数据校验，通过Validator和Errors类完成。

在web mvc中，数据绑定和数据校验几乎同时完成。

5.3 bean包装

5.3.1 获取修改bean属性

    BeanWrapper接口的方法：

l         setPropertyValue(String propertyName, Object value) 或者setPropertyValue(PropertyValue pv)

l         getPropertyValue(String propertyName)

5.3.2 类型转换

    使用PropertyEditor自动完成类型转换。

5.3.3 内建的PropertyEditor

    有ByteArrayPropertyEditor、ClassEditor、CustomBooleanEditor、CustomCollectionEditor、CustomDateEditor、CustomNumberEditor、FileEditor、InputStreamEditor、LocaleEditor、PropertiesEditor、StringTrimmerEditor、URIEditor等等。

5.3.4 自定义PropertyEditor

    继承java.beans.PropertyEditorSupport，重写setAsText(String text)方法。

5.4 数据校验

    通过Validator和Errors类完成，校验时，Validator将校验错误发送给Errors队象。具体的校验可用ValidationUtils完成。

 

Ch6 Spring对AOP的支持

    AOP不会取代OOP，而是作为OOP的补充。AOP从动态的角度考虑程序结构，提取业务处理过程的切面。AOP框架具有以下2个特征：

l         各个步骤之间的良好隔离性。

l         源代码无关性。

6.1 AOP入门

6.1.1 概念

l         切面：关注点的模块化，关注点可能横切多个对象。

l         连接点：程序运行过程中明确的点，如方法的调用，或者异常的抛出。Spring AOP中，连接点总是方法的调用，Spring并没有显式的使用连接点。

l         处理：AOP框架在特定的连接点执行的动作。处理包括“around”、“before”、“throws”等类型。大部分框架都以拦截器作为处理模型。

l         切入点：系列连接点的集合，它确定处理触发的时机。AOP框架允许开发者自己定义切入点：例如使用正则表达式。

l         引入：添加方法或者字段到被处理的类。Spring允许引入新的接口到任何被处理的对象。例如：可以使用一个引入，使任何对象实现IsModified接口，以此来简化缓存。

l         目标对象：包含连接点的对象；也称为被处理对象，或者被代理对象。

l         AOP代理：AOP框架创建的对象，包含处理。Spring中的AOP代理可以是JDK动态代理，也可以是CGLIB代理。前者为实现接口的目标对象的代理，后者为不实现接口的目标对象的代理。

6.1.2 AOP代理

    AOP代理提供比目标对象更加强大的功能。目标对象是蓝本，AOP代理是目标对象的加强，在目标代理的基础上，增加了属性和方法，提供更加强大的功能。Spring对接口实现类采用Dynamic Proxy实现AOP，而对没有实现任何接口的类，则通过CGLIB实现AOP代理。

6.2 Spring对AOP的支持

    如果处理非常细粒度的对象，AspectJ是更适合的选择。

6.2.1 Spring的切入点

    org.springframework.aop.Pointcut是切入点的抽象。

（1）正则表达式切入点

    org.springframework.aop.support.Perl5RegexpMethodPointcut是Spring的正则表达式切入点。org.springframework.aop.support. JdkRegexpMethodPointcut（默认使用）则是另一种正则表达式切入点。

（2）自定义切入点

    通常继承静态切入点的实现类StaticMethodMatcherPointcut。当然也有动态切入点的超类。

（3）Spring的处理

    同一个处理，可以处理多个目标对象，这种处理称为per-class处理，也可以每个目标对象都有自己的处理，这种处理称为per-instance处理。Spring中的实用处理类型有5种：

l         Around处理，需要实现MethodInterceptor接口。

l         Before处理，不需要MethodInvocation对象，要实现MethodBeforeAdvice接口。

l         Throws处理，当连接点抛出异常时，Throws处理被调用。实现Throws异常，必须实现ThrowsAdvice接口。

l         After Returning处理，和Before非常相似。必须实现AfterReturningAdvice接口。

l         Introduction处理，一种特殊的拦截处理，不能作用于任何切入点。因为它总是作用于类层次，而不是方法层次。需要实现IntroductionAdvisor和IntroductionInterceptor接口。

    “Aspect Oriented Programming”，“面向方面编程”还是“面向切面编程”？目标方法中含有一些共有的过程，将这些过程抽取出来，提高程序的复用性。提取出来的共有操作是必不可少的，必须还原给目标方法：方法是最小的封装体――无法修改！此时，程序需要一个切入点，在此处将共有操作还原到目标方法。这个过程由AOP框架完成，其中共有操作就是处理（Advice）。在上述过程中，切入点不能在方法体内，而被确定在方法调用之前，方法调用之后，或者异常抛出之时。AOP框架负责将共有操作在合适的时机（切入点），还愿给目标方法，生成代理。

（4）Advisor

    Advisor等于切入点加上处理。Advisor是aspect的模块化表示。DefaultPointcutAdvisor是最普通的Advisor类。Spring可在一个AOP代理中混合使用Advisor和处理，将自动创建必要的拦截器。

6.3 创建AOP代理

    org.springframework.aop.framework.ProxyFactoryBean是生成代理的基本途径。配置ProxyFactoryBean时需要确定以下属性：

l         代理的目标

l         是否使用CGLIB

（1）代理类

    如果目标类没有实现接口，需要对类生成代理，而不能为接口生成代理。需使用CGLIB。CGLIB代理在运行期间产生目标对象的子类，该子类通过装饰器模式加入到Advice中。因为CGLIB是目标对象类，则需考虑：

l         目标类不能声明为final，因为final类不能被继承无法生成代理；

l         目标方法也不能声明为final，final方法不能被重写，无法得到处理。

6.4 实用的代理工厂类

    不如ProxyFactoryBean全面，但是简单、实用。例如：

l         org.springframework.transaction.interceptor.TransactionProxyFactoryBean

l         org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean，用于创建EJB代理，通过EJB代理，客户端代码无需进行JNDI查找，也无需使用EJB的create方法。为了使AOP能生成代理，提供另一个普通接口，该接口无需继承任何特殊的类，但接管EJB业务接口中的全部方法。

6.5 简介的代理定义方式

    利用父子bean的继承关系来简化代理的定义。

6.6 自动代理

    通过BeanPostProcessor实现，常用的两个实现类，是aop.framework.autoproxy包中的BeanNameAutoProxyCreator和DefaultAdvisorAutoProxyCreator。通过自动代理，可以：

l         避免每个目标bean定义代理；

l         避免客户端代码调用目标bean。

6.7 编程式创建AOP代理

    通过org.springframework.aop.framework.ProxyFactory完成。通常，不要将AOP配置信息放在java代码中。

6.8 操作代理

    无论怎样创建AOP代理，这些AOP代理都将实现Advised接口。

 

Ch7 Spring的事务管理

    在Spring之前，没有一个比较好的事务管理策略，既能极好的把代码从特定事务API中解耦，又可消除大段的事务管理代码，同时还能跨越多个事务资源。

7.1 使用PlatformTransactionManager接口

7.2 编程式事务

Spring提供如下两种编程式的事务管理

l         使用TransactionTemplate管理事务；推荐采用。

l         直接使用一个PlatformTransactionManager实现类管理事务，类似于JTA，但没有异常处理。

7.3 声明式事务

    通过AOP实现。

结论：尽可能使用声明式事务。

 

 

参考：《Spring 2.0 宝典》 李刚 编著

 

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/nomad2/archive/2007/02/04/1502183.aspx