JAVA动态代理

Java动态代理分类

主要分为：JDK代理 和CGLIB代理，前者主要是通过接口来生成一个代理类，后者是通过加装一个具体类class（字节码）来生成一个代理类，以下详细阐述。

（一）JDK代理

依赖的相关技术：InvocationHandler类、Proxy类，从设计模式的角度看，是动态代理+适配器模式，如下图：

即生成的代理类 extends Proxy implements MyInterface(自定义的接口),具体代码如下：

1.自定义接口类

 public interface IComputerSystem{
  //定义抽象方法
   public void work();
}

.2.具体实现类

public class Win2000 implements IComputerSystem{
      public void work(){
          System.out.println("win2000 operation system working...");
      }

}

3.实现动态代理接口InvocationHandler接口，依赖反射动态调用方法

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public MyHandler implements InvocationHandler{
  //保存传入的原始对象
  private Object  target;

  //通过原始对象 ，获取动态生成的代理对象,这里也可以传入Class<?>
  public Object  getProxyObject(Object  target){
         this.target=target;
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

//这里基于反射，注意invoke方法传入的执行对象是target,不是 参数proxy
  public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        doBefore();
        Object obj=   method.invoke(target, args);
        doAfter();
        return obj;
    }

    //方法执行前,这里模拟AOP 的前置方法
    public void doBefore(){
        System.out.println("方法执行前....");
    }

    //方法执行后，这里模拟AOP 的后置方法
    public void doAfter(){
        System.out.println("方法执行后....");
    }```

4.编写测试类

public class Test{
public static void main(String[] args) {
        IComputerSystem  computer= new Win2000();
        MyHandler handler=new MyHandler();
        //通过目标对象生成代理对象
        IComputerSystem proxy=(IComputerSystem) handler.getProxyObject(computer);
        proxy.work();

    }
}

执行结果如下：

方法执行前....
win2000 operation system working...
方法执行后....

相关限制

1.必须依赖接口，执行的反射方法也都是接口中定义的方法；
2.子类中附加方法无法“提取”，即智能针对接口中的方法加以动态处理；

（二）CGLIB代理

cglib代理是通过传入类，结合MethodInterceptor接口、Enhancer类来动态生成传入类的子类，代码如下：

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * CGLib方式实现类的动态代理
 * @author Administrator
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {
    private Enhancer  enHancer=new Enhancer();
    private Object object=null;
    //通过字节码来构造子类
    public Object  getObject(Class<?> class_){
        //设置创建类的父类
        enHancer.setSuperclass(class_);
        //设置回调，参数必须是MethodInterceptor的子类
        enHancer.setCallback(this);
        //创建最终的代理对象
        object=enHancer.create();
        return object;
    }

    public Object intercept(Object obj, Method method, Object[] arg,
            MethodProxy methodProxy) throws Throwable {
         System.out.println("调用动态方法前： ");
         System.out.println("方法名称： "+method.getName());
         method.setAccessible(true) ;
         Object ret=null;
        // Object ret=methodProxy.invoke(obj, arg);

        //   System.out.println("obj:"+obj);
        //   System.out.println("object:"+object);
             ret=methodProxy.invokeSuper(obj, arg);
         //Object ret=methodProxy.invokeSuper(object, arg);
         try{
            //   ret=method.invoke(object, arg);
              ret=methodProxy.invokeSuper(obj, arg);
                 //  ret=methodProxy.invokeSuper(object, arg);
         }catch(Exception e){

         }
         System.out.println("调用动态方法后： ");

        return ret;
    }
}

测试的业务类：

public class HelloWord {

   public void sayHello(String world){
       System.out.println("1:Hello "+world);
   }

   public HelloWord(){
       System.out.println("公有构造器被调用 ");
   }
   //定义私有方法
   private void sayHello2(String world){
       System.out.println("2:Hello "+world);
   }

   //定义final方法,不会被拦截
   public final void sayHello3(String world){
       System.out.println("3:Hello "+world);
   }

 //定义final方法 不会被拦截
   public static void sayHello4(String world){
       System.out.println("4:Hello "+world);
   }

   //调用私有方法，内部的私有方法不会被拦截
   public void sayHello5(String world){
       sayHello2(world);
       System.out.println("5:Hello "+world);
   }

   public void sayHello6(HelloWord hw,String world){
       hw.sayHello4(world); 
       System.out.println("6:Hello "+world);
   }
}

测试类：

public class Test{
public static void main(String[] args) throws Exception {
//      int i=0;
//      System.out.println("最终结果："+getValue(i));

        //Person p=new Person("张三","male");
        //System.out.println(  p.toString());

        MyMethodInterceptor mm=new MyMethodInterceptor();
        Object obj=   mm.getObject(HelloWord.class);

        //这里核实是否是HelloWord 的实例对象
        if(obj instanceof HelloWord ){
            System.out.println("hw is HelloWord 的实例 ");
        }
        HelloWord hw=(HelloWord)obj; 
        //测试方法
//      hw.sayHello(" zhang san");
//      hw.sayHello3(" li si ");
//      hw.sayHello4("wang wu");
//      hw.sayHello5("zhao liu");
        hw.sayHello6(hw, "test");
    }
}

执行结果：

公有有构造器被调用 
hw is HelloWord 的实例
调用动态方法前： 
方法名称： sayHello6
4:Hello test
6:Hello test
4:Hello test
6:Hello test
调用动态方法后： 

相关说明：
1.cglib代理 是通过具体的类来生成代理类，因此不用限制是否存在有接口；
2.类的构造函数不能是私有private,否则允许出错；
3.私有、final、static 方法不能被反射调用，只能被“包装”的调用；