-手写Spring注解版本&事务传播行为

2022-08-18 13:06:32

视频参考C:\Users\Administrator\Desktop\蚂蚁3期\【www.zxit8.com】 0018-(每特教育&每特学院&蚂蚁课堂)-3期-源码分析-手写Spring注解版本&事务传播行为\0018-(每特教育&每特学院&蚂蚁课堂)-3期-源码分析-手写Spring注解版本&事务传播行为

今天视频要手写一个@Transaction事务注解框架

我们首先来看一个spring 事务的常见配置

<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.itmayiedu"></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://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>

    <!-- 配置事物 -->

    <bean id="dataSourceTransactionManager"

        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource"></property>

    </bean>

    <!-- 开启注解事物 -->

    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" />

</beans>

在业务层中@Transaction来使用注解

    @Transactional
public void add() {

        userDao.add("wangmazi", 27);

        int i = 1 / 0;

        System.out.println("我是add方法");

        userDao.add("zhangsan", 16);

    }

接下来我们要手写@Transactional注解框架

接下来首先学习下java的注解以及利用反射读取注解

@Target(value = { ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

public @interface AddAnnotation {

    int userId() default 0;

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

    String[]arrays();

}

接下来利用反射读取注解

package com.itmayiedu.annotation;

import java.lang.reflect.Method;

public class User {

    @AddAnnotation(userName = "张三", userId = 18, arrays = { "1" })

    public void add() {

    }

    public void del() {

    }

    public static void main(String[] args) throws ClassNotFoundException {

        // 怎么样获取到方法上注解信息 反射机制

        Class<?> forName = Class.forName("com.itmayiedu.annotation.User");

        // 获取到当前类（不包含继承）所有的方法

        Method[] declaredMethods = forName.getDeclaredMethods();

        for (Method method : declaredMethods) {

            // 获取该方法上是否存在注解

            System.out.println("####方法名称" + method.getName());

            AddAnnotation addAnnotation = method.getAnnotation(AddAnnotation.class);

            if (addAnnotation == null) {

                // 该方法上没有注解

                System.out.println("该方法上没有加注解..");

                continue;

            }

            // 在该方法上查找到该注解

            System.out.println("userId:" + addAnnotation.userId());

            System.out.println("userName:" + addAnnotation.userName());

            System.out.println("arrays:" + addAnnotation.arrays());

            System.out.println();

        }

    }

}

现在有个User类，类中add方法我们添加了注解，接下来使用反射来操作User类，通过反射获得add方法，然后判断该方法上面是否使用了注解，如果使用了把注解的值打印出来

我们来看下打印的日志

####方法名称main

该方法上没有加注解..

####方法名称add

userId:18

userName:张三

arrays:[Ljava.lang.String;@6607db7d

####方法名称del

该方法上没有加注解..

接下来我们重点讲解手写@Transaction spring的事物注解

例如现在add方法上我们使用@ExtTransactional如何实现注解了。定义一个aop的切面类，在切面类中定义切点可以拦截到controller类的add方法被调用了。在切面中利用反射技术判断add方法上面是否使用了注解，如果使用了注解就开启事务，没有就不开启事务

第一步：需要将spring框架配置文件中的开启事务管理注解去掉

<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.itmayiedu"></context:component-scan>

    <aop:aspectj-autoproxy></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>

去掉：

    <!-- 开启注解事务 -->

    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" />
第二步：自定义一个注解

package com.itmayiedu.annotation;

import java.lang.annotation.Documented;

import java.lang.annotation.ElementType;

import java.lang.annotation.Inherited;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

// 事务注解 设置传播行为

@Target({ ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

public @interface ExtTransaction {

}

第三步：自定义一个事务管理工具的实现类，这里使用的是jdbc的事务管理器来实现对事务的管理

package com.itmayiedu.transaction;

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;

// 编程事务（需要手动begin 手动回滚 手都提交）

@Component

@Scope("prototype") // 每个事务都是新的实例 目的解决线程安全问题 多例子

public class TransactionUtils {

    // 全局接受事务状态

    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("提交事务");

        dataSourceTransactionManager.commit(transaction);

    }

    // 回滚事务

    public void rollback() {

        System.out.println("回滚事务...");

        dataSourceTransactionManager.rollback(transactionStatus);

    }

}

上面这个类有几个地方需要注意的，dao层使用的是jdbcTemplate，使用jdbc的方式，所以要使用jbdc数据源的事务管理器

DataSourceTransactionManager，其他框架hibernate的事务管理器为

Spring声明式事务管理器类：
Jdbc技术：DataSourceTransactionManager
Hibernate技术：HibernateTransactionManager

第二：对于事务管理工具类一个事务应该对于一个事务管理工具类的实例，spring默认代理对象都是单例模式，如果是单例模式多个事务就是多个线程共享一个对象，会出现线程安全问题

所以@Scope("prototype") // 每个事务都是新的实例目的解决线程安全问题多例子，定义为多实例类型

接下来，定位aop实现对调用方法的拦截，实现事务管理

package com.itmayiedu.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.itmayiedu.annotation.ExtTransaction;

import com.itmayiedu.transaction.TransactionUtils;

//  自定义事务注解具体实现

@Aspect

@Component

public class AopExtTransaction {

    // 一个事务实例子 针对一个事务

    @Autowired

    private TransactionUtils transactionUtils;

    // 使用异常通知进行 回滚事务

    @AfterThrowing("execution(* com.itmayiedu.service.*.*.*(..))")

    public void afterThrowing() {

        // 获取当前事务进行回滚

        // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

        transactionUtils.rollback();

    }

    // 环绕通知 在方法之前和之后处理事情

    @Around("execution(* com.itmayiedu.service.*.*.*(..))")

    public void around(ProceedingJoinPoint pjp) throws Throwable {

        // 1.获取该方法上是否加上注解

        ExtTransaction extTransaction = getMethodExtTransaction(pjp);

        TransactionStatus transactionStatus = begin(extTransaction);

        // 2.调用目标代理对象方法

        pjp.proceed();

        // 3.判断该方法上是否就上注解

        commit(transactionStatus);

    }

    private TransactionStatus begin(ExtTransaction extTransaction) {

        if (extTransaction == null) {

            return null;

        }

        // 2.如果存在事务注解,开启事务

        return transactionUtils.begin();

    }

    private void commit(TransactionStatus transactionStatus) {

        if (transactionStatus != null) {

            // 5.如果存在注解,提交事务

            transactionUtils.commit(transactionStatus);

        }

    }

    // 获取方法上是否存在事务注解

    private ExtTransaction getMethodExtTransaction(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 extTransaction = objMethod.getAnnotation(ExtTransaction.class);

        return extTransaction;

    }

}

package com.itmayiedu.dao;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Repository;

@Repository

public class UserDao {

    @Autowired

    private JdbcTemplate jdbcTemplate;

    public void add(String name, Integer age) {

        String sql = "INSERT INTO t_users(NAME, age) VALUES(?,?);";

        int updateResult = jdbcTemplate.update(sql, name, age);

        System.out.println("updateResult:" + updateResult);

    }

}

package com.itmayiedu.service;

//user 服务层

public interface UserService {

    public void add();

    public void del();

}

接下来在实现类使用

 @ExtTransaction就实现了我们的自定义事务注解

package com.itmayiedu.service.impl;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.itmayiedu.dao.UserDao;

import com.itmayiedu.service.LogService;

import com.itmayiedu.service.UserService;

//user 服务层

@Service

public class UserServiceImpl implements UserService {

    @Autowired

    private UserDao userDao;

@Autowired

    private TransactionUtils transactionUtils;

    @ExtTransactionpublic void add() {

        userDao.add("test001", 20);

        // int i = 1 / 0;

        System.out.println("################");

        userDao.add("test002", 21);

    }

    // 方法执行完毕之后，才会提交事务

    public void del() {

        System.out.println("del");

    }

}

接下来我们分析下事务的传播特性，我们使用spring框架默认自带的注解

我们在配置文件中开启事务管理，然后将上面我们自己编写的AopExtTransaction事务框架代码屏蔽掉，以免和spring默认的框架起冲突

注意：spring的事务传播特性是在两个不同的service中相互调用

我们在新建一个dao

package com.itmayiedu.dao;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Repository;

@Repository

public class LogDao {

    @Autowired

    private JdbcTemplate jdbcTemplate;

    public void add(String name) {

        String sql = "INSERT INTO t_log(log_name) VALUES(?);";

        int updateResult = jdbcTemplate.update(sql, name);

        System.out.println("##LogDao##updateResult:" + updateResult);

    }

}

package com.itmayiedu.service.impl;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import com.itmayiedu.dao.LogDao;

import com.itmayiedu.service.LogService;

@Service

public class LogServiceImpl implements LogService {

    @Autowired

    private LogDao logDao;

    @Transactional

    public void addLog() {

        logDao.add("addLog" + System.currentTimeMillis());

        // int i = 1 / 0;

    }

}

<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.itmayiedu"></context:component-scan>

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy> <!-- 开启事物注解 -->

    <!-- . 数据源对象: 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>

    <!-- . 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>

 使用spring框架的默认事务管理，这里需要开启注解事务管理的配置

<tx:annotation-driven transaction-manager="dataSourceTransactionManager" />

PROPAGATION_REQUIRED—如果当前有事务，就用当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

对应的就是在addLog()方法上面使用@Transactional注解

@Transactional
public void addLog() {
logDao.add("addLog" + System.currentTimeMillis());

}

@Transactional
public void add() {
// 调用接口的时候接口失败需要回滚，但是日志记录不需要回滚。
logService.addLog(); // 后面程序发生错误，不能影响到我的回滚### 正常当addLog方法执行完毕，就应该提交事务
userDao.add("test001", 200);
// int i = 1 / 0;
System.out.println("################");
userDao.add("test002", 21);

}

我们来看下运行的情况

第一种情况：正常情况下，事务正常 log日志和人员信息都会添加成功

第二种情况，如果在addLog方法中发送了异常

@Transactional
public void addLog() {
logDao.add("addLog" + System.currentTimeMillis());
int i = 1 / 0;
}

这个时候因为addLog中发送了异常，这个时候就会把异常抛出去给aop框架处理，后续的代码就不会再继续执行

就不会再执行

logService.addLog(); // 后面程序发生错误，不能影响到我的回滚### 正常当addLog方法执行完毕，就应该提交事务
userDao.add("test001", 200);
// int i = 1 / 0;
System.out.println("################");
userDao.add("test002", 21);

因为addLOg方法出现了异常就不会再执行后续的userDao.add("test001", 200);方法，抛出异常的时候aop框架会对事务进行回滚，所以ogDao.add("addLog" + System.currentTimeMillis());不会添加数据到数据库中

第三种情况

如果在addLog方法中发送了异常

@Transactional
public void addLog() {
logDao.add("addLog" + System.currentTimeMillis());
int i = 1 / 0;
}

但是在userService的add方法中使用了try catch进行捕获，我们来看下数据库的情况

@Transactional(rollbackFor=Exception.class)

    public void add() {

        // 调用接口的时候 接口失败 需要回滚，但是日志记录不需要回滚。

        try{

            logService.addLog();

        }catch(Exception e){

            System.out.println(e.toString());

        }

        userDao.add("test001", 200);

        // int i = 1 / 0;

        System.out.println("################");

        userDao.add("test002", 21);

    }

我们来看下这种情况下的运行情况

运行居然抛出了异常

Exception in thread "main" org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:717)
at org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:393)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:120)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:202)
at com.sun.proxy.$Proxy13.add(Unknown Source)
at com.itmayiedu.Test001.main(Test001.java:12)

