动态代理 aop切面实现事务管理

1、定义接口和实现

  
public interface UserService {  
    public String getName(int id);  
  
    public Integer getAge(int id);  
}  

　

public class UserServiceImpl implements UserService {  
    @Override  
    public String getName(int id) {  
        System.out.println("------getName------");  
        return "Tom";  
    }  
  
    @Override  
    public Integer getAge(int id) {  
        System.out.println("------getAge------");  
        return 10;  
    }  
}  

　　

　

2、jdk动态代理实现

BeanFactiory 创建注入方法时使用

               if (object.getClass().getPackage().getName().equals("")) {
                    ConnectionDynamicProxy connectionDynamicProxy = new ConnectionDynamicProxy();
                    connectionDynamicProxy.setTarget(object);

                    //daili object
                    Object proxyObject = Proxy.newProxyInstance(object.getClass().getClassLoader(),
                            object.getClass().getInterfaces(), connectionDynamicProxy);
                    return proxyObject;
                }

　　

public class ConnectionDynamicProxy implements InvocationHandler{

    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        boolean needMyClose = false;
        Connection   conn = (Connection) AppContext.getAppContext().getObject("APP_REQUEST_THREAD_CONNECTION");
        if (conn == null) {
            conn = DBUtil.getConnection();
            needMyClose = true;
            AppContext.getAppContext().addObject("APP_REQUEST_THREAD_CONNECTION",conn);
        }
        try {
            result = method.invoke(target, args);
        } finally {
            if (needMyClose) {
                conn = (Connection) AppContext.getAppContext().getObject("APP_REQUEST_THREAD_CONNECTION");
                DBUtil.close(conn, null, null);
                AppContext.getAppContext().removeObject("APP_REQUEST_THREAD_CONNECTION");
                conn = null;
            }
        }
        return result;
    }

}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;

import com.augmentum.oes.util.DBUtil;

public class ConnectionDynamicProxy implements InvocationHandler{

    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        boolean needMyClose = false;
        boolean isCommitOrRollbackTran =  false;
        ConnectionHolder   connectionHolder = (ConnectionHolder) AppContext.getAppContext().getObject("APP_REQUEST_THREAD_CONNECTION");

        if (connectionHolder == null) {
            connectionHolder = new ConnectionHolder();
            Connection conn = DBUtil.getConnection();
            connectionHolder.setConn(conn);
            if (method.getName().equals("add")) {
                DBUtil.setAutoCommit(conn, false);
                connectionHolder.setStartTran(true);
                isCommitOrRollbackTran = true;
            }
            AppContext.getAppContext().addObject("APP_REQUEST_THREAD_CONNECTION",connectionHolder);
            needMyClose = true;
        } else {
            if (method.getName().equals("add")) {
                if(!connectionHolder.isStartTran()) {
                    connectionHolder.setStartTran(true);
                    DBUtil.setAutoCommit(connectionHolder.getConn() , false);
                    isCommitOrRollbackTran = true;
                }
            }
        }
        try {
            result = method.invoke(target, args);
            if (method.getName().equals("add")) {
                if (isCommitOrRollbackTran) {
                DBUtil.commit(connectionHolder.getConn());
                }

            }
        } catch (Throwable throwable) {
            if (method.getName().equals("add")) {
                if (isCommitOrRollbackTran) {
                    DBUtil.rollback(connectionHolder.getConn());
                }

            }
            throw throwable;
        } finally {
            if (needMyClose) {
                connectionHolder = (ConnectionHolder) AppContext.getAppContext().getObject("APP_REQUEST_THREAD_CONNECTION");
                DBUtil.close(connectionHolder.getConn(), null, null);
                AppContext.getAppContext().removeObject("APP_REQUEST_THREAD_CONNECTION");
                connectionHolder.setConn(null);
                connectionHolder = null;
            }
        }
        return result;
    }

}

　放置connection与是否开启事务

package com.augmentum.oes.common;

import java.sql.Connection;

public class ConnectionHolder {
    private Connection conn;
    private boolean isStartTran = false;

    public Connection getConn() {
        return conn;
    }

    public void setConn(Connection conn) {
        this.conn = conn;
    }

    public boolean isStartTran() {
        return isStartTran;
    }

    public void setStartTran(boolean isStartTran) {
        this.isStartTran = isStartTran;
    }

}

 也就是说main函数里面的proxy实际就是$Proxy0的一个实例对象。
