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

本文链接：https://blog.csdn.net/ahaha413525642/article/details/78195345

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 credit 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>