本人微信公众号"aeolian"~

架构探险笔记8-实现事务控制特性

定义事务注解

我们之前实现过一个Service 注解,用于定义服务类,而在服务类中会包括若干方法, 有些方法是具备事务性的,比如创建、修改、删除等。如何保证这类方法具有事务性呢? 我们可以利用这个Proxy 框架来实现一个简单的事务控制特性。只需要开发者使用Transaction 注解,将其定义在需要事务控制的方法上即可。
下面我们就来实现这个事务管理框架。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Transaction {
}

在Transaction 注解中使用了@Target(ElementType.METHOD), 说明该注解只能用于方法级别。也就是说,我们需要将该注解应用在每个具有耶务性的方法上, 比如:

@Service
public class CustomerService {

    private static final Logger LOGGER = LoggerFactory.getLogger(CustomerService.class);

    /**
     * 获取客户列表
     */
    public List getCustomerList(String keyWord){
        List customerList = null;
        String sql = "select * from customer";
        customerList = DBHelper.queryEntityList(Customer.class,sql);
        return customerList;
    }

    /**
     * 根据id获取客户
     */
    public Customer getCustomer(long id){
        String sql = "select * from customer where id=?";
        Customer customer = DBHelper.queryEntity(Customer.class,sql,id);
        return customer;
    }

    /**
     * 创建客户
     */
    @Transaction
    public boolean createCustomer(Map fieldMap){
        Boolean b = DBHelper.insertEntity(Customer.class,fieldMap);
        return b;
    }

    /**
     * 更新客户
     */
    @Transaction
    public boolean updateCustomer(long id,Map fieldMap){
        Boolean b = DBHelper.updateEntity(Customer.class,id,fieldMap);
        return b;
    }

    /**
     * 删除客户
     */
    @Transaction
    public boolean deleteCustomer(long id){
        Boolean b = DBHelper.deleteEntity(Customer.class,id);
        return b;
    }

}

code

以上createCustomer、updateCustomer、deleteCustomer 方法都带有Transaction 注解,表明它们都是具备事务性的。可以认为,凡是对数据库有变更的方法,都建议带上Transaction 注解,这样就可以保证一旦方法中有一个更新操作失败了,整个方法都可以回滚。

提供事务相关操作

JDBC 提供了郁务常用的操作,比如开启事务、提交事务、回滚事务等,找们可以将这些操作统一封装在DatabaseHelper 中,就像下面这样:

/**
 * 数据库操作助手类
 */
public final class DatabaseHelper {

    /**
     * 开启事务
     */
    public static void beginTransaction(){
        Connection conn = getConnection();   //获取连接(同一线程每次获取的是统一conn)
        if (conn!=null){
            try {
                conn.setAutoCommit(false);  //将自动提交属性改为false
            } catch (SQLException e) {
                LOGGER.error("begin transaction failure",e);
                throw new RuntimeException(e);
                //e.printStackTrace();
            }finally {
                CONNECTION_HOLDER.set(conn);   //将改动属性的conn放入容器中
            }
        }
    }

    /**
     * 提交事务
     */
    public static void commitTransaction(){
        Connection conn = getConnection();
        if (conn != null){
            try {
                conn.commit();   //提交事务
                conn.close();    //关闭连接
            } catch (SQLException e) {
                LOGGER.error("commit transaction failure",e);
                throw new RuntimeException(e);
                //e.printStackTrace();
            } finally {
                CONNECTION_HOLDER.remove();   //从容器中移除连接
            }
        }
    }

    /**
     * 回滚事务
     */
    public static void rollbackTransaction(){
        Connection conn = getConnection();
        if (conn != null){
            try {
                conn.rollback();   //回滚
                conn.close();    //关闭连接
            } catch (SQLException e) {
                LOGGER.error("rollback transaction failure",e);
                throw new RuntimeException(e);
                //e.printStackTrace();
            } finally {
                CONNECTION_HOLDER.remove();   //从容器中移除连接
            }
        }
    }
}

code

需要注意的是, 默认是自动提交事务的, 所以需要将自动提交属性设置为false。在开启事务完毕后, 市~将Connection 对象放入木地线程变;在中。当事务提交或回滚后, 需要移除本地线程变盘中的Connection 对象。

编写事务代理切面类

我们需要编写一个名为TransactionProxy 的类, 让它实现Proxy 接口, 在doProxy 方法中完成事务控制的相关逻辑,代码如下:

public class TransactionProxy implements Proxy{
    private static final Logger LOGGER = LoggerFactory.getLogger(TransactionProxy.class);

    private static final ThreadLocal  FLAG_HOLDER = new ThreadLocal(){
        @Override
        protected Boolean initialValue() {
            return false;
        }
    };
    
    @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 {
                DBHelper.beginTransaction();
                LOGGER.debug("begin transaction");
                result = proxyChain.doProxyChain();
                DBHelper.commitTransaction();
                LOGGER.debug("commit transaction");
            }catch (Exception e){
                DBHelper.rollbackTransaction();
                LOGGER.debug("rollback transaction");
                throw  e;
            }finally {
                FLAG_HOLDER.remove();
            }
        }else {
            result = proxyChain.doProxyChain();
        }
        return result;
    }
}

code

这里定义了一个名为FLAG_HOLDER 的本地线程变量,它是一个标志,可以保证同一个线程中事务控制相关逻辑只会执行一次。通过ProxyChain 对象可获取目标方法,进而判断该方法是否带有Transaction 注解。首先调用口atabaseHelper.beginTransaction 方法开启事务,然后调用ProxyChain 对象的doProxyChain 方法执行目标方法,接着调用DatabaseHelper.commitTransaction提交事务,或者在异常处理中调用DatabaseHelper.rollbackTransacti on 方法回滚事务,最后别忘了移除FLAG_HOLDER 本地线程变量中的标志。

