源码分析系列教程（02） - 手写Spring事务框架-阿里云开发者社区

代码已上传到GitHub，有兴趣的同学可以下载来看看：https://github.com/ylw-github/Java-CodeAnalysis-Demo

手写Spring 事务框架之前，我们先来熟悉一下Spring事务的两种写法，即“编程式事务”和“声明式事务”。

1. Spring 事务的两种常规写法

1.1 编程事务实现

编程式事务 指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，Spring推荐使用TransactionTemplate。下面我们使用编程式事务实现手动事务，使用编程事务实现，手动事务begin、commit、rollback：

1. 需要添加的依赖：

<!-- 1.Spring核心依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.3.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>4.3.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.7.RELEASE</version>
</dependency>
<!-- 2.Spring dao依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>4.3.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>4.3.7.RELEASE</version>
</dependency>
<!-- AOP -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.1</version>
</dependency>
<!-- 数据库 -->
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.25</version>
</dependency>
<!-- Spring单元测试 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.2.5.RELEASE</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

2. 事务工具类TransactionUtils

package com.ylw.transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
@Component
public class TransactionUtils {
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;
    // 开启事务
    public TransactionStatus begin() {
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return transaction;
    }
    // 提交事务
    public void commit(TransactionStatus transactionStatus) {
        dataSourceTransactionManager.commit(transactionStatus);
    }
    // 回滚事务
    public void rollback(TransactionStatus transactionStatus) {
        dataSourceTransactionManager.rollback(transactionStatus);
    }
}

3. AOP 技术封装手动事务AOPTransaction

package com.ylw.transaction;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
@Component
@Aspect
public class AopTransaction {
    @Autowired
    private TransactionUtils transactionUtils;
    // // 异常通知
    @AfterThrowing("execution(* com.ylw.transaction.UserService.add(..))")
    public void afterThrowing() {
        System.out.println("程序已经回滚");
        // 获取程序当前事务 进行回滚
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    // 环绕通知
    @Around("execution(* com.ylw.transaction.UserService.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("开启事务");
        TransactionStatus begin = transactionUtils.begin();
        proceedingJoinPoint.proceed();
        transactionUtils.commit(begin);
        System.out.println("提交事务");
    }
}

4. 数据库操作UserDao

package com.ylw.transaction;
import org.springframework.stereotype.Component;
@Component
public class UserDao {
    public void add(String name, int age) {
        System.out.println("模拟插入数据库 name->" + name + " age->" + age);
    }
}

5. 业务类UserService

package com.ylw.transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    @Autowired
    private TransactionUtils transactionUtils;
    public void add() {
        TransactionStatus transactionStatus = null;
        try {
            transactionStatus = transactionUtils.begin();
            userDao.add("张三", 27);
            int i = 1 / 0;                     //模拟抛出异常
            System.out.println("我是add方法");
            userDao.add("李四", 16);
            transactionUtils.commit(transactionStatus);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (transactionStatus != null) {
                transactionStatus.rollbackToSavepoint(transactionStatus);
            }
        }
    }
}

6.单元测试工具类

import com.ylw.transaction.UserService;
import com.ylw.transaction.UserService2;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TransactionTest {
    @Autowired
    UserService userService;
    @Test
    public void test(){
        userService.add();
    }
}

运行后，发现数据库并没有插入数据：

注意：

事务是程序运行如果没有错误,会自动提交事物,如果程序运行发生异常,则会自动回滚，如果使用了try捕获异常时.一定要在catch里面手动回滚。

事务手动回滚代码：

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

1.2 声明事务实现

管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。

声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。下面我们举一个声明式事务的例子：

1. 注解版声明：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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.xsd
       http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 开启注解 -->
    <context:component-scan base-package="com.ylw"></context:component-scan>
    <!-- 1. 数据源对象: C3P0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!-- 2. JdbcTemplate工具类实例 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事物 -->
    <bean id="dataSourceTransactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 开启注解事物 -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" />
</beans>

2. 业务类使用：

package com.ylw.transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
@Service
public class UserService2 {
    @Autowired
    private UserDao userDao;
    @Transactional
    public void add() {
        userDao.add("张三", 27);
        int i = 1 / 0;                     //模拟抛出异常
        System.out.println("我是add方法");
        userDao.add("李四", 16);
    }
}

