手写Spring事务

 

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

以上代码很熟悉了，传统的spring xml配置事务就是DataSourceTransactionManager

目前项目是spring boot/cloud    分布式事务暂时不考虑在范围内，项目结构

自定义Transaction：

package com.chwl.cn.config.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 Transaction {

	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;// 事务管理器

	// 开启事务
	public TransactionStatus begin() {
		TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
		return transaction;
	}

	// 提交事务
	public void commit(TransactionStatus transaction) {
		dataSourceTransactionManager.commit(transaction);
	}

	// 回滚
	public void rollback(TransactionStatus transaction) {
		dataSourceTransactionManager.rollback(transaction);
	}
}

conntroller:

@RequestMapping(value = "/add/", method = RequestMethod.POST)
	public void get() {
		OrderEntity order = orderService.selectById(1L);
		orderService.add(order);
	}

service:

@Override
	public void add(OrderEntity order) {
		order.setId(null);
		super.insert(order);
		int i=1/0;
	}

不加事务添加一条order

报错，但依然数据库添加成功了

加事务:

@Autowired
	private Transaction transaction;

	@Override
	public void add(OrderEntity order) {
		TransactionStatus t = null;
		try {
			t = transaction.begin();
			order.setId(null);
			super.insert(order);
			int i = 1 / 0;
			transaction.commit(t);
		} catch (Exception e) {
            e.printStackTrace();
			transaction.rollback(t);
		}
	}

用的是自定义的Transaction

报错:

   回滚了，事务起了作用

 

如果是多线程操作，事务会有问题，spring bean默认单例的，加上注解@Scope("prototype")//多例

@Component
@Scope("prototype")//多例
public class Transaction {
@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;// 事务管理器

	// 开启事务
	public TransactionStatus begin() {
		TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
		return transaction;
	}

	// 提交事务
	public void commit(TransactionStatus transaction) {
		dataSourceTransactionManager.commit(transaction);
	}

	// 回滚
	public void rollback(TransactionStatus transaction) {
		dataSourceTransactionManager.rollback(transaction);
	}
}

手写事务

定义注解:

package com.chwl.cn.config.transaction;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.TYPE})//可以用在接口、类、枚举、注解和方法上
@Retention(RetentionPolicy.RUNTIME) 注解会在class字节码文件中存在，在运行时可以通过反射获取到
public @interface MyTransactional {

	String value() default "";
}

切面:

package com.chwl.cn.config.aspect;

import java.lang.reflect.Method;
import java.util.Objects;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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 com.chwl.cn.config.transaction.Transaction;
import com.chwl.cn.config.transaction.MyTransactional;

@Aspect
@Component
public class TransactionAop {

	@Autowired
	private Transaction transaction;
	
	
	/**
     * AOP实现事务管理
     *
     * @param proceedingJoinPoint 切面通知对象
     */
    @Around("execution(* com.chwl.cn.service.*.* (..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint)  {
    	MyTransactional transactional = null;
    	TransactionStatus transactionStatus=null;
        try {
            // 获取注解对象
        	transactional = getTransaction(proceedingJoinPoint);
        	transactionStatus= transaction.begin();
            proceedingJoinPoint.proceed();
            // 提交事务
            transaction.commit(transactionStatus);
        } catch (Throwable throwable) {
        	if(!Objects.isNull(transactional)){
        		transaction.rollback(transactionStatus);
        	}
        }
    }
    
    /**
     * 获取注解对象
     *
     * @param proceedingJoinPoint 切面通知对象
     * @return 注解对象
     * @throws NoSuchMethodException
     */
    public MyTransactional getTransaction(ProceedingJoinPoint proceedingJoinPoint) throws NoSuchMethodException {
//        // 获取方法名称
//        String method = proceedingJoinPoint.getSignature().getName();
        // 获取目标方法
//        Class<?> classTarget = proceedingJoinPoint.getTarget().getClass();
        // 获取目标对象类型
//        Class[] parameterTypes = ((MethodSignature) proceedingJoinPoint.getSignature()).getParameterTypes();
//        // 获取目标对象方法
//        Method objMethod = classTarget.getMethod(method, parameterTypes);
    	// 获取注解
//        MyTransactional declaredAnnotation = objMethod.getDeclaredAnnotation(MyTransactional.class);
        MethodSignature signature = (MethodSignature)proceedingJoinPoint.getSignature();
        Method method = signature.getMethod();
        //先获取方法的注解，如果方法注解没有，看类上是否有注解，有则获取，无则当前方法没事务
        //如果类上有注解，则方法都有事务，如果类上没有，方法也没有，则当前方法没有事务
        MyTransactional annotation = method.getAnnotation(MyTransactional.class);
        if(Objects.isNull(annotation)){
        //获取类上的注解
        	return proceedingJoinPoint.getTarget().getClass().getAnnotation(MyTransactional.class);
        }
        return annotation;
    }

}

都比较简单，思路对了基本都已经成功了80%,使用就更简单了，类上或者方法上面贴上@MyTransactional注解就行啦

 

平时如果事务配在service的话，service的方法尽量少try catch，如果自己没有进行异常处理回滚，那么spring也不会进行回滚，spring也是捕获异常然后进行回滚，原理和上面的类似。Spring Boot同理

如果进行了try catch，请

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); //手动开启事务回滚