@Transactional 实现原理

目录

1、简介

2、自定义注解

2.1 定义

2.2 测试

2.3 总结

3、手写事务注解

3.1 maven依赖

3.2 配置spring.xml文件

3.3 自定义事务注解 (通过反射解析方法上的注解，如果有这个注解就执行事务逻辑)

3.4 封装编程式事务

3.5 通过AOP封装事务工具类, 基于环绕通知和异常通知来触发事务

3.6 dao 层

3.7 service 层

3.8 测试

---

1、简介

Transactional是spring中定义的事务注解，在方法或类上加该注解开启事务。主要是通过反射获取bean的注解信息，利用AOP对编程式事务进行封装实现。(spring-5.1.8.RELEASE)

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {

    @AliasFor("transactionManager")
    String value() default "";

    @AliasFor("value")
    String transactionManager() default "";

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    boolean readOnly() default false;

    Class[] rollbackFor() default {};

    String[] rollbackForClassName() default {};

    Class[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}

2、自定义注解

2.1 定义

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation {
    //自定义注解的属性
    int id() default 0;
    String name() default "默认名称";
    String[]arrays();
    String title() default "默认标题";
}

2.2 测试

public class App {

    @MyAnnotation(name = "Yongqian Wang", arrays = {"2", "3"})
    public void aMethod() {}

    public void bMethod() {}

    public static void main(String[] args) throws ClassNotFoundException {
        // 反射获取到类的信息
        Class clazz = Class.forName("com.wyq.App");

        // 获取当前类（不包括继承）所有方法
        Method[] methods = clazz.getDeclaredMethods();

        // 遍历每个方法的信息
        for (Method method : methods) {
            System.out.println("方法名称：" + method.getName());

            // 获取方法上面的注解
            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("Title : " + annotation.title());
                System.out.println("Arrays : " + annotation.arrays());
            }

            System.out.println("--------------------------");
        }

    }
}


控制台信息：

方法名称：main
该方法上没有加注解...
--------------------------
方法名称：aMethod
Id : 0
Name : Yongqian Wang
Title : 默认标题
Arrays : [Ljava.lang.String;@24d46ca6
--------------------------
方法名称：bMethod
该方法上没有加注解...
--------------------------

2.3 总结

通过上面这么一个小demo我们就能发现，反射获取到每一个方法的注解信息然后进行判断，如果这是@Transactional注解，spring就会开启事务。接下来我们可以按照这种思路自己实现一个事务注解。

3、手写事务注解

3.1 maven依赖

    
        
        
            org.springframework
            spring-core
            ${spring.version}
        
        
            org.springframework
            spring-context
            ${spring.version}
        
        
            org.springframework
            spring-aop
            ${spring.version}
        
        
            org.springframework
            spring-orm
            ${spring.version}
        
        
            org.aspectj
            aspectjrt
            1.9.4
        
        
            aspectj
            aspectjweaver
            1.5.4
        
        
            cglib
            cglib
            3.3.0
        
        
            com.mchange
            c3p0
            0.9.5.2
        
        
            mysql
            mysql-connector-java
            5.1.37
        
    

3.2 配置spring.xml文件

3.3 自定义事务注解 (通过反射解析方法上的注解，如果有这个注解就执行事务逻辑)

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation {
    //自定义注解的属性
    int id() default 0;

    String name() default "默认名称";

    String[] arrays() default {};

    String title() default "默认标题";
}

3.4 封装编程式事务

@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.5 通过AOP封装事务工具类, 基于环绕通知和异常通知来触发事务

@Component
@Aspect
public class AopTransaction {
    @Autowired
    private TransactionUtil transactionUtil;

    private TransactionStatus transactionStatus;

    /**
     * 环绕通知，在方法 前---后 处理事情
     *
     * @param pjp 切入点
     */
    @Around("execution(* com.wyq.service.*.*(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        // 获取方法的注解
        MyAnnotation annotation = this.getMethodMyAnnotation(pjp);
        // 判断是否需要开启事务
        transactionStatus = begin(annotation);
        // 调用目标代理对象方法
        pjp.proceed();
        // 判断关闭事务
        commit(transactionStatus);
    }

    /**
     * 获取代理方法上的事务注解
     *
     * @param pjp
     * @return
     * @throws Exception
     */
    private MyAnnotation getMethodMyAnnotation(ProceedingJoinPoint pjp) throws Exception {
        // 获取代理对象的方法
        String methodName = pjp.getSignature().getName();
        // 获取目标对象
        Class classTarget = pjp.getTarget().getClass();
        // 获取目标对象类型
        Class[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
        // 获取目标对象方法
        Method objMethod = classTarget.getMethod(methodName, par);
        // 获取该方法上的事务注解
        MyAnnotation annotation = objMethod.getDeclaredAnnotation(MyAnnotation.class);
        return annotation;
    }

    /**
     * 开启事务
     *
     * @param annotation
     * @return
     */
    private TransactionStatus begin(MyAnnotation annotation) {
        if (annotation == null) {
            return null;
        }
        return transactionUtil.begin();
    }

    /**
     * 提交事务
     *
     * @param transactionStatus
     */
    private void commit(TransactionStatus transactionStatus) {
        if (transactionStatus != null) {
            transactionUtil.commit(transactionStatus);
        }
    }

    /**
     * 异常通知进行 回滚事务
     */
    @AfterThrowing("execution(* com.wyq.service.*.*(..))")
    public void afterThrowing() {
        // 获取当前事务 直接回滚
        if (transactionStatus != null) {
            transactionUtil.rollback(transactionStatus);
        }
    }
}

3.6 dao 层

/*
CREATE TABLE `t_user0` (
  `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_user0(NAME, age) VALUES(?,?);";
        int result = jdbcTemplate.update(sql, name, age);
        System.out.println("插入成功");
        return result;
    }
}

3.7 service 层

@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...");
    }
}

3.8 测试

public class Test {
    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();
    }
}

4、参考

https://www.cnblogs.com/wlwl/p/10092494.html

https://www.cnblogs.com/wlwl/p/10032206.html