参考《架构探险--从零开始写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;
}