自定义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式事务配置:不推荐,
注解式事务配置:推荐,方法上使用@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;
    }
posted @ 2019-10-30 00:44  发挥哥  阅读(...)  评论(... 编辑 收藏