1.エージェンシーモデル

代理模式一般的に使用されるデザインパターンの1つであり、その特徴はプロキシクラスは、プロキシクラスと同じインターフェイスを備えています。プロキシクラスは、プロキシクラスメソッドを実行するための前処理と後処理を実行して、プロキシクラスメソッドを拡張できます。

ここに写真の説明を挿入

プロキシモデルのクラス構造は、通常、上図のようになります。プロキシクラスとプロキシクラスの間に関連付け関係があります。プロキシクラスのオブジェクトは、プロキシクラスのオブジェクトを保持します。プロキシクラス自体のオブジェクトは実際にはサービスを実装していませんが、プロキシクラスオブジェクトの関連するメソッドを呼び出すことによって特定のサービスを提供します

2.動的プロキシの使用

プロキシクラスはJavaコードでは定義されていませんが、Javaコード（字节码由JVM在运行时动态生成而非预存在任何一个 .class 文件中）の「指示」に従って実行時に動的に生成されます。プログラムの実行中にプロキシクラスを作成するこのプロキシメソッドは、动态代理、その利点は、プロキシクラスの機能を便利に処理できることです。これは、プロキシによって実行されるすべてのメソッドがメソッドを介してInvocationHandler#invoke()呼び出されるためです。これは、プロキシクラスのすべてのメソッドにシェルを配置するのと同じです。このメソッドが均一に処理される限り、すべてのプロキシメソッドを同じにすることができます。運営

次のコードは、動的プロキシの簡単な使用法を示しています。基本的な手順は次のとおりです。

パブリックインターフェイスを定義します。この場合IHello、インターフェイスに抽象メソッドがあります

エンティティクラスは、プロキシクラスとして共通のインターフェースを実装することを定義し、本実施形態は、プロキシクラスがインターフェースをHello実装IHelloすることであり、抽象メソッドオーバーライドインターフェースである。

InvocationHandlerメソッドインターセプトクラスインターフェイスを実装することを定義しinvoke()、処理ロジックインターセプトプロキシクラスを実装するためのメソッドの書き換えは、

Proxy.newProxyInstance()プロキシオブジェクトメソッドを生成することにより、プロキシオブジェクトが保持できる後のインターフェイスメソッドの実装

public class ServiceProxy {
    
    

    public interface IHello {
    
    
        String sayHi();
    }

    public static class Hello implements IHello {
    
    
        @Override
        public String sayHi() {
    
    
            return "Hello";
        }
    }

    // 动态代理类
    public static class ProxyHandler<T> implements InvocationHandler {
    
    
        private T origin;

        public ProxyHandler(T origin) {
    
    
            this.origin = origin;
        }

       /**
         * @param o 代理对象引用
         * @param method 正在执行目标的方法
         * @param objects 目标方法执行时的入参
        */
        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
    
    
            String s = "proxy";
            s += method.invoke(origin, objects);
            return s;
        }
    }

    public static void main(String[] args) {
    
    
        IHello IHello = (IHello) getInstance(IHello.class, new ProxyHandler<>(new Hello()));

        System.out.println(IHello.toString());

        generateProxyClass();
    }

    // 创建代理对象
    public static <T> Object getInstance(Class<T> clazz, ProxyHandler<T> handler) {
    
    
        return Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{
    
    clazz}, handler);
    }

    private static void generateProxyClass() {
    
    
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Hello.class.getInterfaces());
        String path = "/Users/nathan.yang/workspace/algorithm_Java/out/StuProxy.class";
        try (FileOutputStream fos = new FileOutputStream(path)) {
    
    
            fos.write(classFile);
            fos.flush();
            System.out.println("代理类文件写入成功");
        } catch (Exception e) {
    
    
            System.out.println("写文件错误");
        }
    }
}

3.ダイナミックエージェンシーの原則

ここに写真の説明を挿入

Proxy#newProxyInstance() この方法は、動的プロキシの入り口です。動的プロキシオブジェクトを生成する主な手順は次のとおりです。

getProxyClass0() プロキシクラスを生成するメソッド

プロキシクラスInvocationHandlerオブジェクトを参照リフレクティブに取得した後、コンストラクタを呼び出して動的プロキシオブジェクトを生成します

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);
     }
 }

Proxy#getProxyClass0()実際、WeakCacheロジックを取得するプロキシクラスを取得する方法から、そのようなものが呼び出されるプロキシキャッシュクラスがない場合ProxyClassFactory#apply()、プロキシクラスファクトリによってインスタントプロキシクラスを生成するには、次の手順を実行します。

