Spring的事务管理难点剖析（精通Spring+4.x++企业应用开发实战 第12章）

12.1 DAO和事务管理的牵绊

事务管理的目的是保证数据操作的事务性（原子性，一致性，隔离性，持久性，即ACID），脱离了事务性，DAO可以正常进行数据操作

12.1.1 JDBC访问数据库

记得在pom.xml中引入Spring依赖和commons-dbcp依赖

<!-- 引入Spring依赖-->
<!-- 需引入Spring-orm ,ORM即对象/关系映射,提供数据库访问支持-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- web项目都需要引入-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- DBCP（DataBase Connection Pool）数据库连接池，是java数据库连接池的一种，由Apache开发，通过数据库连接池，可以让程序自动管理数据库连接的释放和断开-->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>${commons-dbcp.version}</version>
</dependency>
<!-- 进行mysql数据连接时需要,提供Driver-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>

<properties>
<file.encoding>UTF-8</file.encoding>
<spring.version>4.2.2.RELEASE</spring.version>
<slf4j.version>1.7.5</slf4j.version>
<mysql.version>5.1.29</mysql.version>
<servlet.version>3.0-alpha-1</servlet.version>
<commons-dbcp.version>1.4</commons-dbcp.version>
<jetty.version>8.1.8.v20121106</jetty.version>
<aspectjweaver.version>1.6.8</aspectjweaver.version>
<hibernate.version>4.2.0.Final</hibernate.version>
</properties>

@Service("userService")   //相当于往容器中装载了一个名为userService的Bean
public class UserJdbcWithoutTransManagerService {
@Autowired
private JdbcTemplate jdbcTemplate;

public void addScore(String userName,int toAdd){
String sql = "UPDATE t_user u SET u.credit = u.credit + ? WHERE user_name =?";
jdbcTemplate.update(sql,toAdd,userName);
}

public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("com/smart/withouttx/jdbc/jdbcWithoutTx.xml");
UserJdbcWithoutTransManagerService service = (UserJdbcWithoutTransManagerService)ctx.getBean("userService");
JdbcTemplate jdbcTemplate = (JdbcTemplate)ctx.getBean("jdbcTemplate");
BasicDataSource basicDataSource = (BasicDataSource)jdbcTemplate.getDataSource();
//①检查数据源autoCommit的设置
System.out.println("autoCommit:"+ basicDataSource.getDefaultAutoCommit());
//②插入一条记录，初始分数为10
jdbcTemplate.execute("INSERT INTO t_user(user_name,password,credit) VALUES('tom','123456',10)");
//③调用工作在无事务环境下的服务类方法,将分数添加20分
service.addScore("tom",20);
//④查看此时用户的分数
int score = jdbcTemplate.queryForObject("SELECT credi
4000
t FROM t_user WHERE user_name ='tom'", Integer.class);
System.out.println("score:"+score);
jdbcTemplate.execute("DELETE FROM t_user WHERE user_name='tom'");
}
}

jdbcWithoutTx.xml配置文件如下

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"> 
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}"/>

<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource"/>

<context:component-scan base-package="com.smart.withouttx.jdbc"/>
</beans>

输出



在配置文件中没有配置任何事务管理器，但数据成功地持久化到数据库中。

在默认情况下，dataSource数据源的autoCommit被设置为true-意味着所有通过JdbcTemplate执行的语句马上提交，没有事务。如果设置为false，再运行，将抛出错误，原因的是新增及更改数据的操作都没有提交到数据库，所以④的操作因无法从数据库中查询到匹配的记录而引发异常

12.1.2 Hibernate访问数据库

Hibernate的事务管理和Hibernate一级缓存存在关系：在调用Session的save，update等方法时，Hibernate并不直接向数据库发送SQL语句，只在提交事务(commit)或flush一级缓存时才真正向数据库发送SQL。

所以，即使底层数据库不支持事务，Hibernate的事务管理也是有一定好处的，不会对数据操作的效率造成负面影响。所以，如果使用Hibernate数据访问技术，则需要配置HibernateTransactionManager事务管理器

如果不使用Hibernate事务管理器，Spring就会采用默认的事务管理策略搜索(PROPAGATION_REQUIRED,readOnly)。如果有修改操作是不允许的，就会抛出异常。

需要引入的依赖

<!-- 引入lang包，需要commons.lang.builder.ReflectionToStringBuilder-->
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.2</version>
</dependency>
<!-- 引入hibernate依赖，访问数据库的表项-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>