数据库中没有插入任何数据，为啥出现上面这种情况了

##Transaction rolled back because it has been marked as rollback-only spring 具备多种事务传播机制，最常用的是REQUIRED，即如果不存在事务，则新建一个事务；如果存在事务，则加入现存的事务中。示例代码如下：

public void A() {
querySomething(...)；
try {
B()
} catch () {
}
saveSomethinf()；
}

public void B() {
throw Exception()
}
此时B会和A存在一个事务中。如果B抛出异常没有捕获，即使在A中捕获并处理，仍会发生异常：Transaction rolled back because it has been marked as rollback-only 因为spring会在A捕获异常之前提前捕获到异常，并将当前事务设置为rollback-only，而A觉得对异常进行了捕获，它仍然继续commit，当TransactionManager发现状态为设置为rollback-only时，则会抛出UnexpectedRollbackException 相关代码在AbstractPlatformTransactonManager.java中：

public final void commit(TransactionStatus status) throws TransactionException {
if (status.isCompleted()) {
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}

DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
if (defStatus.isLocalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Transactional code has requested rollback");
}
processRollback(defStatus);
return;
}
if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
}
processRollback(defStatus);
// Throw UnexpectedRollbackException only at outermost transaction boundary
// or if explicitly asked to.
if (status.isNewTransaction() || isFailEarlyOnGlobalRollbackOnly()) {
throw new UnexpectedRollbackException(
"Transaction rolled back because it has been marked as rollback-only");
}
return;
}