3. 单元测试（test1方法）：

import com.ylw.transaction.UserService;
import com.ylw.transaction.UserService2;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TransactionTest {
    @Autowired
    UserService userService;
    @Autowired
    UserService2 userService2;
    @Test
    public void test(){
        userService.add();
    }
    @Test
    public void test1(){
        userService2.add();
    }
}

运行后，发现数据库并没有插入数据（和上面的一样）：

2.手写Spring注解版本事务

2.1 注解

注解是Jdk1.5新增新技术，很多框架为了简化代码，都会提供有些注解。可以理解为插件，是代码级别的插件，在类的方法上写：@XXX，就是在代码上插入了一个插件。

注解特点： 不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。

注解分类：

内置注解(也成为元注解 jdk 自带注解)
自定义注解（Spring框架）

2.1.1 内置注解

内置注解一般为JDK自带的注解，比如我们常用到的"@SuppressWarnings"、"@Deprecated"、"@Overricle"：

1）@SuppressWarnings 在程序前面加上可以在javac编译中去除警告–阶段是SOURCE

2） @Deprecated 带有标记的包，方法，字段说明其过时----阶段是SOURCE

3）@Overricle 打上这个标记说明该方法是将父类的方法重写–阶段是SOURCE

1. @Overricle 案例演示：

2. @Deprecated案例演示:

3. @SuppressWarnings 案例演示:

2.1.2 自定义注解

首先要明确前面说的，注解的作用是用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。

下面介绍常用的的几个注解：

1. @Target

@Target 说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。

CONSTRUCTOR:    用于描述构造器
 FIELD:          用于描述域
 LOCAL_VARIABLE: 用于描述局部变量
 METHOD:         用于描述方法
 PACKAGE:        用于描述包
 PARAMETER:      用于描述参数
 TYPE:           用于描述类、接口(包括注解类型) 或enum声明

2. @Retention

表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）。

3. @Document

描述 Annotation 应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。被例如javadoc此类的工具文档。

4. @Inherited

这也是一个标记注解。@Inherited 阐述了某个被标注的类型是被继承的。被标注过的 class 的子类所继承。类并不从它所实现的接口继承 Annotation，方法并不从它所重载的方法继承 Annotation。

当使用@Inherited类型标注的 Annotation 的 Retention 是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。

5.例子

1）定义注解

package com.ylw.transaction.annonation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(value = { ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface AddAnnotation {
    int userId() default 0;
    String userName() default "默认名称";
    String[]description();
}

2）使用注解

package com.ylw.transaction.annonation;
public class User {
    @AddAnnotation(userName = "张三", userId = 1, description = {"高大", "英俊", "肥胖"})
    public void add() {
    }
}

3）测试注解

package com.ylw.transaction.annonation;
import java.lang.reflect.Method;
public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class classInfo = Class.forName("com.ylw.transaction.annonation.User");
        // 获取到所有方法
        Method[] methods = classInfo.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
            AddAnnotation declaredAnnotation = method.getDeclaredAnnotation(AddAnnotation.class);
            if (declaredAnnotation == null) {
                // 结束本次循环
                continue;
            }
            // 获取userId
            int userId = declaredAnnotation.userId();
            System.out.println("userId:" + userId);
            // 获取userName
            String userName = declaredAnnotation.userName();
            System.out.println("userName:" + userName);
            // 获取arrays
            String[] description = declaredAnnotation.description();
            for (String str : description) {
                System.out.println("desc:" + str);
            }
        }
    }
}

运行结果：

2.2 自定义事务注解

1.TransactionUtils:

package com.ylw.transaction.spring;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
@Component
public class TransactionUtils {
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;
    private TransactionStatus transaction;
    // 开启事务
    public TransactionStatus begin() {
        transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return transaction;
    }
    // 提交事务
    public void commit(TransactionStatus transactionStatus) {
        dataSourceTransactionManager.commit(transactionStatus);
    }
    // 回滚事务
    public void rollback() {
        dataSourceTransactionManager.rollback(transaction);
    }
}

2.注解类ExtTransaction:

