动态代理

动态代理是什么呢？
动态代理其实是一种方便运行时候动态的处理代理方法的调用机制。
通过动态代理可以给我们带来什么呢？通过代理可以让调用者和实现者之间解耦，例如RPC调用，对于我们调用者来说我就是想对用远程的那个方法，对于内部寻址啊，序列化反序列化等等这些交给代理来就行了，这样就能解放我们双手！
或者我们平日开发中需要监控一些方法的执行性能等，这时候就很时候用到代理了。
如我们需要监控每一个方法调用的开始时间和结束时间。

public class TestServiceImpl implements  TestService {
  public void test1() {
    Monitor.begin("test1");
    System.out.println("执行方法test1");
    Monitor.end("test1");
  }

  public void test2() {
    Monitor.begin("test2");
    System.out.println("执行方法test2");
    Monitor.end("test2");
  }
}

public class Monitor {
  public static void begin(String method) {
    System.out.println("begin monitor :" + method + "--" + System.currentTimeMillis());
  }

  public static void end(String method) {
    System.out.println("end monitor :" + method + "--" + System.currentTimeMillis());
  }
}

这样的话就把那些非业务逻辑的代码嵌入到我们的业务中，破坏了业务代码的纯粹性，所以我们希望把这个非业务的代码从业务代码中剥离出来，通过动态代理，我们可以将这些代码移除在动态运行的时候再织入它！
我们常见的动态代理有：JDK动态代理、Cglib(基于ASM)等。
JDK动态代理是基于Java的反射机制实现的，主要涉及到java.lang.reflect包中的Proxy和InvocationHandler。
InvocationHandler是一个接口，通过实现这个接口定义一个横切的逻辑！然后通过反射机制调用目标类的方法，这样就能动态的把非业务逻辑和业务逻辑动态的拼接在一起！
proxy则利用InvocationHandler创建代理实例，来间接的调用代理的方法！

public class MonitorHandler implements InvocationHandler {

  private Object target;

  private MonitorHandler(Object target) {
    this.target = target;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Monitor.begin(
        target.getClass().getName() + "." + method.getName() + "--" + System.currentTimeMillis());
    Object obj = method.invoke(target, args);
    Monitor.end(
        target.getClass().getName() + "." + method.getName() + "--" + System.currentTimeMillis());
    return obj;
  }
}

public static void main(String args[]){
    Testservice target = new TestServiceImpl();
    MonitorHandler handler = new MonitorHandler(target);
    Testservice proxy = (Testservice) Proxy.newProxyInstance(
                                target.getClass().getClassLoader(), 
                                target.getClass().getInterfaces(),
                                handler);
    proxy.test1();
    proxy.test2();
}

这样的话非业务代码就被剥离开了！但是注意JDK的反射是基于接口的！也就是你的service一定是有接口的不然是不行的！这时候就有个Cglib可以顶上了！
Cglib采用了底层的字节码技术，为代理类创建了一个子类来代理它！

public class CglibMonitorProxy implements MethodInterceptor {
   private Enhancer enhancer = new Enhancer();
   public Object getProxy(Class clazz){
       enhancer.setSuperclass(clazz);
       enhancer.setCallback(this);
       return enhancer.create();
   }
   public Objcet intercept(Object obj, Method method,Object[] args,MethodProxy proxy) throws Throwable{
       Monitor.begin(obj.getClass().getName() + "." + method.getName() + "--" + System.currentTimeMillis());
       Object obj = proxy.invokeSuper(obj,args);
       Monitor.end(obj.getClass().getName() + "." + method.getName() + "--" + System.currentTimeMillis());
       return obj;
   }
}
   public static void main(String args[]){
       CglibMonitorProxy proxy = new CglibMonitorProxy();
       TestserviceImpl testService = (TestserviceImpl) proxy.getProxy(TestServiceImpl.class);
       testservice.test1();
       testservice.test2();
       }

但是要注意一点，Cglib因为是用子类代理所以对目标类中的final或者private方法无法进行代理。
再来对比一下JDK动态代理和Cglib，JDK动态代理在java1.3之前性能很差，但是随着java版本的提升jdk代理的性能也有所提升，但是据有研究表明，Cglib的性能是JDK动态代理的大概十倍，但是Cglib创建动态代理所花费的时间是JDK的大概八倍。因此对于无需频繁创建代理对象的例如单例或者是有实力池的代理，比较适合用Cglib。反正它们两的性能差别不是数量级上面的差别！
但是以上的代码我们可以看出，我们每次调用service都需要new 代理类！而且基本上等于强制service的每个方法都被监控了！有时候我们就需要其中的重点的一两个！
所以如果我们有用Spring的话，推荐使用Spring AOP。AOP的底层就是通过使用JDK或者Cglib的动态代理实现的！

---

如有错误欢迎指正！