代理模式
代理模式一般包含三個(gè)角色：

1. Subject：主題對象，一般是一個(gè)接口，定義一些業(yè)務(wù)相關(guān)的基本方法。
2. RealSubject：具體的主題對象實(shí)現(xiàn)類，它會實(shí)現(xiàn)Subject接口中的方法。
3. Proxy：代理對象，里面包含一個(gè)RealSubject的引用，外部會通過這個(gè)代理對象，來實(shí)現(xiàn)RealSubject中方法的調(diào)用。

JAVA中提供了動態(tài)代理的實(shí)現(xiàn)，需要依賴InvocationHandler。

舉個(gè)例子

Subject

首先創(chuàng)建一個(gè)主題對象，里面定義一個(gè)execute方法：

public interface Subject {
    void execute();
}

RealSubject

接著創(chuàng)建具體的主題對象實(shí)現(xiàn)類，它會實(shí)現(xiàn)Subject的方法

public class RealSubject implements Subject {
    @Override
    public void execute() {
        System.out.println("realsubject方法執(zhí)行");
    }
}

創(chuàng)建InvocationHandler

JDK動態(tài)代理需要依賴InvocationHandler，所以這里創(chuàng)建一個(gè)ProxyInvocationHandler實(shí)現(xiàn)它的invoke方法，并提供了getProxy方法來獲取創(chuàng)建的代理對象，ProxyInvocationHandler類中引用了需要代理的目標(biāo)對象，也就是RealSubject，在invoke方法中通過反射執(zhí)行了RealSubject中的方法：

public class ProxyInvocationHandler implements InvocationHandler {

    /**
     * 代理的目標(biāo)對象，也就是RealSubject
     */
    private Object target;

   /**
     * 構(gòu)造函數(shù)
     */
    public ProxyInvocationHandler(Object target){
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("開始執(zhí)行方法：" + method.getName());
        // 通過反射執(zhí)行RealSubject中的方法
        Object result = method.invoke(target, args);
        System.out.println("結(jié)束執(zhí)行方法：" + method.getName());
        return null;
    }

    public Object getProxy() {
        // 創(chuàng)建代理對象，傳入了類加載器、要代理對象的接口、InvocationHandler（this當(dāng)前對象）
        return Proxy.newProxyInstance(Thread.currentThread()
                        .getContextClassLoader(), target.getClass().getInterfaces(), this);
    }
}

測試：

public class ProxyTest {
    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        // 創(chuàng)建實(shí)際的對象
        Subject subject = new RealSubject();
        // 創(chuàng)建InvocationHandler，這里傳入的真是對象
        ProxyInvocationHandler invocationHandler = new ProxyInvocationHandler(subject);
        // 獲取代理對象
        Subject proxy = (Subject) invocationHandler.getProxy();
        // 執(zhí)行方法
        proxy.execute();
    }
}

運(yùn)行結(jié)果：

開始執(zhí)行方法：execute
realsubject方法執(zhí)行
結(jié)束執(zhí)行方法：execute

根據(jù)輸出結(jié)果，可以看出JDK動態(tài)代理，主要是通過InvocationHandler生成一個(gè)代理對象，通過這個(gè)代理對象可以執(zhí)行目標(biāo)方法，執(zhí)行之時(shí)，首先會進(jìn)入到InvocationHandler中的invoke方法，在創(chuàng)建InvocationHandler時(shí)
傳入了實(shí)際的對象RealSubject，所以InvocationHandler中可以拿到真實(shí)對象，只需要在InvocationHandler中的invoke方法中通過反射執(zhí)行RealSubject中對應(yīng)的方法即可。

動態(tài)代理實(shí)現(xiàn)原理

在ProxyInvocationHandler中可以看到通過Proxy創(chuàng)建了一個(gè)代理對象，那么接下來就進(jìn)入到Proxy中，看一下是如何創(chuàng)建代理對象的：

        // 創(chuàng)建代理對象，傳入了類加載器、要代理對象的接口、InvocationHandler（this當(dāng)前對象）
        return Proxy.newProxyInstance(Thread.currentThread()
                        .getContextClassLoader(), target.getClass().getInterfaces(), this);

Proxy

在Proxy中newProxyInstance方法創(chuàng)建代理對象的時(shí)候，傳入了類加載器、需要代理的對象以及InvocationHandler：

1. 根據(jù)類加載器和需要代理的對象接口信息生成代理對象的class；
2. 根據(jù)生成的代理類的class信息，獲取類的構(gòu)造器；
3. 通過構(gòu)造器創(chuàng)建代理對象，并將InvocationHandler傳入；

public class Proxy implements java.io.Serializable {
    // 創(chuàng)建代理對象
    @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);
        }
        // 1. 根據(jù)類加載器和需要代理的對象接口信息生成代理對象的class
        Class<?> cl = getProxyClass0(loader, intfs);
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            // 2. 獲取類構(gòu)造器
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            // InvocationHandler
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // 3. 通過構(gòu)造器創(chuàng)建代理對象，并將InvocationHandler傳入
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
           //...
        }
    }
}

生成代理類的class

getProxyClass0中首先會進(jìn)行邊界檢查，然后根據(jù)類加載器和需要代理的對象接口信息從緩存中獲取生成的代理類的calss，具體的實(shí)現(xiàn)在WeakCache的get方法中：

   /**
     * 代理類的緩存
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

    /**
     * 生成代理類的class
     */
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        // 邊界檢查
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        // 從緩存proxyClassCache中獲取class
        return proxyClassCache.get(loader, interfaces);
    }

   

