要使用Springboot的事务其实非常简单，在启动类上添加@EnableTransactionManagement，在Service的类或者方法上使用@Transactional就可以了。
事务本身的4大特性
原子性（Atomicity） 指事务必须是一个不可分割的整体
一致性（Consistency） 指执行完数据库操作后，数据不会被破坏
隔离性（Isolation） 保证数据库操作之间，彼此没有任何干扰
持久性（Durability） 保证永久的存放在磁盘中
其中隔离性又分四个级别，它们依次向下，级别越来越高，并发性越来越差，安全性越来越高
READ_UNCOMMITTED 允许存在脏读（事务A读取了事务B未提交的数据，并在这个基础上又做了其他操作）
READ_COMMITTED 不允许脏读，允许不可重复读（事务A读取了事务B已提交的更改数据）
REPEATABLE_READ 不允许脏读，不可重复读，允许幻读（事务A读取了事务B已提交的新增数据）
SERIALIZABLE 全部不允许，做到完全隔离
而Spring是以7种事务传播行为来区别的,假设事务从方法A传播到方法B,用户需要面对方法B,需要知道方法A有事务吗？
PROPAGATION_REQUIRED 如果没有，就新建一个事务；如果有，就加入当前事务。是Spring默认的事务传播行为，适合绝大多数情况。
PROPAGATION_REQUIRES_NEW 如果没有，就新建一个事务；如果有，就将当前事务挂起，意思就是创建了一个新事务，它和原来的事务没有任何关系。
PROPAGATION_NESTED 如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务，也就是“嵌套事务”，所嵌套的子事务与主事务之间是有关联关系的（当主事务提交或回滚，子事务也会提交或回滚）。
PROPAGATION_SUPPORTS 如果没有，就以非事务方式执行；如果有，就使用当前事务。这种方式非常随意，没有就没有，有就有，有点无所谓的态度，反正是支持的。
PROPAGATION_NOT_SUPPORTED 如果没有，就以非事务方式执行；如果有，就将当前事务挂起，这种方式非常强硬，没有就没有，有也不支持，挂起，不管。
PROPAGATION_NEVER 如果没有，就以非事务方式执行；如果有，就抛出异常。这种方式更强硬，没有就没有，有了反而报错，从不支持事务。
PROPAGATION_MANDATORY 如果没有，就抛出异常；如果有，就使用当前事务。这种方式可以说是最强硬的，没有事务就直接报错，必须要有事务。
具体配置为
@Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED)
其中isolation和propagation取值都是枚举。
现在我们来自己实现一个事务管理特性，代码承接于 AOP原理与自实现
首先在pom中增加JDBC的引用，根据你数据库版本的不同而不同，我这里是针对mysql 8的。
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
定义事务注解
package com.guanjian.annotion;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 定义需要事务控制的方法
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Transacion {
}
实现一个线程隔离类
package com.guanjian.proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 线程隔离
*/
public class ThreadLocal<T> {
private Map<Thread,T> container = new ConcurrentHashMap<>();
public void set(T value) {
container.put(Thread.currentThread(),value);
}
public T get() {
Thread thread = Thread.currentThread();
T value = container.get(thread);
if (value == null && !container.containsKey(thread)) {
value = initialValue();
container.put(thread,value);
}
return value;
}
public void remove() {
container.remove(Thread.currentThread());
}
protected T initialValue() {
return null;
}
}
数据库操作助手类
package com.guanjian.util;
import com.guanjian.proxy.ThreadLocal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
* 数据库操作助手类
*/
public class DatabaseHelper {
private static final String driver = "com.mysql.cj.jdbc.Driver";
private static final String url = "jdbc:mysql://192.168.1.102:3306/cloud_user?useSSL=FALSE&serverTimezone=GMT%2B8";
private static final String username = "root";
private static final String password = "root";
//用于放置数据库连接的局部线程变量(使每个线程都拥有自己的连接)，用于线程隔离，生成环境请使用数据库连接池
private static ThreadLocal<Connection> CONNECTION_HOLDER = new ThreadLocal<>();
/**
* 开启事务
*/
public static void beginTransaction() {
Connection conn = getConnection();
if (conn != null) {
try {
conn.setAutoCommit(false);
} catch (SQLException e) {
System.out.println("Begin transaction failure " + e);
throw new RuntimeException(e);
}finally {
CONNECTION_HOLDER.set(conn);
}
}
}
/**
* 提交事务
*/
public static void commitTransaction() {
Connection conn = getConnection();
if (conn != null) {
try {
conn.commit();
conn.close();
} catch (SQLException e) {
System.out.println("commit transaction failure " + e);
throw new RuntimeException(e)
} finally {
CONNECTION_HOLDER.remove();
}
}
}
/**
* 回滚事务
*/
public static void rollbackTransaction() {
Connection conn = getConnection();
if (conn != null) {
try {
conn.rollback();
conn.close();
} catch (SQLException e) {
System.out.println("rollback transaction failure" + e);
throw new RuntimeException(e);
} finally {
CONNECTION_HOLDER.remove();
}
}
}
private static Connection getConnection(){
Connection conn = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(url,username,password);
} catch (Exception e) {
e.printStackTrace();
}
return conn;
}
}
使用事务代理类对标记有@Transaction的方法拦截，进行代理增强
package com.guanjian.proxy;
import com.guanjian.annotion.Transacion;
import com.guanjian.util.DatabaseHelper;
import java.lang.reflect.Method;
/**
* 事务代理
*/
public class TransactionProxy implements Proxy {
//线程事务控制标志，保证同一个线程中事务控制逻辑只会执行一次
private static final ThreadLocal<Boolean> FLAG_HOLDER = new ThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return false;
}
};
@Override
public Object doProxy(ProxyChain proxyChain) throws Throwable {
Object result;
boolean flag = FLAG_HOLDER.get(); //默认false
Method method = proxyChain.getTargetMethod();
//检查方法是否带有@Transaction注解且是同一个线程执行的，进行代理增强
if (!flag && method.isAnnotationPresent(Transacion.class)) {
FLAG_HOLDER.set(true);
try {
DatabaseHelper.beginTransaction();
System.out.println("begin transaction");
//跟代理链双向递归
result = proxyChain.doProxyChain();
DatabaseHelper.commitTransaction();
System.out.println("commit transaction");
}catch (Exception e) {
DatabaseHelper.rollbackTransaction(www.hengtongyoule.com);
System.out.println("rollback transaction");
throw e;
}finally {
//移除该线程
FLAG_HOLDER.remove();
}
}else { //如果没有注解，则只执行被代理类实例本方法
result = proxyChain.doProxyChain();
}
return result;
}
}
在AOPHelper中进行修改
/**
* 创建所有的AOP类，事务类与与之对应的目标类集合的映射
* @return
* @throws Exception
*/
private static Map<Class<?>,Set<Class<?>>> createProxyMap() throws Exception {
Map<Class<?>,Set<Class<?>>> proxyMap = new HashMap<>();
addAspectProxy(proxyMap);
addTransactionProxy(proxyMap);
return proxyMap;
}
/**
* 增加切面代理
* @param proxyMap
* @throws Exception
*http://dasheng178.com/#portal/list.html
private static void addAspectProxy(Map<Class<?>,Set<Class<?>>> proxyMap) throws Exception {
//获取切面代理类(抽象类)的所有实现类(子类)
Set<Class<?>> proxyClassSet = ClassHelper.getClassSetBySuper(AspectProxy.class);
for (Class<?> proxyClass:proxyClassSet) {
//实现类是否有@Aspect标签
if (proxyClass.isAnnotationPresent(Aspect.class)) {
//获取该标签
Aspect aspect = proxyClass.getAnnotation(Aspect.class);
//获取所有目标类集合
Set<Class<?>> targetClassSet = createTargetClassSet(aspect);
//将代理类实例与该集合添加map映射
proxyMap.put(proxyClass,targetClassSet);
}
}
}
/**
* 增加事务代理
* @param proxyMap
*/
private static void addTransactionProxy(www.meiwanyule.cn Map<www.yongshi123.cn Class<?>,Set<Class<?>>> proxyMap) {
//以@Componet标签为开启事务代理的类标签
Set<Class<?>> componentClassSet www.xintiandiyule1.com/= ClassHelper.www.yongshiyule178.comgetClassSetByAnnotation(Component.class);
proxyMap.put(TransactionProxy.www.sanxinyuLevip.com class,componentClassSet);
}
测试
@Component
public class Test4 {
@Transacion
public void show(www.michenggw.com) {
System.out.println("aaa");
}
}
public class Test {
public static void main(String[www.baishenyvip.com] args) {
//扫描包
Manager.scanAndImp("com.guanjian.test");
//初始化AopHelper
ClassUtil.loadClass(AopHelper.class.getName(),true);
//这里其实拿到的是代理类的实例，代理类是目标类的子类
Test4 test4 = (www.sanxingyLzc.com Test4)Manager.getBean(www.suoLaieyuLe.com Test4.class);
test4.show();
}
}
运行结果
aop Class loaded
begin transaction
aaa
commit transaction
相关文章
- spring整合atomikos实现分布式事务
- spring事务传播属性与隔离级别
- 关于 Spring Boot 后端项目使用 Maven 打包命令、JAR/WAR 对比、内嵌服务器与第三方服务器对比，以及热部署配置的详细说明
- Spring AI教程（十六）：检索增强生成（RAG）与函数调用 | Spring AI教程（十七）：实现RAG技术与评估AI响应
- 【Java面试系列】Spring Boot应用中的事务传播机制与分布式事务实践详解 - 3-5年Java开发必备知识
- Java 实现机器学习算法的多种方法与案例-二：具体说明
- Redis系列-JAVA与redis整合-Spring Data Redis实现一个订阅/发布系统
- 【Spring事务详解】--- 、beforeCompletion、afterCommit、afterCompletion实现分析
- @TransactionalEventListener Spring 事务绑定事件的深入学习与使用
- HarmonyOS开发：头像处理与群头像生成的实现-二：具体说明