java动态代理理解

看spring aop时了解到，原理是有接口的是java动态代理，无接口的是cglib代理。

然后又去了解java动态代理，看了一些帖子，总结了一下。

public  interface Subject {
  abstract  public  void request();
}

// 具体角色RealSubject：
public  class RealSubject implements Subject {
  public RealSubject() {}

  public  void request() {
    System.out.println( " From real subject. " );
 }

}

// 代理处理器：
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;

public  class DynamicSubject implements InvocationHandler {
  private Object sub;
  public DynamicSubject() {}

  public DynamicSubject(Object obj) {
    sub = obj;
  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println( " before calling "  + method);
    method.invoke(sub,args);

    System.out.println( " after calling "  + method);
    return  null ;
  }
}

该方法中的method.invoke(sub,args);其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象

 

/ 客户端：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Client {

  static public void main(String[] args) throws Throwable {
   RealSubject rs = new RealSubject(); // 在这里指定被代理类
   InvocationHandler ds = new DynamicSubject(rs);
   Class cls = rs.getClass();

   // 以下是一次性生成代理
   Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );
   subject.request();
  }
}

// 程序运行结果：
before calling public abstract void Subject.request()
From real subject.
after calling public abstract void Subject.request()

使用动态代理的步骤基本上是两步：
1.创建一个实现InvocationHandler接口的类，它里面实现了invoke方法。
2.然后通过Proxy.newProxyInstance（）返回一个代理队对象，但是它需要的参数是一个实现了InvocationHandler接口的处理器对象。当代理对象调用某个方法时，会被封装转发到处理器的invoke方法，在invoke方法中调用委托对象的对应方法以及增强的方法。

通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口 (Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实 现了非常灵活的动态代理关系。

 

上面的一些变量和方法的说明在参考文章里有，我就不赘述了。

参考文章：

java代理机制

Java 动态代理(Dynamic proxy) 小结

java静态代理和动态代理