WeakCache

WeakCache的get方法中如果根據(jù)緩存key獲取對象為空，會創(chuàng)建一個(gè)Factory對象賦值給Supplier，F(xiàn)actory是WeakCache的一個(gè)內(nèi)部類，它實(shí)現(xiàn)了Supplier接口，然后調(diào)用Supplier的get方法來生成代理類的class，接下來進(jìn)入到Factory的get方法中：

final class WeakCache<K, P, V> {
    // 獲取class
    public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);
        expungeStaleEntries();
        // 獲取緩存key
        Object cacheKey = CacheKey.valueOf(key, refQueue);
        // 根據(jù)key獲取對象
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        // 如果為空
        if (valuesMap == null) {
            // 創(chuàng)建一個(gè)ConcurrentMap
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }
        // 創(chuàng)建subKey
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;
        while (true) {
            if (supplier != null) {
                // 調(diào)用get方法獲取class
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            // 如果為空，創(chuàng)建Factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }
            // 如果supplier為null
            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // 將factory賦值給supplier
                    supplier = factory;
                }
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    supplier = factory;
                } else {
                    // retry with current supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }
}

Factory

Factory是WeakCache的一個(gè)內(nèi)部類，它實(shí)現(xiàn)了Supplier接口，在get方法中，又調(diào)用了valueFactory的apply方法創(chuàng)建class，valueFactory是WeakCache的一個(gè)成員變量，在WeakCache的構(gòu)造函數(shù)中可以看到傳入了valueFactory對象進(jìn)行初始化，那么接下來就需要回到Proxy類中，看一下如何實(shí)例化WeakCache的：

final class WeakCache<K, P, V> {
    
    private final BiFunction<K, P, V> valueFactory;
    
    public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                     BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        // 初始化
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }

    // Factory
    private final class Factory implements Supplier<V> {

        private final K key;
        private final P parameter;
        private final Object subKey;
        private final ConcurrentMap<Object, Supplier<V>> valuesMap;

        Factory(K key, P parameter, Object subKey,
                ConcurrentMap<Object, Supplier<V>> valuesMap) {
            this.key = key;
            this.parameter = parameter;
            this.subKey = subKey;
            this.valuesMap = valuesMap;
        }

        @Override
        public synchronized V get() { 
            // 
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }
            
            V value = null;
            try {
                // 調(diào)用valueFactory的apply方法創(chuàng)建class
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            
            ......
              
            return value;
        }
    }
}

ProxyClassFactory

Proxy中WeakCache初始化的時(shí)候使用的是ProxyClassFactory類型的factory：

public class Proxy implements java.io.Serializable {  
     /**
     * WeakCache初始化
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
}

所以調(diào)用valueFactory的apply方法的時(shí)候會進(jìn)入到ProxyClassFactory的apply方法，在apply方法中會通過ProxyGenerator動態(tài)生成代理類并加載類，然后將實(shí)例化的代理類返回：

 private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 前綴
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            ......

            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 生成代理類
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                // 加載代理，并返回對象
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

ProxyGenerator

ProxyGenerator是Proxy的一個(gè)內(nèi)部類，用于動態(tài)生成class：

 private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> {  
      public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        // 生成class
        final byte[] var4 = var3.generateClassFile();
        // 是否保存到文件,如果開啟了之后，運(yùn)行程序之后會在包下面生成class文件
        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), new String[0]);
                            Files.createDirectories(var3, new FileAttribute[0]);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class", new String[0]);
                        }

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

代理類的生成

由于設(shè)置了sun.misc.ProxyGenerator.saveGeneratedFiles為true，所以可以在包下面看到生成的代理類$Proxy0：

1. 它繼承了Proxy并實(shí)現(xiàn)了Subject，并且在構(gòu)造函數(shù)中需要傳入InvocationHandler對象；
2. 當(dāng)執(zhí)行$Proxy0中的execute方法時(shí)，實(shí)際上調(diào)用的是InvocationHandler的invoke方法；

package com.sun.proxy;

import com.example.demo.bean.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

// 動態(tài)生成了一個(gè)$Proxy0類，它繼承了Proxy并實(shí)現(xiàn)了Subject
public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;
    // 傳入InvocationHandler對象
    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 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);
        }
    }
    
    // Subject的execute方法
    public final void execute() throws  {
        try {
            // 調(diào)用了InvocationHandler的invoke方法
            super.h.invoke(this, m3, (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", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.example.demo.bean.Subject").getMethod("execute", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

總結(jié)

JDK的動態(tài)代理實(shí)現(xiàn)原理是在運(yùn)行中動態(tài)生成代理類，這個(gè)代理類實(shí)現(xiàn)了Subject接口，在對代理類進(jìn)行實(shí)例化的時(shí)候，需要傳入InvocationHandler，當(dāng)調(diào)用代理類的方法時(shí)，會執(zhí)行InvocationHandler的invoke方法，在invoke方法中再執(zhí)行真正的目標(biāo)方法，從而完成代理功能。

參考

【拉勾教育】Dubbo源碼解讀與實(shí)戰(zhàn)-代理模式與常見實(shí)現(xiàn)文章來源地址http://www.zghlxwxcb.cn/news/detail-710795.html

到了這里，關(guān)于【Java】JDK動態(tài)代理實(shí)現(xiàn)原理的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！