@Transactional實現原理

　　Transactional是spring中定義的事務注解，在方法或類上加該注解開啟事務。主要是通過反射獲取bean的注解信息，利用AOP對編程式事務進行封裝實現。AOP對事務的封裝可以看我的這篇文章的介紹。

我們先寫個demo，感受它的加載過程。

spring事務注解：

1. 自定義一個注解

/**
 * @Target  作用域(作用在方法上,類上,或是屬性上)
 * @Retention 運行周期
 * @interface 定義注解
 */
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    //自定義注解的屬性
    int id() default 0;
    String name() default "默認名稱";
    String[]arrays();
    String title() default "默認標題";
}

2. 測試

import java.lang.reflect.Method;
public class User {
    
    @MyAnnotation(name="吳磊",arrays = {"2","3"})
    public  void aMethod () {}
    
    public  void bMethod () {}
    
    public static void main(String[] args) throws ClassNotFoundException {
        //1. 反射獲取到類信息
        Class<?> forName = Class.forName("com.demo.User");
        //2. 獲取到當前類（不包含繼承）所有的方法
        Method[] declaredMethods = forName.getDeclaredMethods();
        //3. 遍歷每個方法的信息
        for (Method method : declaredMethods) {
            System.out.println("方法名稱:" + method.getName());
            //4. 獲取方法上面的注解
            MyAnnotation annotation = method.getDeclaredAnnotation(MyAnnotation.class);
            if(annotation == null) {
                System.out.println("該方法上沒有加注解....");
            }else {
                System.out.println("Id:" + annotation.id());
                System.out.println("Name:" + annotation.name());
                System.out.println("Arrays:" + annotation.arrays());
                System.out.println("Title:" + annotation.title());
            }
            System.out.println("--------------------------");
        }
    }
}

=============================
【控制台輸出】
方法名稱:main
該方法上沒有加注解....
--------------------------
方法名稱:aMethod
Id:0
Name:吳磊
Arrays:[Ljava.lang.String;@74a14482
Title:默認標題
--------------------------
方法名稱:bMethod
該方法上沒有加注解....
--------------------------

總結：通過上面這么一個小demo我們就能發現，反射獲取到每一個方法的注解信息然后進行判斷，如果這是@Transactional注解，spring就會開啟事務。接下來我們可以按照這種思路基於上一篇博客的編程式事務自己實現一個事務注解。

手寫注解事務：

1. 導包

  <dependencies>
        <!-- 引入Spring-AOP等相關Jar -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.5.3</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
    </dependencies>

2. 配置spring.xml文件

<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.wulei"/>
    <!-- 開啟切面代理 -->
    <aop:aspectj-autoproxy /> 
    <!-- 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://localhost:3306/test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- 2. JdbcTemplate工具類實例 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 3. 配置事務 -->
    <bean id="dataSourceTransactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

3.1 自定義事務注解 (通過反射解析方法上的注解，如果有這個注解就執行事務邏輯)

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//@Transaction可以作用在類和方法上, 我們這里只作用在方法上。
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
/**
* 自定義事務注解
*/
public @interface MyAnnotation {

}

3.2 封裝編程式事務

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
@Component
@Scope("prototype") // 申明為多例,解決線程安全問題。
/**
 * 手寫編程式事務
 */
public class TransactionUtil {

    // 全局接受事務狀態
    private TransactionStatus transactionStatus;
    // 獲取事務源
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;

    // 開啟事務
    public TransactionStatus begin() {
        System.out.println("開啟事務");
        transactionStatus = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return transactionStatus;
    }

    // 提交事務
    public void commit(TransactionStatus transaction) {
        System.out.println("提交事務");
        if(dataSourceTransactionManager != null) dataSourceTransactionManager.commit(transaction);
    }

    // 回滾事務
    public void rollback(TransactionStatus transaction) {
        System.out.println("回滾事務...");
        if(dataSourceTransactionManager != null) dataSourceTransactionManager.rollback(transaction);
    }
}

3.3 通過AOP封裝事務工具類, 基於環繞通知和異常通知來觸發事務。

import java.lang.reflect.Method;
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 com.wulei.transaction.TransactionUtil;
@Aspect// 申明為切面
@Component
/**
 * 切面類封裝事務邏輯
 */
public class AopTransaction {

    @Autowired
    private TransactionUtil transactionUtil;
    
    private TransactionStatus transactionStatus;
    /**
     * 環繞通知 在方法之前和之后處理事情 
     * @param pjp 切入點
     */
    @Around("execution(* com.wulei.service.*.*(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        // 1.獲取方法的注解
        MyAnnotation annotation = this.getMethodMyAnnotation(pjp);
        // 2.判斷是否需要開啟事務
        transactionStatus = begin(annotation);
        // 3.調用目標代理對象方法
        pjp.proceed();
        // 4.判斷關閉事務
        commit(transactionStatus);
    }
    /**
     * 獲取代理方法上的事務注解
     * @param pjp 切入點
     */
    private MyAnnotation getMethodMyAnnotation(ProceedingJoinPoint pjp) throws Exception {
        //1. 獲取代理對對象的方法
        String methodName = pjp.getSignature().getName();
        //2. 獲取目標對象
        Class<?> classTarget = pjp.getTarget().getClass();
        //3. 獲取目標對象類型
        Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
        //4. 獲取目標對象方法
        Method objMethod = classTarget.getMethod(methodName, par);
        //5. 獲取該方法上的事務注解
        MyAnnotation annotation = objMethod.getDeclaredAnnotation(MyAnnotation.class);
        return annotation;
    }
    /** 開啟事務  */
    private TransactionStatus begin(MyAnnotation annotation) {
        if(annotation == null) return null;
        return transactionUtil.begin();
    }
    /** 關閉事務 */
    private void commit(TransactionStatus transactionStatus) {
        if(transactionStatus != null) transactionUtil.commit(transactionStatus);
    }
    /**
     * 異常通知進行 回滾事務
     */
    @AfterThrowing("execution(* com.wulei.service.*.*(..))")
    public void afterThrowing() {
        // 獲取當前事務 直接回滾
        //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        if(transactionStatus != null) transactionUtil.rollback(transactionStatus);
    }
}

4. 編寫dao層

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
/*
 CREATE TABLE `t_users` (
   `name` varchar(20) NOT NULL,
   `age` int(5) DEFAULT NULL,
   PRIMARY KEY (`name`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 */
@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public int add(String name, Integer age) {
        String sql = "INSERT INTO t_users(NAME, age) VALUES(?,?);";
        int result = jdbcTemplate.update(sql, name, age);
        System.out.println("插入成功");
        return result;
    }
}

5. 編寫service

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.wulei.dao.UserDao;
import com.wulei.transaction.MyAnnotation;
@Service
public class UserService {

    @Autowired
    private UserDao userDao;
    
    // 加上事務注解
    @MyAnnotation
    public void add() {
        userDao.add("test001", 20);
        int i = 1 / 0;
        userDao.add("test002", 21);
//        // 如果非要try,那么出現異常不會被aop的異常通知監測到,必須手動在catch里面回滾事務。
//        try {
//            userDao.add("test001", 20);
//            int i = 1 / 0;
//            userDao.add("test002", 21);
//        } catch (Exception e) {
//            // 回滾當前事務
//            System.out.println("回滾");
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//        }
    }

    public void del() {
        System.out.println("del...");
    }
}

 6. 測試

import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wulei.service.UserService;
public class Main {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        // aop()對userService類進行了攔截,添加自定義事務注解的方法會觸發事務邏輯
        userService.add();
        // del()方法沒有加注解，則什么也不會觸發。
        //userService.del();
    }
}