动态SQL数据层框架（5）：AOP事务管理

 

这是一个简单的数据层框架，可以实现动态SQL查询、自动化事务管理、IOC和依赖注入，使用了以下技术：

1) Maven管理依赖，Github托管代码　　2) DBUtils框架作为JDBC底层框架　　3) JDK动态代理实现的AOP　　4) 注解　　5) Freemarker来做动态SQL模板的解析　　6) 工厂设计模式　　7) 反射和XML解析

从使用方式开始介绍，逐步深入地去理解框架的各个知识点。

框架主要分为两部分：
1) dynamic-sql-dao是框架主体
2) dynamic-sql-dao-test是一个demo含有测试用例

Github地址

https://github.com/xuguofeng/dynamic-sql-dao
https://github.com/xuguofeng/dynamic-sql-dao-test

 

文章目录

动态SQL数据层框架（0）：一个基于FreeMarker和DBUtils的动态SQL框架
动态SQL数据层框架（1）：DBUtils框架基础
动态SQL数据层框架（2）：框架结构
动态SQL数据层框架（3）：BaseDao接口和BaseDaoSupport抽象类
动态SQL数据层框架（4）：DynamicSQLParser工具类和配置文件
动态SQL数据层框架（5）：AOP事务管理

 

本篇文章主要介绍如何使用JDK动态代理技术、对象工厂模式、注解技术实现AOP自动化事务管理，关于对象工厂可以参考《多态和简单对象工厂》

 

一、BeanFactory工厂

1、静态Map保存对象

/**
 * 保存对象，接口名 —> 实现类对象
 */
private static Map<String, Object> beans = new HashMap<String, Object>();

 

2、加载工厂配置

在类路径下创建beans.properties文件，配置需要使用工厂管理的对象，格式如下：

 

DepartmentDao=org.net5ijy.dao.jdbc.DepartmentDaoImpl
EmployeeDao=org.net5ijy.dao.jdbc.EmployeeDaoImpl
StudentDao=org.net5ijy.dao.jdbc.StudentDaoImpl
TeacherDao=org.net5ijy.dao.jdbc.TeacherDaoImpl

 

Key为接口简单名

Value为对应使用的实现类的全限定名

 

该类有一个静态代码块，用于加载配置，实例化对象、依赖注入以及事务代理对象的创建

 

实例化对象

// 加载beans.properties文件
prop.load(BeanFactory.class.getClassLoader().getResourceAsStream(
        "beans.properties"));

Set<String> keys = prop.stringPropertyNames();

// 遍历，实例化，放入对象缓存beans
for (String key : keys) {
    String className = prop.getProperty(key);
    try {
     // 实例化对象
        Class<?> clazz = Class.forName(className);
        Object obj = clazz.newInstance();

        // 放入对象缓存beans
        beans.put(key, obj);
    } catch (ClassNotFoundException e) {
    } catch (InstantiationException e) {
    } catch (IllegalAccessException e) {
    }
}

 

依赖注入

首先把全部对象获取出来，遍历，获取标注了@Resource注解的set方法，之后从方法名截取set后面的内容，从beans中获取对应的对象，最后调用这个set方法注入依赖对象

Collection<Object> objects = beans.values();
for (Object obj : objects) {
    Method[] methods = obj.getClass().getMethods();
    for (Method method : methods) {
        if (method.getAnnotation(Resource.class) != null) {
            String methodName = method.getName().replace("set", "");
            Object o = beans.get(methodName);
            try {
                method.invoke(obj, o);
            } catch (Exception e) {
                log.error("依赖注入出错", e);
            }
        }
    }
}

 

事务扫描

对工厂中的全部对象进行遍历，如果某个对象所属类型标注了@Transactional注解，就使用TransactionProxy.proxyFor创建一个这个对象的代理对象，这个代理对象可以实现事务的管理，后面会有详细介绍

Set<String> beanNames = beans.keySet();
for (String name : beanNames) {
    Object obj = beans.get(name);
    Class<?> clazz = obj.getClass();
    if (clazz.getAnnotation(Transactional.class) != null) {
        // 使用JDK动态代理
        obj = TransactionProxy.proxyFor(obj);
        beans.put(name, obj);
    }
}

 

 

3、静态方法获取对象

/**
 * 根据指定接口类Class对象获取实现类bean
 */
public static <T> T getObject(Class<T> clazz) {
    Object bean = beans.get(clazz.getSimpleName());
    if (bean != null) {
        return (T) bean;
    }
    return null;
}

 

二、TransactionProxy和TransactionInvocationHandler

1、@Transactional注解

/**
 * 标注在需要使用事务的业务层类和方法上
 */
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Transactional {

}

 

之前在介绍“工厂事务扫描”时提到了工厂会为标注了@Transactional的类的对象创建能够管理事务的代理对象。

而且，这个注解还可以标注在方法上，代理对象内部会判断调用的方法是否标注了@Transactional注解，如果标注了才会进行事务管理。

 

2、TransactionProxy创建代理对象

该类有一个proxyFor静态方法使用JDK的动态代理机制为传入的Object对象创建代理对象。

