代理的实质就是代理类保存着实际目标类的引用对象。代理分为静态代理和动态代理

静态代理

定义一个目标类接口，并定义两个方法：

public interface ITarget {
    void fun1();
    String fun2(String s);
}

定义一个真实目标类并且实现ITarget接口

public class TargetObject implements ITarget{
    @Override
    public void fun1() {
        System.out.println("执行方法fun1...");
    }

    @Override
    public String fun2(String s) {
        System.out.println("执行方法fun2..." + s);
        return s;
    }
}

定义一个代理类保存着ITarget的引用

public class TargetObjectProxy {
    private ITarget target;
    public TargetObjectProxy(ITarget target){
        this.target = target;
    }
    //目标方法执行前
    public void before(){
        System.out.println("静态代理方法执行前...");
    }

    //目标方法执行后
    public void after(){
        System.out.println("静态代理方法执行后...");
    }
    
    public void fun1() {
        before();
        target.fun1();
        after();
    }

    public String fun2(String s) {
        before();
        String result = target.fun2();
        after();
        return result;
    }
}

上面直接调用TargetObjectProxy的方法即可完成静态代理，传统的三层架构就是使用静态代理实现的，Controller代理Service，Service代理Dao

但是当目标类新增方法，也要在代理类中添加相应的方法，不符合开闭原则

动态代理

动态代理实现有两种，分别是JDK动态代理和CGlib动态代理

JDK动态代理

JDK动态代理要求代理类实现InvocationHandler接口，并且重写invoke方法，使用反射生成代理类

使用

创建一个ObjectProxy类

public class ObjectProxy implements InvocationHandler {
    //目标类
    private Object target;

    public ObjectProxy(Object target){
        this.target = target;
    }

    //反射获取目标类的代理实例
    public <T> T getInstance(){
        Class<?> clazz = target.getClass();
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    public void before(){
        System.out.println("动态代理执行前...");
    }

    public void after(){
        System.out.println("动态代理执行后...");
    }

    /**
     * @param proxy  代理对象 $Proxy0
     * @param method 当前执行方法
     * @param args 方法参数
     * @return 方法的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object o = method.invoke(target, args);
        after();
        return o;
    }
}

测试

public class JDKProxyDemo {
    public static void main(String[] args) throws IOException {
        TargetObjectProxy proxy = new TargetObjectProxy(new TargetObject());
        ITarget target = proxy.getInstance();
        target.fun1();
        System.out.println(target.fun2("hello"));
    }
}

原理

JDK动态代理实际上是在代码运行期间动态生成代理类，编译加载到JVM中，这里主要关注Proxy.newProxyInstance方法

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
         * Look up or generate the designated proxy class.
         */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
         * Invoke its constructor with the designated invocation handler.
         */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

上述代码：

Class<?> cl = getProxyClass0(loader, intfs);

生成了代理类的字节码对象，跟踪发现在Proxy.ProxyClassFactory中有个apply方法，该方法中

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);

生成代理类的字节数组然后通过defineClass加载到JVM中

看一下generateProxyClass方法

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
    //定义代理代码生成器
    ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
    final byte[] var4 = var3.generateClassFile();
    if (saveGeneratedFiles) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                try {
                    int var1 = var0.lastIndexOf(46);
                    Path var2;
                    if (var1 > 0) {
                        Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                        Files.createDirectories(var3);
                        var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                    } else {
                        var2 = Paths.get(var0 + ".class");
                    }

                    Files.write(var2, var4, new OpenOption[0]);
                    return null;
                } catch (IOException var4x) {
                    throw new InternalError("I/O exception saving generated file: " + var4x);
                }
            }
        });
    }

    return var4;
}

最后使用反射生成代理类的对象

CGlib动态代理

使用

定义代理类实现MethodIntercept接口实现intercept方法

public class CGlibProxy implements MethodInterceptor {
    private Object target;

    public <T> T getInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        target = clazz.newInstance();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return (T) enhancer.create();
    }

    public void before(){
        System.out.println("CGlib动态代理方法执行前...");
    }

    public void after(){
        System.out.println("CGlib动态代理方法执行后...");
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object o1 = methodProxy.invokeSuper(o, objects);
        after();
        return o1;
    }
}

原理

CGlib动态代理实际上通过继承目标类实现的，是通过ASM生成class字节码

代理类调用方法时会被拦截器拦截，最终执行methodProxy.invokeSuper方法

public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    try {
        init();
        FastClassInfo fci = fastClassInfo;
        return fci.f2.invoke(fci.i2, obj, args);
    }
    catch (InvocationTargetException e) {
        throw e.getTargetException();
    }
}

JDK动态代理和CGlib动态代理对比

1.JDK 动态代理是实现了被代理对象的接口，CGLib 是继承了被代理对象。
2.JDK 和 CGLib 都是在运行期生成字节码，JDK 是直接写 Class 字节码，CGLib 使用 ASM
框架写 Class 字节码，Cglib 代理实现更复杂，生成代理类比 JDK 效率低。
3.JDK 调用代理方法，是通过反射机制调用，CGLib 是通过 FastClass 机制直接调用方法，
CGLib 执行效率更高。

CGlib生成代理类效率低，执行效率高