JDK和CGLIB动态代理实现AOP控制事务
前言
还是接着xml方式自定义实现Ioc容器
这个实例中，没有进行事务得操作，不能保持一个线程操作中事务得一致性；
@Override
public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {
Account from = accountDao.queryAccountByCardNo(fromCardNo);
Account to = accountDao.queryAccountByCardNo(toCardNo);
from.setMoney(from.getMoney()-money);
to.setMoney(to.getMoney()+money);
accountDao.updateAccountByCardNo(to);
//模拟异常代码
int c = 1/0;
accountDao.updateAccountByCardNo(from);
}
service 层没有添加事务控制，这样会出现脏数据，可能会出现以下场景：
- 1 没扣钱 ，别人账户加了钱
- 2 扣了钱，别人账户没加上钱
解决这种脏数据问题是给service加上事务操作，如果出现异常，我们就让他回滚，如果没有我们就手动提交事务；
当前线程2个update操作内的数据库操作属于同一个
线程内执行调用,可以让这个线程使用同一个数据库连接
1 如何让两个Update语句再同一个事务中呢！
在JDBC的事务操作中，必须操作的是同一个Connection连接
我们可以让两个update语句使用同一个数据库连接！
2 如何让让两个update语句使用同一个数据库连接？
Java中使用ThreadLocal给当前线程绑定同一个对象
ThreadLocal<T> threadLocal = new ThreadLocal<>();
所以我们来修改一下这行代码
Connection con = DruidUtils.getInstance().getConnection();
将获取连接部分抽离出来，定义一个连接工厂ConnetionUtil类,单例它，保持一个对象，避免不同得连接对事务影响；
public class ConnetionUtil {
//单例 保持唯一
private ConnetionUtil(){}
private static ConnetionUtil connetionUtil = new ConnetionUtil();
public static ConnetionUtil getconnetionUtil(){
return connetionUtil;
}
private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
public Connection getConnection() throws SQLException {
Connection connection = threadLocal.get();
if (threadLocal.get()==null){
connection = DruidUtils.getInstance().getConnection();
//绑定当前线程 数据库连接
threadLocal.set(connection);
}
//存在直接返回这个连接
return connection;
}
//开启事务
public void start() throws SQLException {
//不自动提交
getConnection().setAutoCommit(false);
}
//提交事务
public void commit() throws SQLException {
getConnection().commit();
}
//关闭事务 回滚事务
public void rowback() throws SQLException {
getConnection().rollback();
}
public void close() throws SQLException {
getConnection().close();
}
}
然后再dao层去更改一下获取连接的地方
Connection con = ConnetionUtil.getconnetionUtil().getConnection();
然后再service层去控制事务，关闭自动事务提交，使用try..catch 捕获极可；
try {
//开启事务
TransferServicemanager.get().start();
Account from = accountDao.queryAccountByCardNo(fromCardNo);
Account to = accountDao.queryAccountByCardNo(toCardNo);
from.setMoney(from.getMoney()-money);
to.setMoney(to.getMoney()+money);
accountDao.updateAccountByCardNo(to);
//模拟异常代码
int c = 1/0;
accountDao.updateAccountByCardNo(from);
//提交事务
TransferServicemanager.get().commit();
}catch (Exception e){
//回滚事务
TransferServicemanager.get().rowback();
System.out.println(e.getStackTrace());
throw new RuntimeException("失败!");
}finally {
//关闭连接
System.out.println(ConnetionUtil.getconnetionUtil());
ConnetionUtil.getconnetionUtil().close();
}
这样就可以实现手动控制事务，从而进一步保证数据一致性；
思考一下，平时工作中系统中有很多得写语句，那么每一个业务层我们都手动去加一下，事务控制代码，那不得被累死；
我们需要改造一下，这块代码，使用代理去实现这块，动态的生成一个代理类去执行这块业务逻辑
基于类的职责，我们定义一个事务管理器类TransferServicemanager，将事务代码剥离出来，专门去管理事务操作！
public class TransferServicemanager {
private TransferServicemanager(){}
//单例
private static TransferServicemanager t = new TransferServicemanager();
//对外提供对象接口
public static TransferServicemanager get(){
return t;
}
//开启事务
public void start() throws SQLException {
//不自动提交
ConnetionUtil.getconnetionUtil().start();
}
//提交事务
public void commit() throws SQLException {
ConnetionUtil.getconnetionUtil().commit();
}
//关闭事务 回滚事务
public void rowback() throws SQLException {
ConnetionUtil.getconnetionUtil().rowback();
}
}
定义动态代理工厂ProxyFactory类,这里通过传入的被代理对象，使用JDK和CGLIB去生成代理对象！
public class ProxyFactory {
//单例
private ProxyFactory() {
}
private static ProxyFactory jdkProxy = new ProxyFactory();
//对外提供接口
public static ProxyFactory getJdkProxy() {
return jdkProxy;
}
/**
* Jdk动态代理
*
* @param obj 被代理的对象
* @return 返回代理对象
*/
public Object getJdkProxy(Object obj) {
//生成代理对象
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
Object result = null;
try {
//开启事务
TransferServicemanager.get().start();
result = method.invoke(obj, objects);
//提交事务
TransferServicemanager.get().commit();
} catch (Exception e) {
//回滚事务
TransferServicemanager.get().rowback();
System.out.println(e.getStackTrace());
throw new RuntimeException("失败!");
} finally {
//关闭连接
System.out.println(ConnetionUtil.getconnetionUtil());
ConnetionUtil.getconnetionUtil().close();
}
return result;
}
});
}
/**
* Jdk动态代理
*
* @param object 被代理的对象
* @return 返回代理对象
*/
public Object getCglibProxy(Object object) {
//生成代理对象
return Enhancer.create(object.getClass(), new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
Object result = null;
try {
//开启事务
TransferServicemanager.get().start();
result = method.invoke(object, objects);
//提交事务
TransferServicemanager.get().commit();
} catch (Exception e) {
//回滚事务
TransferServicemanager.get().rowback();
System.out.println(e.getStackTrace());
throw new RuntimeException("失败!");
} finally {
//关闭连接
System.out.println(ConnetionUtil.getconnetionUtil());
ConnetionUtil.getconnetionUtil().close();
}
return result;
}
});
}
}
在代理类里执行原对象方法前后控制事务操作；
try {
//开启事务
TransferServicemanager.get().start();
result = method.invoke(object, objects);
//提交事务
TransferServicemanager.get().commit();
} catch (Exception e) {
//回滚事务
TransferServicemanager.get().rowback();
System.out.println(e.getStackTrace());
throw new RuntimeException("失败!");
} finally {
//关闭连接
System.out.println(ConnetionUtil.getconnetionUtil());
ConnetionUtil.getconnetionUtil().close();
}
return result;
}
最后在控制层去获取找个代理对象去执行方法
委托对象是增强了事务控制的功能（这个对象就已经增强了事务操作）
// 3 从工厂获取
// 3.1 获取jdk代理对象 ProxyFactory
private TransferService transferService = (TransferService) ProxyFactory.getJdkProxy().getJdkProxy(BeanFactorys.getBean("transferService"));
// 3.2 获取cglib 代理对象 ProxyFactory
// private TransferServiceImpl transferService = (TransferServiceImpl) ProxyFactory.getJdkProxy().getCglibProxy(BeanFactorys.getBean("transferService"));
需要的cglib依赖
<!--引入cglib依赖包-->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.1_2</version>
</dependency>
