自定义ThreadLocal和事务(基于自定义AOP)
参考《架构探险--从零开始写javaweb框架》4.6章节
自定义ThreadLocal
package smart;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class MyThreadLocal<T> {
private Map<Thread, T> container = Collections.synchronizedMap(new HashMap<>());
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;
}
}
ThreadLocal容器,存放线程局部变量,设计目标:解决线程并发问题,使用场景:存放JDBC Connection,达到事务控制的能力。
将connection放在DBUtil中的静态变量,多个线程操作DBUtil会导致线程不安全,使用多线程测试,线程A关闭线程B的连接,导致出错。所以在DBUtil中使用ThreadLocal存储connection来线程隔离,避免线程不安全。实际工作中推荐使用连接池而不是DBUtil。
Spring事务传播行为7种:
方法A传播到方法B,4种情况:
方法A有事务,方法B也有事务
方法A有事务,方法B没有事务
方法A没有事务,方法B有事务
方法A没有事务,方法B也没有事务
假设事务从方法A传播到方法B,用户需要面对方法B,考虑方法A有事务吗?
propagation_required 没有则新建,有则加入当前事务,spring的默认事务传播行为
propagation_required_new 没有则新建,有则将当前事务挂起,新建一个事务且和原来的事务没关系
propagation_nested 没有则新建,有则嵌套在当前事务中,嵌套子事务与主事务关联(主事务提交或回滚,子事务也提交或回滚),在方法A调用方法B,应该用在方法A而不是方法B上
propagation_supports 没有就以非事务方式执行,有就使用当前事务,有就有,没有就没有,无所谓,反正支持
propagation_not_supported 没有就以非事务方式执行,有就将当前事务挂起,很强硬,没有就没有,有也不支持,挂起来不管它
propagation_never 没有就以非事务方式执行,有就抛异常,很强硬,没有就没有,有反而报错,不支持事务
propagation_mandatory 没有抛异常,有就使用当前事务,很强硬,没有事务要报错,必须要有事务
附加功能:
事务超时:transaction timeout,解决事务时间长消耗资源多的问题,故意给事务设置一个最大时长,超过了就回滚
只读事务:readonly transaction,为了忽略不需要事务的方法,比如读取数据,可以提高性能
xml式事务配置:不推荐,tx:annotation-driven/
注解式事务配置:推荐,方法上使用@Transactional,可在里面设置事务隔离级别,事务传播行为,事务超时时间,是否只读事务。
事务管理思维导图:
基于自定义AOP实现自定义事务:
connection.setAutoCommit(false);关闭自动提交事务(开启事务);
connection.commit();提交事务
connection.rollback();回滚事务
这3个方法放在代理的钩子中:
package smart.myaop;
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 Transaction {
}
package smart.myaop;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import smart.myaop.framework.Proxy;
import smart.myaop.framework.ProxyChain;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.SQLException;
/**
* 事务代理切面类
*/
public class TransactionProxy implements Proxy {
private static final Logger logger = LoggerFactory.getLogger(TransactionProxy.class);
private static final ThreadLocal<Connection> CONNECTION_HOLDER = new ThreadLocal<>();
/**
* FLAG_HOLDER本地线程变量是个标注,保证同一个线程中事务控制相关逻辑只执行一次
*/
private static final ThreadLocal<Boolean> FLAG_HOLDER = new ThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return false;
}
};
/**
* proxyChain对象获取目标方法判断方法是否带有Transaction注解,然后调用beginTransaction方法开启事务,调用proxyChain对象的doProxyChain方法执行目标方法
* 然后调用commitTransaction提交事务或在异常中执行rollbackTransaction方法回滚事务,最后一处FLAG_HOLDER本地线程变量中的标志
* @param proxyChain
* @return
* @throws Throwable
*/
@Override
public Object doProxy(ProxyChain proxyChain) throws Throwable {
Object result;
boolean flag = FLAG_HOLDER.get();
Method method = proxyChain.getTargetMethod();
if(!flag && method.isAnnotationPresent(Transaction.class)) {
FLAG_HOLDER.set(true);
try {
beginTransaction();
logger.debug("begin transaction");
result = proxyChain.doProxyChain();
commitTransaction();
logger.debug("commit transaction");
} catch (Exception e) {
rollbackTransaction();
logger.debug("rollback transaction");
throw e;
} finally {
FLAG_HOLDER.remove();
}
} else {
result = proxyChain.doProxyChain();
}
return result;
}
private void rollbackTransaction() {
Connection connection = getConnection();
if(connection != null) {
try {
connection.rollback();
connection.close();
} catch (SQLException e) {
logger.error("rollback transaction failure", e);
throw new RuntimeException(e);
} finally {
CONNECTION_HOLDER.remove();
}
}
}
/**
* 提交事务,默认事务自动提交,所以将自动提交属性设置为false,开启事务后,将连接对象放入本地线程变量中
* 事务提交或回滚后,移除本地线程变量中的连接对象
*/
private void commitTransaction() {
Connection connection = getConnection();
if(connection != null) {
try {
connection.commit();
connection.close();
} catch (SQLException e) {
logger.error("commit transaction failure", e);
throw new RuntimeException(e);
} finally {
CONNECTION_HOLDER.remove();
}
}
}
/**
* 开启事务
*/
private void beginTransaction() {
Connection connection = getConnection();
if(connection != null) {
try {
connection.setAutoCommit(false);
} catch (SQLException e) {
logger.error("begin transaction failure", e);
throw new RuntimeException(e);
} finally {
CONNECTION_HOLDER.set(connection);
}
}
}
private Connection getConnection() {
return null; //获取connection过程略,开启事务时,应从外界获取连接对象,然后放入本地线程变量,提交和回滚事务从本地线程对象中拿连接对象
}
}
改造自定义AOP时实现的获取增强与被增强类的映射关系获取的方法:
/**
* 给createTargetMap方法用
* 代理类(切面类)与目标类集合之间的一对多映射关系
* 在全部class对象集合中搜索满足1是AspectProxy子类,2被@Aspect注解,这样的类(代理类),根据@Aspect注解指定的注解属性去获取该注解对应的目标类集合
* 然后建立代理类与目标类集合之间的映射关系,据此分析出目标类与代理对象列表之间的映射关系
* @return
* @throws Exception
*/
private static Map<Class<?>, Set<Class<?>>> createProxyMap() throws Exception {
Map<Class<?>, Set<Class<?>>> proxyMap = new HashMap<>();
Set<Class<?>> proxyClassSet = new HashSet<>();
for (Class<?> aClass : allClassSet) {
if(AspectProxy.class.isAssignableFrom(aClass) && !AspectProxy.class.equals(aClass)) {
proxyClassSet.add(aClass); //获取AspectProxy子类class对象集合
}
}
for (Class<?> aClass : proxyClassSet) {
if(aClass.isAnnotationPresent(Aspect.class)) {
Aspect aspect = aClass.getAnnotation(Aspect.class);
Set<Class<?>> targetClassSet = createTargetClassSet(aspect);
proxyMap.put(aClass, targetClassSet);
}
}
/**
* 将事务代理机制添加到AOP中,上面是普通切面代理,这里添加事务代理
* 事务增强类映射到所有@Service类
*/
Set<Class<?>> serviceClassSet = new HashSet<>();
for (Class<?> aClass : allClassSet) {
if(aClass.isAnnotationPresent(Service.class)) {
serviceClassSet.add(aClass); //这里从所有的class集合中挑出被@Service注解的class对象集合
}
}
proxyMap.put(TransactionProxy.class, serviceClassSet);
return proxyMap;
}