在框架中添加事务代理机制

只需对AopHelper 类的createProxyMap 方法稍作调整,即可将事务代理机制添加到框架中。由于之前添加到AOP 框架中的只是普通切面代理,现在需要将事务代理也添加进去。我们定义两个私有方法, 一个用于添加普通切面代理, 另一个用于添加事务代理,就像下面这样:

public class AopHelper {
    /**
     * 创建所有Map<代理类,Set<代理目标类>>的映射关系
     * @return Map<代理类,Set<代理目标类>>
     * @throws Exception
     */
    private static Map,Set>> createProxyMap() throws Exception{
        Map,Set>> proxyMap = new HashMap, Set>>();   //结果集<代理类,Set<代理目标类>>
        addAspectProxy(proxyMap);   //添加普通切面
        addTransactionProxy(proxyMap);   //添加事务代理
        return proxyMap;
    }

    private static void addAspectProxy(Map,Set>> proxyMap){
        //获取所有的AspectProxy的子类(代理类集合),即切面,
        /*这个是入口,根据基类来查找所有的切面(代理类),获取所有的切面!!!*/
        Set> proxyClassSet = ClassHelper.getClassSetBySuper(AspectProxy.class);
        for (Class proxyClass : proxyClassSet){   //遍历代理类(切面),如ControllerAspect
            if (proxyClass.isAnnotationPresent(Aspect.class)){    //验证基类为AspectProxy且要有Aspect注解的才能为切面。如果代理类的的注解为Aspect(也就是说代理类一定要都切点(注解)才能是切面),例如ControllerAspect代理类的注解为@Aspect(Controller.class)
                Aspect aspect = proxyClass.getAnnotation(Aspect.class);   //获取代理类(切面)的注解

                /*根据注解获取所有的目标类*/
                Set> targetClassSet = createTargetClassSet(aspect);   //获取所有的代理目标类集合

                proxyMap.put(proxyClass,targetClassSet);   //加入到结果集Map<代理类,Set<代理目标类>>中
            }
        }
    }

    /**
     * 获取Transaction的class - targets映射关系
     * @param proxyMap
     */
    private static void addTransactionProxy(Map,Set>> proxyMap) {
        Set> serviceClassSet = ClassHelper.getClassSetByAnnotation(Service.class);
        proxyMap.put(TransactionProxy.class,serviceClassSet);
    }
}

code

当运行应用程序后,就可和到事务代卫!!.切而中输山的日志信息了。到此为止, 一个简单的事务控制框架就开发元毕了。

也可以用AOP的切面实现

/**
 * 拦截器方式实现切面
 */
@Aspect(Service.class)
public class TransactionAspect extends AspectProxy {
    private static final Logger LOGGER = LoggerFactory.getLogger(TransactionAspect.class);

    /**
     * 前置增强
     * @param cls    目标类
     * @param method 目标方法
     * @param params 目标方法参数
     */
    @Override
    public void before(Class cls, Method method, Object[] params) throws Throwable {
        LOGGER.debug("TransactionAspect---------begin---------");
        LOGGER.debug(String.format("class: %s",cls.getName()));
        LOGGER.debug(String.format("method: %s",method.getName()));
        try {
            DBHelper.beginTransaction();   //开启事务
            LOGGER.debug("begin transaction");
        }catch (Exception e){
            DBHelper.rollbackTransaction();   //异常回滚
            LOGGER.debug("rollback transaction");
            throw  e;
        }finally {
        }

    }

    /**
     * 后置增强
     * @param cls    目标类
     * @param method 目标方法
     * @param result 目标方法返回结果
     */
    @Override
    public void after(Class cls, Method method, Object result) throws Throwable {
        try {
            DBHelper.commitTransaction();   //提交方法
            LOGGER.debug("commit transaction");
        }catch (Exception e){
            DBHelper.rollbackTransaction();  //异常回滚
            LOGGER.debug("rollback transaction");
            throw  e;
        }finally {
        }
    }

    /**
     * 拦截只有Transaction注解的方法
     * @param cls    目标类
     * @param method 目标方法
     * @param params 目标方法参数
     * @return 返回是否拦截
     */
    @Override
    public boolean intercept(Class cls, Method method, Object[] params) throws Throwable {
        if (method.isAnnotationPresent(Transaction.class)){
            return true;
        }
        return false;
    }
}

code

但是如果两个都有会报错,因为一个先开启事务后,执行下一个事务,第二个事务执行完毕并且提交然后再执行第一个事务的提交部分。此时Connection已经变为自动提交状态。

如果没有看到日志打印,一定要注意log4j.properties中的log4j.logger.com.autumn=DEBUG配置,否则默认为log4j.rootLogger的等级,Class的根包路径必须是org.smart4j,换做其他是不可以的,会导致日志打印不出来。至于smart4j的jar包,也要有配置log4j.logger.org.smart4j=DEBUG的properties文件。但是最终只会读取项目的properties文件。所以要在项目的properties中加入log4j.logger.org.smart4j=DEBUG。

总结

在本章中,我们首先开发一个Proxy框架,然后通过该框架实现了AOP特性,通过模板方法模式提供了一个抽象的切面类,扩展AspectProxy抽象类并定义Aspect注解,然后完成特定的钩子方法,即可将横切逻辑与业务逻辑相分离,这就是AOP要做的事情。最后,我们使用Proxy框架实现了一个简单的事务代理框架,可在Service类的方法中使用Transaction注解来定义需要进行事务控制的方法。

源码 

点赞

Leave a Reply

Your email address will not be published. Required fields are marked *