1. CGLIB动态代理简介
 
JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
 
2. JDK动态代理与CGLIB区别
 
JDK动态代理和CGLIB字节码生成的区别？
 
JDK动态代理只能对实现了接口的类生成代理，而不能针对类
CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法。因为是继承，所以该类或方法最好不要声明成final
 
3.代码示例
 
注：需要引入相关jar包，下载cglib.jar和asm.jar
 
1. 真实对象
 
package dynamicproxy.cglib;

/**
 * 真实对象
 * @author <u>sunlh</u>
 *
 */
public class HelloWorld { 
     public void sayHelloWorld() {
           System.out.println("Hello World!");
     }
}
 
2. 建立代理对象与真实服务对象的关系&实现代理逻辑方法
 
package dynamicproxy.cglib;

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxyExample implements MethodInterceptor{

     /**
      * 生成CGLIB代理对象
      * @param cls Class类
      * @return Class类的CGLIB代理对象
      */
     public Object getProxy(<u>Class</u> cls) {
           // CGLIB <u>enhancer</u>增强类对象
           Enhancer enhancer = new Enhancer();
           // 设置增强类型
           enhancer.setSuperclass(cls);
           // 定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
           enhancer.setCallback(this);
           // 生成并返回代理对象
           return enhancer.create();
     }   

     @Override
     public Object intercept(Object proxy, Method method, 
Object[] args, MethodProxy methodProxy) throws Throwable {
           System.out.println("调用真实对象前");
           // CGLIB反射调用真实对象方法
           Object result = methodProxy.invokeSuper(proxy, args);
           System.out.println("调用真实对象后");
           return result;
     }
}
 
这里使用CGLIB的加强者EnHancer，通过设置超类的方法（setSuperclass），然后通过setCallback方法设置哪个类为它的代理类。其中，参数为this就意味着是当前对象，那就要求用this这个对象实现接口MethodInterceptor的方法intercept，然后返回代理对象。
 那么此时当前类的intercept方法就是其代理逻辑方法。
 
在反射真实对象前后进行打印，CGLIB通过如下方法完成
 
Object result = methodProxy.invokeSuper(proxy, args);
 
3. 测试CGLIB动态代理
 
package dynamicproxy.cglib;
/**
 * 测试
 * @author sunlh
 *
 */
public class TestCglibProxy {
	public static void main(String[] args) {
		CglibProxyExample cpe = new CglibProxyExample();
		HelloWorld proxy = (HelloWorld) cpe.getProxy(HelloWorld.class);
		proxy.sayHelloWorld("张三");
	}
}
 
控制台输出
 
调用真实对象前
Hello 张三
调用真实对象后
 
4.特殊情况
 
当真实对象声明为final时，使用CGLIB动态代理会报错
 
代码示例
 修改真实对象，声明为final（即不可继承）
 
package dynamicproxy.cglib;
/**
 * 真实对象
 * @author <u>sunlh</u>
 *
 */
public final class HelloWorld {    

     public void sayHelloWorld(String name) {
           System.out.println("Hello " + name);
     }
}
 
再次执行测试方法，控制台输出
 java.lang.IllegalArgumentException: Cannot subclass final class class dynamicproxy.cglib.HelloWorld

Java动态代理可以动态地创建代理并动态地处理对所代理方法的调用。
 
下面用《Java编程思想》中的一个例子说明： 
 首先是接口类，目标类要实现的接口：
 
public interface Interface {
    void doSomething();
    void somethingElse(String args);
}
 
再就是目标类，也可以成为真实类，继承上面的接口并实现其中的方法：
 
public class RealObject implements Interface {

    @Override
    public void doSomething() {
        System.out.println("I am doing something...");
    }

    @Override
    public void somethingElse(String args) {
        System.out.println("doing something else");
    }
}
 
再就是创建一个代理对象，代理对象持有一个Object类型的引用（这说明可以代理任意类型的目标类？），代理对象的构造函数有一个Object类型的参数，用来初始化持有的引用。并且有一个主要的invoke方法。 
 代理类代码如下：
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxyHandler implements InvocationHandler{
    private Object proxied;

    public DynamicProxyHandler(Object proxied){
        this.proxied = proxied;
    }

    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{

        System.out.println("**** proxy:" + proxy.getClass() + ", method:" + method + ", args:" + args);

        if(method.getName().equals("doSomething")){
            System.out.println("detected the doSomething method!");
        }

        if(args!=null){
            for(Object obj:args){
                System.out.print(obj+" ");
            }
        }
        return method.invoke(proxied,args);
    }
}
 
