摘要：原理動(dòng)態(tài)代理要求代理目標(biāo)必須是接口的實(shí)現(xiàn)類，通過接口生成模板類，模板類實(shí)現(xiàn)所有接口方法，實(shí)現(xiàn)方法是一個(gè)個(gè)模板方法，只是簡(jiǎn)單的通過反射把請(qǐng)求委托給處理。

public interface IBiz {
    void doSomething();
}

public class BizImpl implements IBiz {

    public void doSomething() {
        System.out.println("做一些業(yè)務(wù)邏輯");
    }
}

public class PerformanceMonitor {

    public void start() {
        System.out.println("開始時(shí)間: " + String.valueOf(System.currentTimeMillis()));
    }

    public void end() {
        System.out.println("結(jié)束時(shí)間: " + String.valueOf(System.currentTimeMillis()));
    }
}

為接口生成的模板代理類，所有方法調(diào)用時(shí)都會(huì)委托給InvocationHandler.invoke(...)代為處理，它根據(jù)傳入的Method信息，使用反射機(jī)制調(diào)用真實(shí)的方法。

public class BizInvocationHandler implements InvocationHandler {

    private IBiz target;
    private PerformanceMonitor monitor;

    public BizInvocationHandler(IBiz target) {
        this.target = target;
        this.monitor = new PerformanceMonitor();
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        monitor.start();
        method.invoke(target);
        monitor.end();
        return null;
    }
}

public class ProxyBuilder {

    private Class [] interfaces;
    private InvocationHandler handler;
    private ClassLoader classLoader = ProxyBuilder.class.getClassLoader();

    public static ProxyBuilder newProxyBuilder() {
        return new ProxyBuilder();
    }

    public ProxyBuilder setInterFaces(Class[] interFaces) {
        this.interfaces = interFaces;
        return this;
    }

    public ProxyBuilder setClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
        return this;
    }

    public ProxyBuilder setInvocationHandler(InvocationHandler handler) {
        this.handler = handler;
        return this;
    }

    public Object build() {
        return Proxy.newProxyInstance(classLoader, interfaces, handler);
    }

    public void buildClassFile(String className, String dir) {
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(className, interfaces);

        StringBuilder strBuilder = new StringBuilder();
        strBuilder.append(dir).append("/").append(className).append("class");
        String classFileName = strBuilder.toString();

        FileOutputStream out = null;
        try {
            out = new FileOutputStream(classFileName);
            out.write(proxyClassFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

其中build()生成代理對(duì)象；buildClassFile(...)生成代理類的class文件。

public class JDKProxyTest {

    @Test
    public void testBiz() {
        IBiz biz = new BizImpl();
        BizInvocationHandler hander = new BizInvocationHandler(biz);

        IBiz proxy = (IBiz)ProxyBuilder.newProxyBuilder()
            .setClassLoader(Thread.currentThread().getContextClassLoader())
            .setInterFaces(new Class[] {IBiz.class})
            .setInvocationHandler(hander)
            .build();
        proxy.doSomething();
    }
}

執(zhí)行輸出:

開始時(shí)間: 1500530510627
做一些業(yè)務(wù)邏輯
結(jié)束時(shí)間: 1500530510628

JDK動(dòng)態(tài)代理使用步驟如下:

實(shí)現(xiàn)InvocationHandler接口，為其載入代理的目標(biāo)實(shí)例&橫切邏輯，通過實(shí)現(xiàn)invoke方法實(shí)現(xiàn)橫切邏輯織入。

通過Proxy.newProxyInstance(...)把要代理的接口和InvocationHandler實(shí)例聯(lián)系起來生成最終的代理實(shí)例。

通過強(qiáng)制類型轉(zhuǎn)換可以把生成的代理實(shí)例轉(zhuǎn)換成任何一個(gè)代理的接口類型，從而調(diào)用接口方法。

JDK動(dòng)態(tài)代理要求代理目標(biāo)必須是接口的實(shí)現(xiàn)類，通過接口生成 模板類 ，模板類實(shí)現(xiàn)所有接口方法，實(shí)現(xiàn)方法是一個(gè)個(gè) 模板方法 ，只是簡(jiǎn)單的通過反射把請(qǐng)求委托給InvocationHandler.invoke(...)處理。

回頭看下ProxyBuilder.buildClassFile(...)，它通過ProxyGenerator.generateProxyClass(...)生成IBiz的代理類。

public class JDKProxyTest {

    @Test
    public void testBuildClassFile() {
        IBiz biz = new BizImpl();
        BizInvocationHandler hander = new BizInvocationHandler(biz);

        ProxyBuilder.newProxyBuilder()
            .setClassLoader(Thread.currentThread().getContextClassLoader())
            .setInterFaces(new Class[] {IBiz.class})
            .setInvocationHandler(hander)
            .buildClassFile("proxy", ".");
    }
}

直接通過Idea打開生成的proxy.class文件即可，反編譯后的代碼一下(注意：這里去掉了hashCode、toString等無強(qiáng)關(guān)聯(lián)性代碼):

public final class proxy extends Proxy implements IBiz {
    private static Method m1;
    
    ...

    public proxy(InvocationHandler var1) throws  {
        super(var1);
    }

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

    static {
        try {
            m1 = Class.forName("jdkproxy.IBiz").getMethod("doSomething", new Class[0]);
            
            ...
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

哈哈，代碼非常簡(jiǎn)單，無謂多說。

入口: Proxy.newProxyInstance(...)

    public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        ...
        
        final Class[] intfs = interfaces.clone();
        
        // 獲取或生成指定接口的代理類，這里會(huì)對(duì)生成的代理類進(jìn)行緩存，下面展開。
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            ...

            // 獲取代理類的構(gòu)造方法
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                // 構(gòu)造方法不為public的話，修改其訪問屬性
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            
            // 通過反射調(diào)用代理類的構(gòu)造方法實(shí)例化代理對(duì)象返回。
            return cons.newInstance(new Object[]{h});
        } catch ...
        
        ...
    }

Proxy.getProxyClass0(...)

    private static Class getProxyClass0(ClassLoader loader,
                                           Class... interfaces) {
        // 限制接口數(shù)量
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // 這是一個(gè)WeakCach。
        // 如果cache中存在由loader加載并且實(shí)現(xiàn)了interfaces接口的代理類，就直接返回。
        // 否則就通過ProxyClassFactory創(chuàng)建代理類
        // proxyClassCache = (new WeakCache<>(new KeyFactory(), new ProxyClassFactory());)
        return proxyClassCache.get(loader, interfaces);
    }

ProxyClassFactory.apply(...)

最終生成代理類的邏輯就在這里

        public Class apply(ClassLoader loader, Class[] interfaces) {
            ....
            // 生成代理類的字節(jié)碼，buildClassFile.buildClassFile也是這樣生成代理類的。
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                // 返回定義的代理類
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                ...
            }
        }

通過JDK代理生成的代理類是一個(gè)模板類，它通過反射找到接口的所有方法，并為每一個(gè)方法生成模板方法，通過反射調(diào)InvocationHandler.invoke(...)，通常業(yè)務(wù)邏輯和橫切都在這里被調(diào)用。

由于JDK代理生成的代理類相對(duì)cglib生成子類要輕量級(jí)一些，所以在生成代理的效率上要優(yōu)于cglib代理，但是在調(diào)用時(shí)，GDK代理通過反射的方式調(diào)用，相對(duì)cglib直接調(diào)用效率上要低。