手写系列之 —— 实现Spring事务注解功能

Spring事务分为编程式事务和声明式事务，编程式事务是手动控制，声明式事务是利用注解或者配置文件自动实现事务控制，本篇文章主要实现利用注解完成声明式事务的功能。

Spring

一、思路说明

• 实现思想

  • 主要利用AOP以及编程式事务的原理，通过AOP在事务方法的前后加上事务处理方法，AOP的实现原理是利用动态代理机制，重写执行类的代理方法，在需要执行事务方法的前后加上编程式事务的开始、提交、回滚方法实现自动控制

• 实现步骤

  • 1、自定义事务注解标签
  • 2、通过扫包获取到所有添加了事务注解的类和方法，将类和方法保存到容器当中
  • 3、利用动态代理机制实现类似aop的功能
  • 4、初始化类对象时判断容器中是否存在，存在则将利用动态代理重新生成对象，在方法的前后加上编程式事务的操作

实现步骤

二、功能实现

1、自定义事务注解

/**
 * 自定义的事务注解
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTransactional {
}

2、通过扫包将添加了注解的类和方法保存到容器中

由于此处重点在于介绍声明式事务的实现原理，所以关于IOC的相关方法不做考虑，此demo暂时使用集合缓存事务方法

    // 暂时使用静态的list模拟IOC注入容器
    private static List> IOC_LIST = new ArrayList<>();
    
    /**
     * 初始化扫包注入
     * 由于此处的重点不是IOC，所以扫包注入的过程在外部直接调用初始化
     */
    private static void initIOC() {

        // 获取包下有多少类
        List> classList = ClassUtil.getClasses(PACKAGE_NAME);
        for (Class cls : classList) {

            // 遍历每个类查询类的所有方法
            Method[] declaredMethods = cls.getDeclaredMethods();
            for (Method method : declaredMethods) {

                // 判断方法上是否有标注的事务注解，有则添加到容器内
                if (method.getAnnotation(MyTransactional.class) != null) {
                    // 此方法有事务注解，则利用动态代理原理添加事务机制
                    Map map = new HashMap<>();
                    map.put("class", cls);
                    map.put("method", method.getName());
                    IOC_LIST.add(map);
                }
            }
        }
    }

3、初始化对象时利用动态代理重新生成对象

    /**
     * 初始化获取对象，并检测是否需要添加事务代理
     */
    private static Object initObject(ClassPathXmlApplicationContext context, String beanId) {
        Object object = context.getBean(beanId);

        // 判断是否在IOC容器内有事务标签
        for (Map map : IOC_LIST) {
            Class cls = (Class)map.get("class");
            if (cls.getName().equals(object.getClass().getName())) {
                for (Method method : cls.getDeclaredMethods()) {
                    if (method.getName().equals(map.get("method"))) {
                        // 存在保存的事务方法，则执行动态代理方法重新初始化对象
                        ServiceInvocationHandler invocationHandler = new ServiceInvocationHandler(object,
                                method.getName(), (TransactionUtil) context.getBean("transactionUtil"));

                        // 重新生成代理之后的对象
                        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), invocationHandler);
                    }
                }
            }
        }
        return object;
    }

4、定义动态代理方法，手动实现事务处理

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        if (method.getName().equals(methodName)) {

            // 开始事务
            TransactionStatus transactionStatus = transactionUtil.begin();
            Object returnObj = null;
            try {
                returnObj = method.invoke(object);
                transactionUtil.commit(transactionStatus);
            } catch (Exception e) {

                e.printStackTrace();

                // 抓到报错，进行事务回滚
                transactionUtil.rollBack(transactionStatus);
            }
            // 提交事务
            return returnObj;
        }
        return method.invoke(object);
    }

完成代码，更多示例程序持续更新中。