可知JDK动态代理是使用接口生成新的实现类，实现类里面则委托给InvocationHandler，InvocationHandler里面则调用被代理的类方法

　

3、cglib动态代理实现

 Cglib是通过直接继承被代理类，并委托为回调函数来做具体的事情：

从代理类里面可知道对于原来的add函数，代理类里面对应了两个函数分布是add 和CGLIB$add$0
其中后者是在方法拦截器里面调用的的，前者则是我们使用代理类时候调用的函数。当我们代码调用add时候，会具体调用到方法拦截器的intercept方法，该方法内则通过proxy.invokeSuper调用CGLIB$add$0

这是一个需要被代理的类，也就是父类，通过字节码技术创建这个类的子类，实现动态代理。

public class SayHello {  
 public void say(){  
  System.out.println("hello everyone");  
 }  
}  

　　

该类实现了创建子类的方法与代理的方法。getProxy(SuperClass.class)方法通过入参即父类的字节码，通过扩展父类的class来创建代理对象。intercept()方法拦截所有目标类方法的调用，obj表示目标类的实例，method为目标类方法的反射对象，args为方法的动态入参，proxy为代理类实例。proxy.invokeSuper(obj, args)通过代理类调用父类中的方法。

public class CglibProxy implements MethodInterceptor{  
 private Enhancer enhancer = new Enhancer();  
 public Object getProxy(Class clazz){  
  //设置需要创建子类的类  
  enhancer.setSuperclass(clazz);  
  enhancer.setCallback(this);  
  //通过字节码技术动态创建子类实例  
  return enhancer.create();  
 }  
 //实现MethodInterceptor接口方法  
 public Object intercept(Object obj, Method method, Object[] args,  
   MethodProxy proxy) throws Throwable {  
  System.out.println("前置代理");  
  //通过代理类调用父类中的方法  
  Object result = proxy.invokeSuper(obj, args);  
  System.out.println("后置代理");  
  return result;  
 }  
}  

　　实现类

public class DoCGLib {  
 public static void main(String[] args) {  
  CglibProxy proxy = new CglibProxy();  
  //通过生成子类的方式创建代理类  
  SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class);  
  proxyImp.say();  
 }  
}  

　结果

前置代理
hello everyone
后置代理

　　

　

关闭事务自动提交   
public static void setAutoCommit(Connection conn, boolean autoCommit) {
        try {
            conn.setAutoCommit(autoCommit);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new DBException();
        }
    }

同一事务代码块


提交事务  commit
catch  调用
    public void rollback(Connection conn) {
        try {
            conn.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
            throw  new DBException();
        }
    }

　　

　

　四 spring 进行 事务 管理

    <!-- add Transation Manger -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
        <!-- start  Transation annoation -->  加入这个时可以直接使用注解@Transctional
        <tx:annotation-driven transaction-manager="transactionManager"/>
    </bean>
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="update" propagation="REQUIRED" read-only="false"/>
            <tx:method name="deleteById" propagation="REQUIRED" read-only="false"/>
            <tx:method name="getNextId" propagation="REQUIRED" read-only="false"/>
            <tx:method name="addUpdate" propagation="REQUIRED" read-only="false"/>
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut expression="execution(* com.augmentum.oes.service..*.*(..))" id="pc"/>
        <aop:advisor pointcut-ref="pc" advice-ref="txAdvice" order="1"/>
    </aop:config>

rollbackFor  设置为此异常回滚。 大部分异常继承runtimeException

对应JDK动态代理机制是委托机制，具体说动态实现接口类，在动态生成的实现类里面委托为hanlder去调用原始实现类方法。

比如接口类为Abo,实现类为AboImpl,AboImpl的代理类为$ProxyAoImpl ，那么$ProxyAoImpl 能赋值给Abo?能够赋值给AboImpl？

$ProxyAoImpl 是能够赋值给Abo的，因为前者间接实现了后者，但是$ProxyAoImpl 不能赋值给AboImpl因为他们没有继承或者实现关系。所以回顾下自己项目中Rpc里面autowired时候都是对bo类进行的，而不是对boimpl，并且我们的boimpl类一般都是配置了事务切面被代理过的。

对应Cglib则使用的继承机制，具体说被代理类和代理类是继承关系，所以代理类是可以赋值给被代理类的,如果被代理类有接口，那么代理类也可以赋值给接口。

另外JDK代理只能对接口进行代理，Cglib则是对实现类进行代理。