package com.ylw.transaction.spring.div;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//自定义事务注解
@Target(value = { ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtTransaction {
}

3.定义切面类

package com.ylw.transaction.spring.div;
import com.ylw.transaction.spring.TransactionUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import java.lang.reflect.Method;
@Component
@Aspect
public class AopExtTransaction {
  @Autowired
  private TransactionUtils transactionUtils;
  @AfterThrowing("execution(* com.ylw.transaction.spring.*.*.*(..))")
  public void afterThrowing() throws NoSuchMethodException, SecurityException {
    // isRollback(proceedingJoinPoint);
    System.out.println("程序发生异常");
    // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    // TransactionStatus currentTransactionStatus =
    // TransactionAspectSupport.currentTransactionStatus();
    // System.out.println("currentTransactionStatus:" +
    // currentTransactionStatus);
    transactionUtils.rollback();
  }
  // // 环绕通知 在方法之前和之后处理事情
  @Around("execution(* com.ylw.transaction.spring.*.*.*(..))")
  public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    // 调用方法之前执行
    TransactionStatus transactionStatus = begin(proceedingJoinPoint);
    proceedingJoinPoint.proceed();// 代理调用方法 注意点： 如果调用方法抛出异常不会执行后面代码
    // 调用方法之后执行
    commit(transactionStatus);
  }
  public TransactionStatus begin(ProceedingJoinPoint pjp) throws NoSuchMethodException, SecurityException {
    // // 判断是否有自定义事务注解
    ExtTransaction declaredAnnotation = getExtTransaction(pjp);
    if (declaredAnnotation == null) {
      return null;
    }
    // 如果有自定义事务注解，开启事务
    System.out.println("开启事务");
    TransactionStatus transactionStatu = transactionUtils.begin();
    return transactionStatu;
  }
  public void commit(TransactionStatus transactionStatu) {
    if (transactionStatu != null) {
      // 提交事务
      System.out.println("提交事务");
      transactionUtils.commit(transactionStatu);
    }
  }
  public ExtTransaction getExtTransaction(ProceedingJoinPoint pjp) throws NoSuchMethodException, SecurityException {
    // 获取方法名称
    String methodName = pjp.getSignature().getName();
    // 获取目标对象
    Class<?> classTarget = pjp.getTarget().getClass();
    // 获取目标对象类型
    Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
    // 获取目标对象方法
    Method objMethod = classTarget.getMethod(methodName, par);
    // // 判断是否有自定义事务注解
    ExtTransaction declaredAnnotation = objMethod.getDeclaredAnnotation(ExtTransaction.class);
    if (declaredAnnotation == null) {
      System.out.println("您的方法上,没有加入注解!");
      return null;
    }
    return declaredAnnotation;
  }
  // 回滚事务
  public void isRollback(ProceedingJoinPoint pjp) throws NoSuchMethodException, SecurityException {
    // // 判断是否有自定义事务注解
    ExtTransaction declaredAnnotation = getExtTransaction(pjp);
    if (declaredAnnotation != null) {
      System.out.println("已经开始回滚事务");
      // 获取当前事务 直接回滚
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
      return;
    }
  }
}

4.业务类使用：

package com.ylw.transaction.spring;
import com.ylw.transaction.spring.div.ExtTransaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserService3 {
    @Autowired
    private UserDao userDao;
    @ExtTransaction
    public void add() {
        userDao.add("张三", 27);
        int i = 1 / 0;                     //模拟抛出异常
        System.out.println("我是add方法");
        userDao.add("李四", 16);
    }
}

测试类（test2方法）：

import com.ylw.transaction.spring.UserService;
import com.ylw.transaction.spring.UserService2;
import com.ylw.transaction.spring.UserService3;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TransactionTest {
    @Autowired
    UserService userService;
    @Autowired
    UserService2 userService2;
    @Autowired
    UserService3 userService3;
    @Test
    public void test(){
        userService.add();
    }
    @Test
    public void test1(){
        userService2.add();
    }
    @Test
    public void test2(){
        userService3.add();
    }
}

运行结果后，数据库没有改变：

4.Spring事务传播行为

Spring中事务的定义：

Propagation（key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。）有以下选项可供使用：

PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

源码分析系列教程（02） - 手写Spring事务框架