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>源码地址
传送门