Java 动态代理笔记 —— JDK动态代理

代理的问题常常被提到，本身自己也比较模糊，借助慕课网的课程学习下，本身作作笔记，下次不清楚回来在看看，本文主要是介绍下JDK动态代理。

• 代理分两种：静态代理（代理设计模式里面会涉及到）、动态代理（jdk、cglib）

1、概述

caller -> proxy -> target

JDK动态代理是基于 接口 的，proxy(runtime 动态生成字节码)和target都会实现相同的接口，proxy能够对target进行包装，如在target调用方法先后作自定义处理。

2、流程

JDK动态代理是利用反射技术，动态生成对应的代理类，利用InvocationHandler接口的invoke实现具体方法调用。

• 接口

public interface Subject {

    void helloWorld();
}
复制代码

• target 目标类

public class RealSubject implements Subject {

    @Override
    public void helloWorld() {
        System.out.println("hello world");
    }
}
复制代码

• InvocationHandler

public class JdkProxySubject implements InvocationHandler {

    private RealSubject realSubject;

    public JdkProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = null;
        try {
            result = method.invoke(realSubject, args);
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println("after");
        return result;
    }
}
复制代码

• 结果

public class Client {

    public static void main(String[] args) {
        // 显示动态生成的代理对象的class文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        Subject subject = (Subject) Proxy.newProxyInstance(
            Client.class.getClassLoader(), 
            new Class[]{Subject.class}, 
            new JdkProxySubject(new RealSubject())
        );
        subject.helloWorld();
    }
    
    ／**
    * 运行的结果
    * before
    * hello world
    * after
    *／
}
复制代码

• 代理对象的class文件

package com.sun.proxy;

import com.juststand.aop.dynamic.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void helloWorld() throws {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.juststand.aop.dynamic.Subject").getMethod("helloWorld");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

复制代码

3、源码解析

3.1 Proxy

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 复制代码

运行时动态生成字节码文件，而且在运行时候加载类，须要三个构造函数

• 类加载器
• 须要代理的接口
• 调用处理器 InvocationHandler

3.2 Proxy.newProxyInstance(..) -> getProxyClass0(..)

/** * a cache of proxy classes */
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}
复制代码

若是proxy class已经存在就从缓存中返回，若是没有就经过ProxyClassFactory建立。

WeakCache内部是ConcurrentHashMap

3.3 Proxy.newProxyInstance(..) -> getProxyClass0(..) -> ProxyClassFactory.apply(..)

内部用反射生成须要的Class对象。

ProxyClassFactory.apply(..) 里面经过ProxyGenerator.generateProxyClass(..)生成代理对象的字节码文件。

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
复制代码

平时debug看到的一些$Proxy0这样的东西，都是在apply方法里面生成的，ProxyClassFactory有个全局变量

// prefix for all proxy class names
    private static final String proxyClassNamePrefix = "$Proxy";
        
 // next number to use for generation of unique proxy class names
    private static final AtomicLong nextUniqueNumber = new AtomicLong();
复制代码

3.4 $Proxy0

subject.helloWorld() 实际上 $Proxy0.helloWorld() ，$Proxy0调用父类Proxy的InvocationHandler.invoke(..)方法，在本例中就是JdkProxySubject.invoke(..)