帶着疑問

Proxy 類的作用
怎樣使用Proxy 類
Proxy 工作原理是什麼
產生的Proxy 代理類結構是什麼
反推Proxy的用法

Proxy 的作用

Proxy類提供了靜態方法用來創建動態代理類以及其實例，同時它也是通過調用它的方法產生的動態代理類的父類；這裏有兩點需要說明：1.動態代理類指的是動態代理類對應的Class 實例；2、動態代理類的父類：及所有生成的動態代理類都將繼承Proxy類並實現指定的接口方法加上toString,equals,hashcode三個方法。

使用Proxy 類

方式一：使用Proxy類提供的靜態方法獲取代理類對應的Class 實例，通過此實例基於反射獲取構造函數創建代理類, 代碼如下:

InvocationHandler handler = new MyInvocationHandler(...);
Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
Foo f = (Foo) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);

這裏需要注意的是獲取構造函數時需要獲取參數爲InvocationHandler.class類型的形參構造函數。

方法二：一種更加簡單的方法，直接獲取代理類的實例。

Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class<?>[] { Foo.class },handler);

幾個概念：

dynamic proxy class: 一個代理類代表在運行時實現了指定接口組的類的Class 實例。
proxy instance: 代理類實例是指dynamic proxy class的實例。
proxy interface: 代理接口指代理類需要實現的接口

每個代理類有一個關聯的InvocationHandler 實例(這個實例成員是在Proxy 類聲明的:protected InvocationHandler h)。對代理類調用實現了代理接口的方法時，都會派發到 InvocationHandler 的invoke方法，同時傳遞三個參數： proxy instance(代理實例)，Method(正在被調用的方法)，方式形參的數組。調用處理程序根據需要處理編碼的方法調用，並且它返回的結果將作爲代理實例上的方法調用的結果返回。

一個代理類具有以下特點：

如果所有代理接口都是public: 則代理類是public,final,not abstract.
如果任何一個代理接口不是public: 則代理類是no-public,final,not abstract
代理類的名稱是 “$Proxy” + 數字編號
代理類繼承自 Proxy 類。
如果代理類實現非公共接口，則它將在與該接口相同的包中定義。否則，代理類的包也未指定。請注意，程序包密封不會阻止在運行時在特定程序包中成功定義代理類，也不會由同一個類加載器和具有特定簽名者的相同程序包定義類
Proxy.isProxyClass：用來檢測當前類是否是代理類
每個代理類都有一個公共構造函數，它接受一個參數（接口InvocationHandler的實現）來設置代理實例的調用處理程序。不必使用反射API來訪問公共構造函數，也可以通過調用Proxy.newProxyInstance方法來創建代理實例，該方法將調用Proxy.getProxyClass的操作與使用調用處理程序調用構造函數相結合。

深入Proxy類的原理

要理解Proxy可以從三個重要屬性，兩個重要內部類

三個重要屬性如下：

規定代理類的構造函數的參數類型

 private static final Class<?>[] constructorParams =
        { InvocationHandler.class };

保存代理類的緩存數據結構：

private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

這裏需要先弄懂WeakCache的原理與作用

代理實例的InvocationHandler 實例

   protected InvocationHandler h;

兩個重要方法如下：

靜態方法：newProxyInstance直接獲取代理對象實例：

  public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        // 判斷Invocation 對象不能爲空
        Objects.requireNonNull(h);
        // 複製代理接口
        final Class<?>[] intfs = interfaces.clone();
        // 權限校驗主要檢查loader是否能夠加載代理接口對應的Class 實例
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * 查找代理類的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);
        }
    }

看下私有的: getProxyClass0方法

 private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        // 判斷接口長度
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // 從緩存中去，沒有的話通過ProxyClassFactory 生成,這裏要明白WeakCache的機制
        return proxyClassCache.get(loader, interfaces);
    }

兩個重要內部類：

KeyFactory: 作爲參數傳遞給WeakCache類作爲SubFactoryKey函數生成WeakCache需要的subKey, 它很簡單，只是放回接口實例對應的hashCode

private static final class KeyFactory
        implements BiFunction<ClassLoader, Class<?>[], Object>
    {
        @Override
        public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
            switch (interfaces.length) {
                case 1: return new Key1(interfaces[0]); // the most frequent
                case 2: return new Key2(interfaces[0], interfaces[1]);
                case 0: return key0;
                default: return new KeyX(interfaces);
            }
        }
    }

ProxyClassFactory: 這個纔是生成代理類的主角，它有WeakCache內部調用apply方法來觸發生成代理類的邏輯，本質上生成代理類就是修改字節碼。

private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 定義代理類的名稱前綴
        private static final String proxyClassNamePrefix = "$Proxy";

        // 全局的代理類生成序列數字，它和名稱前綴一起構成代理類的名稱
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

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

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                Class<?> interfaceClass = null;
                try {
                    // 加載代理接口，及生成Class 實例
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
               // 驗證代理接收是一個接口類型
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                // 去重
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
             // 記錄非public 代理接口所在包，用來保證生成的代理類在同一個包類,同時也驗證所有非public 代理在同一個包
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }
            // 組裝代理類名稱
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 生成特殊的代理類,這裏也提供了把二進制寫成.class文件查看代理類的接口的思路
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                // 根據代理類的二級制數據調用defineClass0這個native方法由虛擬機生成代理類的Class實例
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

總體流程如下：

查看生成代理類接口

描述的再多不如真實看一下：查看代理類方法參加：https://blog.csdn.net/u011244682/article/details/96335660
代理接口如下：

public interface PersonService {

    public boolean saveUser(String user);

    public String getUserName();
}

由JDK生成的動態代理類如下：

package com.leran;

import com.learn.proxy.PersonService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class proxy01 extends Proxy implements PersonService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    private static Method m0;

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

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

    public final boolean saveUser(String var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m3, new Object[]{var1});
        } 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);
        }
    }

    public final String getUserName() throws  {
        try {
            return (String)super.h.invoke(this, m4, (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);
        } 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.learn.proxy.PersonService").getMethod("saveUser", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.learn.proxy.PersonService").getMethod("getUserName");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

反推代理類的用法

通過查看生成的代理類結構就知道爲什麼需要傳遞InvocationHandler 對象已經爲什麼需要重寫invoke方法以及AOP 在對invoke方法的處理作用。

reflect包- Proxy類

帶着疑問

Proxy 的作用

使用Proxy 類

深入Proxy類的原理

查看生成代理類接口

反推代理類的用法

相關文件

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

記一次 .NET某工控視覺自動化系統卡死分析

Java 源代碼編譯成 Class 文件的過程分析

css-佈局- box-sizing 的含義及作用

nginx 配置支持websocket

reflect包-WeakCache類

vue props 屬性值接受多個類型

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結