Java的代理：静态代理、JDK/CGLIB的动态代理

    其实所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用。代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先FQ，然后再访问facebook。这就是代理的作用了。

静态代理：

public class StaticPxory {
    public static void main(String[] args) {
        AProxy  aProxy = new AProxy(new A1());
        aProxy.method();
    }
}
 interface A{
    void method();
}
class A1 implements A{
    @Override
    public void method() {
        System.out.println("A1----------------");
    }
}
class AProxy implements A{
    private A a;
    public AProxy(A a) {
        this.a = a;
    }
    @Override
    public void method() {
        System.out.println("AProxy----------------start");
        a.method();
        System.out.println("AProxy----------------end");
    }
}
打印结果：
AProxy----------------start
A1----------------
AProxy----------------end

    在上面的示例中，一个静态代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象。   
    在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持。
    如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。这也就是AOP(面向切面编程)的基本原理。

动态代理：

public class DynamicProxy {
    public static void main(String[] args) {
        ProxyHandler proxyHandler = new ProxyHandler(new B1());
        B b = (B) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
                new Class[]{B.class},
                proxyHandler);
        b.method();
    }
}
interface B{
    void method();
}
class B1 implements B{
    @Override
    public void method() {
        System.out.println("B1----------------");
    }
}
class ProxyHandler implements InvocationHandler{
    private B b;
    public ProxyHandler(B b) {
        this.b = b;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("start----------------");
        method.invoke(b,args);
        System.out.println("end----------------");
        return null;
    }
}
打印结果：
start----------------
B1----------------
end----------------

    动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强。
    纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，
我们会发现其实动态代理只是对类做了进一步抽象和封装，使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！

    JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类，JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。

1、Jdk动态代理：利用拦截器（必须实现InvocationHandler接口）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理

    JDK代理使用的是反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

    JDK创建代理对象效率较高，执行效率较低；

    JDK动态代理机制是委托机制，只能对实现接口的类生成代理，通过反射动态实现接口类；

2、 Cglib动态代理：利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来进行代理

    CGLIB代理使用字节码处理框架asm，对代理对象类的class文件加载进来，通过修改字节码生成子类。

    CGLIB创建代理对象效率较低，执行效率高。

    CGLIB则使用的继承机制，针对类实现代理，被代理类和代理类是继承关系，所以代理类是可以赋值给被代理类的，因为是继承机制，不能代理final修饰的类

3、使用JDK还是CGLIB

1)如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP，可以强制使用CGLIB实现AOP
2)如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

3、强制使用CGLIB实现AOP的方法
1）添加CGLIB库(aspectjrt-xxx.jar、aspectjweaver-xxx.jar、cglib-nodep-xxx.jar)
2）在Spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class=“true”/>