processCommit(defStatus);
}
解决方法：在抛出异常的最原始地方处理异常，即在spring捕获到异常之前处理掉

在一个transactional中如果有另一transaction，内层的事务会跟随外层的事务，变为一个整体的事务。

如果内层transaction发生了异常，即使你捕捉了这个异常，那么整体的Transaction也会被定义成RollbackOnly，这也正是事务管理的原则。所以当外层事务想提交整个事务时，出现异常。

解决版本就是在logService中对异常进行try catch处理

@Transactional

    public void addLog() {

        try{

            logDao.add("addLog" + System.currentTimeMillis());

            int i = 1 / 0;

        }catch(Exception e){

        }

    }

@Transactional(rollbackFor=Exception.class)

    public void add() {

        // 调用接口的时候 接口失败 需要回滚，但是日志记录不需要回滚。

            logService.addLog(); 

        userDao.add("test001", 200);

        // int i = 1 / 0;

        System.out.println("################");

        userDao.add("test002", 21);

    }

上面这种情况：log日志和人员信息都会添加到数据库中， int i = 1 / 0;发现了异常但是我们自定义了try catch处理异常，就不会把异常抛出去给aop框架进行处理，对数据进行回滚

因为logService.addLog(); 对外没有抛出异常，后续的 userDao.add("test001", 200);代码也会正常执行，把人员数据添加到数据库中

第五情况在add添加人员方法中抛出了异常

    @Transactional

    public void addLog() {

            logDao.add("addLog" + System.currentTimeMillis());

            int i = 1 / 0;

    }

    @Transactional(rollbackFor=Exception.class)

    public void add() {

        // 调用接口的时候 接口失败 需要回滚，但是日志记录不需要回滚。

            logService.addLog();

        userDao.add("test001", 200);

        int i = 1 / 0;

        System.out.println("################");

        userDao.add("test002", 21);

    }

在调用add方法中抛出了异常，因为当前事务addLog的事务传播属性是 @Transactional，PROPAGATION_REQUIRED—如果当前有事务，就用当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

所以logService.addLog();和userDao.add("test001", 200);是在同一个事务中，当发现异常的时候，如果没有对异常使用try catch进行处理，会把异常抛出去给aop框架进行处理

异常前面的

 logService.addLog(); 和 userDao.add("test001", 200);都会回滚

码农公寓

相关文章