まず、指定したクラスローダーでターゲットインターフェースをロードできるかどうかを確認します

インターフェイスが配置されているパッケージなどの条件に基づいて、プロキシクラスが配置されているパッケージとプロキシクラスの完全修飾名を決定します。プロキシクラス名は次のとおりです。包名+$Proxy+id

ProxyGenerator.generateProxyClass()バイトコード配列を生成し、動的に生成し、プロキシクラスをロードします

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

         Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
         for (Class<?> intf : interfaces) {
      
      
             /*
              * Verify that the class loader resolves the name of this
              * interface to the same Class object.
              */
             Class<?> interfaceClass = null;
             try {
      
      
                 interfaceClass = Class.forName(intf.getName(), false, loader);
             } catch (ClassNotFoundException e) {
      
      
             }
             if (interfaceClass != intf) {
      
      
                 throw new IllegalArgumentException(
                     intf + " is not visible from class loader");
             }
             /*
              * Verify that the Class object actually represents an
              * interface.
              */
             if (!interfaceClass.isInterface()) {
      
      
                 throw new IllegalArgumentException(
                     interfaceClass.getName() + " is not an interface");
             }
             /*
              * Verify that this interface is not a duplicate.
              */
             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;

         /*
          * Record the package of a non-public proxy interface so that the
          * proxy class will be defined in the same package.  Verify that
          * all non-public proxy interfaces are in the same package.
          */
         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 + ".";
         }

         /*
          * Choose a name for the proxy class to generate.
          */
         long num = nextUniqueNumber.getAndIncrement();
         String proxyName = proxyPkg + proxyClassNamePrefix + num;

         /*
          * Generate the specified proxy class.
          */
         byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
             proxyName, interfaces, accessFlags);
         try {
      
      
             return defineClass0(loader, proxyName,
                                 proxyClassFile, 0, proxyClassFile.length);
         } catch (ClassFormatError e) {
      
      
             /*
              * A ClassFormatError here means that (barring bugs in the
              * proxy class generation code) there was some other
              * invalid aspect of the arguments supplied to the proxy
              * class creation (such as virtual machine limitations
              * exceeded).
              */
             throw new IllegalArgumentException(e.toString());
         }
     }

リフレクションパラメータで取得したプロキシクラスInvocationHandler.classコンストラクタは、実際にはProxyパラメータ化されたコンストラクタであり、コンストラクタcons.newInstance(new Object[]{h})を呼び出してプロキシオブジェクトを生成します
```
protected Proxy(InvocationHandler h) {
      
      
     Objects.requireNonNull(h);
     this.h = h;
 }
```

次のコードは、JVMにロードされたプロキシクラスをクラスファイルに出力できます。次に、デコンパイラツールを使用して、プロキシクラスのソースコードを表示できます。

private static void generateProxyClass() {
      
      
     byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Hello.class.getInterfaces());
     String path = "/Users/nathan/workspace/algorithm_Java/out/StuProxy.class";
     try (FileOutputStream fos = new FileOutputStream(path)) {
      
      
         fos.write(classFile);
         fos.flush();
         System.out.println("代理类文件写入成功");
     } catch (Exception e) {
      
      
         System.out.println("写文件错误");
     }
 }

生成されたプロキシクラスのソースコードは次のとおりです。このクラスの動的プロキシ実装の原則を確認できることは明らかです。

することでstatic、コードブロックプロキシクラスMethodオブジェクトのメソッド、テーブル生成メソッドの各パッケージ

プロキシオブジェクト同じ名前のプロキシクラスメソッドを実行します。メソッドを呼び出すProxyためInvocationHandlerのオブジェクト参照を保持するようにポイントすることで親クラスInvocationHandler#invoke()、完全な動的プロキシ

public final class $Proxy0 extends Proxy implements IHello {
      
      
 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 String sayHi() throws  {
      
      
     try {
      
      
       // 父类 Proxy 保留的指向 InvocationHandler 对象的引用调用 invoke() 方法
         return (String)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);
     }
 }

......

// 方法表
 static {
      
      
     try {
      
      
         m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
         m3 = Class.forName("ServiceProxy$IHello").getMethod("sayHi");
         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());
     }
 }
}

Java動的プロキシの基本原則

記事ディレクトリ

1.エージェンシーモデル

2.動的プロキシの使用

3.ダイナミックエージェンシーの原則

おすすめ