@Service("hiberService")   //往容器中添加一个Bean
public class UserHibernateWithoutTransManagerService {
private HibernateTemplate hibernateTemplate;

@Autowired
public void setHibernateTemplate(HibernateTemplate hibernateTemplate){
this.hibernateTemplate=hibernateTemplate;
}
public void addScore(String userName,int toAdd){
User user=hibernateTemplate.get(User.class,userName);
//①以下两条语句取消注释后，由于默认事务管理器不支持数据更改，将报异常
//user.setScore(user.getScore()+toAdd);
//hibernateTemplate.update(user);
}

public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("com/smart/withouttx/hiber/hiberWithoutTx.xml");
UserHibernateWithoutTransManagerService service = (UserHibernateWithoutTransManagerService)ctx.getBean("hiberService");

JdbcTemplate jdbcTemplate = (JdbcTemplate)ctx.getBean("jdbcTemplate");
BasicDataSource basicDataSource = (BasicDataSource)jdbcTemplate.getDataSource();
//①检查数据源autoCommit的设置
System.out.println("autoCommit:"+ basicDataSource.getDefaultAutoCommit());
//②插入一条记录，初始分数为10
jdbcTemplate.execute("INSERT INTO t_user(user_name,password,score,last_logon_time) VALUES('John','123456',10,"+System.currentTimeMillis()+")");

//③调用工作在无事务环境下的服务类方法,将分数添加20分
service.addScore("John",20);

//④查看此时用户的分数
int score = jdbcTemplate.queryForObject("SELECT score FROM t_user WHERE user_name ='John'", Integer.class);
System.out.println("score:"+score);
jdbcTemplate.execute("DELETE FROM t_user WHERE user_name='John'");
}
}

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd ">
<!-- 扫描包下的注释-->
<context:component-scan base-package="com.smart.withouttx.jdbc"/>
<!-- 扫描properties文件-->
<context:property-placeholder location="classpath:jdbc.properties" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}" />
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource"/>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
p:dataSource-ref="dataSource">
<property name="annotatedClassed">
<list>
<value>com.smart.User</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="hibernateTemplate"
class="org.springframework.orm.hibernate4.HibernateTemplate"
p:sessionFactory-ref="sessionFactory"/>
</beans>

正常运行。如果取消①处的注释，程序将报错，说明Hibernate在Spring中，在没有事务管理器的情况下，只能读数据而无法更改数据

12.2 应用分层的迷惑

并不是使用Spring的事务管理就一定要进行三层的划分（Web，Service及DAO）。

Spring所提供的各种好处（如AOP，注解增强，注解MVC等）的唯一前提就是让POJO的类变成一个受Spring容器管理的Bean。下面的实例用一个POJO完成所有的功能，既是Controller，又是Service，还是DAO

//①将POJO类通过注解变成Spring MVC中的Controller
@Controller
public class MixLayerUserService {
//②自动注入JdbcTemplate
private JdbcTemplate jdbcTemplate;
@Autowired
public void setJdbcTemplate(JdbcTemplate jdbcTemplate){
this.jdbcTemplate=jdbcTemplate;
}

//③通过Spring MVC的注解映射成为处理HTTP请求的函数，同时作为一个拥有事务性的方法
@RequestMapping("/logon.do")  //输入logon.do时映射到该方法
@Transactional    //拥有事务性
public String logon(String userName,String password){
if(isRightUser(userName,password)){
String sql="UPDATE t_user u SET u.score=u.score+ ? WHERE user_name= ? ";
jdbcTemplate.update(sql,20,userName);
return "success";
}else {
return "fail";
}
}

private boolean isRightUser(String userName,String password){
//简化判断
return true;
}
}

通过@Controller注解将MixLayerUserService变成Web层的Controller，同时也是Service层的服务类。由于直接使用JdbcTemplate访问数据，所以也是一个DAO

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"> <context:component-scan base-package="com.smart.mixlayer"/>
<context:property-placeholder location="classpath:jdbc.properties"/>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}"/>

<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource"/>
<!-- ①事务管理配置-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="datasource"/>
<tx:annotation-driven/>

<!-- ②启动Spring MVC的注解功能-->
<mvc:annotation-driven/>

<!-- 模型视图名称的解析，即在模型视图名称添加前后缀 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/>
</beans>

要使程序能够运行起来，还必须进行web.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> <servlet>
<servlet-name>user</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:com/smart/mixlayer/applicationContext.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>user</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

默认情况下，Spring MVC根据Servlet的名字查找WEB-INF下的<servletName>servlet.xml作为Spring MVC的配置文件，这里通过contextLocation参数显式指定Spring MVC配置文件

需要引入jetty插件

<build>
<plugins>
<!-- jetty插件 -->
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
<version>6.1.25</version>
<configuration>
<connectors>
<connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
<port>80</port>
<maxIdleTime>60000</maxIdleTime>
</connector>
</connectors>
<contextPath>/forum</contextPath>
<scanIntervalSeconds>0</scanIntervalSeconds>
</configuration>
</plugin>
</plugins>
</build>