最后是测试类，为目标类动态生成一个代理，并传递个消费者（要使用这个类的对象）。代码如下：
 
import java.lang.reflect.Proxy;

public class SimpleDynamicProxy {
    public static void consumer(Interface iface){
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

    public static void main(String[] args){
        RealObject real = new RealObject();
        consumer(real);

        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(),
                new Class[]{Interface.class},
                new DynamicProxyHandler(real));

        consumer(proxy);
    }
}
 
输出为：
 
I am doing something...
doing something else
**** proxy:class $Proxy0, method:public abstract void proxy.Interface.doSomething(), args:null
detected the doSomething method!
I am doing something...
**** proxy:class $Proxy0, method:public abstract void proxy.Interface.somethingElse(java.lang.String), args:[Ljava.lang.Object;@13785d3
bonobo doing something else
 
通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要一个类加载器，通常可以从已经被加载的对象中获取其加载器，然后传递给它；还需要一个你希望该代理实现的接口列表；以及InvocationHandler接口的一个实现。 
 invoke方法中传递进来了代理对象，以防你需要区分请求的来源，但是在许多情况下，你并不关心这一点。然而在invoke()内部，在代理上调用方法时需要格外小心，因为对接口的调用将被重定向为对代理的调用。

首先定义一个接口
 
public interface IStars {

    void sing();

    void dance();
}
 
其中有两个对应star的方法，dance和sing；
 
然后定义一个star类来实现这个接口
 
public class Stars implements IStars {

    private String name;

    public Stars(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void sing() {
        System.out.println(getName() + "唱了一首歌");
    }

    @Override
    public void dance() {
        System.out.println(getName() + "跳了一支舞");
    }
}
 
这时，需要一个代理类来实现对star类的动态代理，即定义一个代理类
 
public class StarsNewProxy implements InvocationHandler {

    private Object object;
    

    public StarsNewProxy(Object o){
        this.object = o;
    }

    private boolean runBefore(Method method){
        System.out.println("拦截到代理请求");
        if(method.getName().equals("dance")){
            System.out.println("明星脚受伤了，不能跳舞表演了");
            return false;
        }
        return true;
    }

    private void runAfter(Method method){
        System.out.println(method.getName() + "代理请求完毕");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(!runBefore(method))
            return null;
        Object result = method.invoke(object, args);
        runAfter(method);
        return result;
    }
}
 
实现InvocationHandler接口，重写invoke方法，其中的method.invoke即是执行这个方法，除此之外还可以在执行这个方法前和方法后定义一些其他的操作，有点类似于AOP的思想。
 
接下来我们实现一个测试类
 
public class Test {
    public static void main(String[] args) {
        IStars iStars = new Stars("Frank");
        InvocationHandler handler = new StarsNewProxy(iStars);
        IStars proxy = (IStars) Proxy.newProxyInstance(iStars.getClass().getClassLoader(), iStars.getClass().getInterfaces(), handler);
        proxy.dance();
        proxy.sing();
    }
}
 
执行结果如下：
 
 
本文中的动态代理是通过JDK动态代理机制实现的，必须要先实现业务接口，即IStar接口；然后根据反射机制找到对应的被代理的类，就可以在动态生成的代理类中调用业务实现类的同名方法。

 
 
相信很多人在刚刚学习Java时，会感觉【动态代理】晦涩难懂，只知道如何来调用它，却不知道它的实现细节。本文通过根据JDK源码，展示这些细节，以期能对JDK的动态代理有深入的理解。
 
 
简单示例代码
 

public class ProxyInstance implements Product {

    public void show() {
        System.out.println("这是原本的类");
    }

}

public class JdkProxyTest {

    public static void main(String[] args) {
        final ProxyInstance target = new ProxyInstance();
        Product proxy = (Product)Proxy.newProxyInstance(target.getClass().getClassLoader(),
                        target.getClass().getInterfaces(),
                        new InvocationHandler() {
                            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                System.out.println("代理的前置方法");
                                Object object = method.invoke(target, args);
                                System.out.println("代理的后置方法");
                                return object;
                            }
                        });
        proxy.show();
    }

}
 
执行后的打印代码如下：
 
代理的前置方法
这是原本的类
代理的后置方法
 
基于JDK的动态代理最终都是调用了上面类型的代码来实现。有时候感觉动态代理难以理解，是因为示例代码中有几个地方隐藏了实现细节，让人无法完全明白这个过程到底发生了什么。需要搞清楚的有以下2点：
 
①既然说到代理，那么这个代理是何时、如何创建的？
②上面注入的InvocationHandler里的invoke方法由谁来调用执行？
 
代码分析
 
我们从Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)开始分析。
 
待补充