java 动态代理模式（jdk和cglib）

package proxy.dynamicproxy;

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


/**
 * 需要实现InvocationHandler接口，内部维护一个实际类实例
 *
 */
public class JdkProxyHandler implements InvocationHandler {

    private Object realObject;

    public Object proxy(Object realObject){
        this.realObject = realObject;
        return Proxy.newProxyInstance(this.realObject.getClass().getClassLoader(),
                this.realObject.getClass().getInterfaces(), this);
    }

    /**
     *
     * @param proxy 动态生成的代理类实例
     * @param method 方法实例
     * @param args 方法参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是代理人：大明星唱歌开始前，我先宣传一下：巴拉巴拉。。。");

        // 调用实际类的方法，并传入参数，内部是反射机制
        Object ret = method.invoke(this.realObject, args);

        System.out.println("我是代理人：大明星唱歌完毕了，我来总结一下：巴拉巴拉。。。");

        return ret;
    }
}

package proxy.dynamicproxy;

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

import java.lang.reflect.Method;

/**
 * 需要实现MethodInterceptor接口
 * cglib相关依赖：
 * ant-1.6.2.jar
 * asm-3.1.jar
 * asm-util-3.1.jar
 * cglib-2.2.2.jar
 */
public class CglibProxyHandler implements MethodInterceptor {

    public Object proxy(Object realObject){

        // 使用字节码增强器 四个固定步骤：
        // 1、new字节码增强器
        // 2、设置当前类实例为回调
        // 3、将实际类实例设置为父类
        // 4、创建一个代理类
        Enhancer enhancer = new Enhancer();
        enhancer.setCallback(this);
        enhancer.setSuperclass(realObject.getClass());
        // 这里会生成代理类、代理类的FastClass辅助类、实际类的FastClass辅助类
        // 辅助类为代理类和实际类的每个方法生成一个唯一的id
        // 用于在调用intercept方法时，通过唯一id就可以调用对应的方法
        // 不再走反射机制，提高性能
        return enhancer.create();
    }

    /**
     *
     * @param o 代理类的实例
     * @param method 方法实例
     * @param objects 方法参数
     * @param methodProxy 方法代理
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("我是代理人：大明星唱歌开始前，我先宣传一下：巴拉巴拉。。。");

        // 这里如果使用 method.invoke方法，就等同于走了反射机制去调用方法，性能不高
        // 而且还需要另外维护实际类实例
        // Object ret = method.invoke(this.realObject, objects);

        Object ret = methodProxy.invokeSuper(o, objects);

        System.out.println("我是代理人：大明星唱歌完毕了，我来总结一下：巴拉巴拉。。。");

        return ret;
    }
}

package proxy.dynamicproxy;

import net.sf.cglib.core.DebuggingClassWriter;
import proxy.staticproxy.IStar;
import proxy.staticproxy.RealStar;

public class Test {
    public static void main(String[] args) {

        /**
         * 还是以“代理人”和“大明星”为例
         * jdk动态代理：适用于大明星实现某接口的情况，且只能用于实现接口的情况
         *      不能用于未实现任何接口的类，因为生成的动态代理类要继承自Proxy、同时实现大明星接口。
         * cglib动态代理：适用于任何类。它是采用动态代理类直接继承大明星类的方式，将大明星当作父类
         *      覆写大明星类的所有方法（除final修饰的方法，wait方法，notify方法）
         *
         * 优缺点：
         * jdk方式，只能针对接口，底层直接写字节码的方式生成代理类，所以生成代理类速度快
         *      但是代理类执行方法时，通过反射的方式去执行，速度不如cglib方式
         * cglib方式，可以适用于任何类，底层使用ASM框架生成字节码，因为采用FastClass机制
         *      在生成代理类的同时还要生成代理类和大明星类的对应FastClass类（辅助类）
         *      这两个辅助类的作用是：对应FastClass辅助类会为代理类和大明星类的每一个方法
         *      （除final修饰的方法，wait方法，notify方法）生成唯一id，这样在后面的调用方法时
         *      不再通过反射去执行逻辑，而是直接根据id找到对应的方法去执行，提高性能，但相对的，生成字节码速度较慢
         */
        boolean isUseJdkProxy = false;

        if (isUseJdkProxy) {
            System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

            IStar star = (IStar) new JdkProxyHandler().proxy(new RealStar());
            star.sing();
        }
        else {

            System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
                    "C:\Users\Administrator\IdeaProjects\untitled\cglibClass");

            IStar star = (IStar) new CglibProxyHandler().proxy(new RealStar());

            // 这一步里面的具体流程：
            // 动态代理类的sing方法 --> CglibProxyHandler的intercept方法
            //  --> 实际类执行前的行为代理 --> MethodProxy.invokeSuper方法
            //  --> 根据唯一id在FastClass里找到对应的实际方法
            //  --> 代理类的FastClass内部：让代理类调用实际方法
            //  --> 代理类的实际方法内部一般就是直接调用父类(被代理类)的方法
            //  --> 返回父类方法的返回值
            star.sing();

        }
    }
}