log4.properties文件

log4j.rootLogger=INFO,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
#log4j.appender.A1.layout.ConversionPattern=(%F:%L) - %m%n
log4j.appender.A1.layout.ConversionPattern=%m%n
log4j.logger.org.springframework.jdbc=DEBUG
log4j.logger.org.springframework.transaction=DEBUG
log4j.logger.org.springframework.orm.hibernate4=DEBUG

org.springframework.jdbc和org.springframework.transaction日志级别设置为DEBUG，访问http://localhost/forum/logon.do?userName=tom应用，logon()方法将做出响应，查看后台输出日志



粗体部分说明已成功运行在事务上下文中

12.3 事务方法嵌套调用的迷茫

12.3.1 Spring事务传播机制回顾

Spring对事务控制的支持统一在TransactionDefinition类中描述，该类有以下几个重要的接口方法



除了事务的传播行为，事务的其他特性，Spring是借助底层资源的功能来完成的，Spring充当了代理的角色。

所谓的事务传播行为，就是多个事务方法相互调用时，事务如何在这些方法间传播，Spring支持7种事务传播行为



默认传播行为是PROPAGATION_REQUIRED

如果多个ServiceX#methodX()均工作在事务环境中(均被Spring事务增强)，且程序中存在调用链Service1#method1()->Service2#method2()->Service3#method3()，那么这三个服务类的3个方法通过Spring事务传播机制工作在同一个事务中

12.3.2 相互嵌套的服务方法

来看一个实例



logon()方法内部调用了updataLastLogonTime()和ScoreService#addScore()方法

UserService#logon()调用了ScoreService#addScore()方法，二者分别通过Spring AOP进行了事务增强，则它们工作在同一事务中

UserService

@Service("userService")
public class UserService extends BaseService {

private JdbcTemplate jdbcTemplate;

private ScoreService scoreService;

@Autowired
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}

@Autowired
public void setScoreService(ScoreService scoreService) {
this.scoreService = scoreService;
}

public void logon(String userName) {
System.out.println("before userService.updateLastLogonTime...");
updateLastLogonTime(userName);
System.out.println("after userService.updateLastLogonTime...");

System.out.println("before scoreService.addScore...");
scoreService.addScore(userName, 20);
System.out.println("after scoreService.addScore...");

}

public void updateLastLogonTime(String userName) {
String sql = "UPDATE t_user u SET u.last_logon_time = ? WHERE user_name =?";
jdbcTemplate.update(sql, System.currentTimeMillis(), userName);
}

public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("com/smart/nestcall/applicatonContext.xml");
UserService service = (UserService) ctx.getBean("userService");

JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
BasicDataSource basicDataSource = (BasicDataSource) jdbcTemplate.getDataSource();
//插入一条记录，初始分数为10
jdbcTemplate.execute("INSERT INTO t_user(user_name,password,score,last_logon_time) VALUES('tom','123456',10," + System.currentTimeMillis() + ")");

//调用工作在无事务环境下的服务类方法,将分数添加20分
System.out.println("before userService.logon method...");
service.logon("tom");
System.out.println("after userService.logon method...");

jdbcTemplate.execute("DELETE FROM t_user WHERE user_name='tom'");
}
}

ScoreService

@Service("scoreUserService")
public class ScoreService extends BaseService{

private JdbcTemplate jdbcTemplate;

@Autowired
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}

public void addScore(String userName, int toAdd) {
String sql = "UPDATE t_user u SET u.score = u.score + ? WHERE user_name =?";
jdbcTemplate.update(sql, toAdd, userName);
}
}

BaseService

public class BaseService {
}

配置文件，通过Spring配置为ScoreService和UserService中的所有共有方法都添加Spring AOP的事务增强，让两个类中的方法都工作在事务环境下

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"> <context:component-scan base-package="com.smart.nestcall"/>

<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}"/>

<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource"/>
<!--事务管理器 -->
<bean id="jdbcManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:datasource-ref="datasource"/>
<!-- ①通过以下配置为所有继承BaseService类的所有子类的所有public方法都添加事务增强(展现了切面增强的强大)-->
<aop:config proxy-target-class="true">
<aop:pointcut id="serviceJdbcMethod"
expression="within(com.smart.nestcall.BaseService+)"/>
<aop:advisor  pointcut-ref="serviceJdbcMethod" advice-ref="jdbcAdvice" order="0"/>
</aop:config>
<tx:advice id="jdbcAdvice" transaction-manager="jdbcManager">
<tx:attributes>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
</beans>

最终的结果是UserService的logon()和updateLastLogonTime()和ScoreService的addScore()方法工作在同一个事务中