public static Object proxyFor(Object object) {
    return Proxy.newProxyInstance(object.getClass().getClassLoader(),
            object.getClass().getInterfaces(),
            new TransactionInvocationHandler(object));
}

 

内部类TransactionInvocationHandler实现了InvocationHandler接口。在创建TransactionInvocationHandler时需要传入被代理的对象

private Object proxy;
private Class<?> proxyClass;

TransactionInvocationHandler(Object object) {
    this.proxy = object;
    this.proxyClass = object.getClass();
}

 

实现了invoke方法，可以对被代理对象进行方法拦截、事务管理。

 

首先判断拦截到的方法是否标注了@Transactional注解

Transactional t = this.proxyClass.getMethod(method.getName(),
        method.getParameterTypes()).getAnnotation(Transactional.class);

 

如果没有@Transactional注解直接执行方法并返回

if (t == null) {
    return method.invoke(proxy, objects);
}

 

如果有@Transactional注解，首先使用TransactionManager.startTransacation()开启事务，然后执行方法获取返回值，使用TransactionManager.commit()提交事务。如果执行方法过程中发生异常，会使用TransactionManager.rollback()回滚事务，最后在finally里面使用TransactionManager.close()关闭数据库连接。

 

完整的invoke方法如下：

public Object invoke(Object obj, Method method, Object[] objects)
        throws Throwable {

    Object result = null;

    // 判断是否有Transactional注解
    Transactional t = this.proxyClass.getMethod(method.getName(),
            method.getParameterTypes()).getAnnotation(Transactional.class);
    try {
        // 没有Transactional注解直接执行返回
        if (t == null) {
            return method.invoke(proxy, objects);
        }
        // 有Transactional注解
        // 开启事务
        TransactionManager.startTransacation();
        // 获取业务操作返回值
        result = method.invoke(proxy, objects);
        // 提交事务
        TransactionManager.commit();
    } catch (Exception e) {
        log.error("业务操作失败", e);
        // 异常时事务回滚
        if (t != null) {
            TransactionManager.rollback();
        }
        throw e;
    } finally {
        // 关闭连接
        TransactionManager.close();
    }
    return result;
}

 

三、TransactionManager工具类

1、功能概述

之前的数据库连接工具类DBCPUtil管理着一个静态的数据源，调用getConnection()方法时会从数据源获取一个数据库连接。这个类并不能管理事务。

如果需要事务，开发者就要在DAO实现中显式地开启事务、提交、回滚和关闭连接。如下：

public boolean addEmployee(Employee e) {

    Connection conn = null;
    PreparedStatement prep = null;

    try {
        conn = DBUtil.getConnection();

        conn.setAutoCommit(false);

        // ...

        conn.commit();

        return true;

    } catch (SQLException e1) {
        try {
            conn.rollback();
        } catch (SQLException e2) {
        }
    } finally {
        try {
            if (prep != null) {
                prep.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e1) {
        }
    }
    return false;
}

 

2、核心作用

在介绍TransactionInvocationHandler时，我们提到了：

使用TransactionManager.startTransacation()开启事务，TransactionManager.commit()提交事务，TransactionManager.rollback()回滚事务，TransactionManager.close()关闭数据库连接。

 

有了BeanFactory工厂、事务扫描、事务代理对象之后，我们只需要在Service实现类和需要使用事务的方法上标注@Transactional就可以实现自动化的事务管理了，如下：

@Transactional
public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    @Resource
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    @Transactional
    public boolean doTransfer(Account from, Account to, Double amount) {

        // 判断转出账户余额是否充足
        if (from.getBalance() < amount) {
            throw new RuntimeException("转出账户余额不足，操作失败");
        }
        // 设置
        from.setBalance(from.getBalance() - amount);
        to.setBalance(to.getBalance() + amount);
        // 修改数据
        boolean b1 = this.accountDao.updateObject(from);

        boolean b2 = this.accountDao.updateObject(to);
        // 操作全部成功才返回true
        if (b1 && b2) {
            return true;
        }
        throw new RuntimeException("转账操作失败");
    }
}

 

在DAO中使用TransactionManager.getConnection()即可获取到当前线程上绑定的连接，在数据操作时不需要管理事务、关闭连接。

 

3、实现方式

内部使用ThreadLocal用于绑定当前线程和一个数据库连接

 

private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

 

所有的方法都只是对当前线程上绑定的连接进行操作

/**
 * 获取当前线程绑定的Connection
 */
public static Connection getConnection() throws SQLException {
    Connection conn = tl.get();
    if (conn == null) {
        conn = DBCPUtil.getConnection();
        tl.set(conn);
    }
    return conn;
}
/**
 * 开启事务
 */
public static void startTransacation() throws SQLException {
    getConnection().setAutoCommit(false);
}
/**
 * 提交事务
 */
public static void commit() throws SQLException {
    getConnection().commit();
}
/**
 * 回滚事务
 */
public static void rollback() throws SQLException {
    getConnection().rollback();
}
/**
 * 关闭连接
 */
public static void close() throws SQLException {
    getConnection().close();
    tl.remove();
}