Javaダイナミックエージェントの分析と理解

Javaダイナミックエージェントの分析と理解
エージェント設計モード
定義:このオブジェクトへのアクセスを制御するために、他のオブジェクトにプロキシを提供します.
動的エージェントの使用
JAvaダイナミックエージェントメカニズムは巧みな方法でエージェントモデルの設計理念を実現した.
プロキシモードサンプルコード

public interface Subject  
{  
 public void doSomething();  
}  
public class RealSubject implements Subject  
{  
 public void doSomething()  
 {  
  System.out.println( "call doSomething()" );  
 }  
}  
public class ProxyHandler implements InvocationHandler  
{  
 private Object proxied;  
   
 public ProxyHandler( Object proxied )  
 {  
  this.proxied = proxied;  
 }  
   
 public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable  
 {  
  //           ，          

  //           
  return method.invoke( proxied, args); 
  
  //           ，          
 }  
} 

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
import sun.misc.ProxyGenerator;  
import java.io.*;  
public class DynamicProxy  
{  
 public static void main( String args[] )  
 {  
  RealSubject real = new RealSubject();  
  Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(), 
   new Class[]{Subject.class}, 
   new ProxyHandler(real));
     
  proxySubject.doSomething();
  
  //write proxySubject class binary data to file  
  createProxyClassFile();  
 }  
   
 public static void createProxyClassFile()  
 {  
  String name = "ProxySubject";  
  byte[] data = ProxyGenerator.generateProxyClass( name, new Class[] { Subject.class } );  
  try 
  {  
   FileOutputStream out = new FileOutputStream( name + ".class" );  
   out.write( data );  
   out.close();  
  }  
  catch( Exception e )  
  {  
   e.printStackTrace();  
  }  
 }  
} 

動的エージェントの内部実装
まずクラスProxyのコード実装Proxyの主な静的変数を見てみましょう

//    ：                    
private static Map loaderToCache = new WeakHashMap(); 

//   ：                 
private static Object pendingGenerationMarker = new Object(); 

//    ：               ，      isProxyClass        
private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); 

//           
protected InvocationHandler h;

Proxyの構築方法

//    Proxy             ，   private            
private Proxy() {} 

//    Proxy             ，   protected            
protected Proxy(InvocationHandler h) {this.h = h;} 

Proxy静的方法newProxyInstance

public static Object newProxyInstance(ClassLoader loader, Class>[]interfaces,InvocationHandler h) throws IllegalArgumentException { 
  //    h    ，     
  if (h == null) { 
    throw new NullPointerException(); 
  } 

  //                         
  Class cl = getProxyClass(loader, interfaces); 

  //                     
  try { 
    Constructor cons = cl.getConstructor(constructorParams); 
    return (Object) cons.newInstance(new Object[] { h }); 
  } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); 
  } catch (IllegalAccessException e) { throw new InternalError(e.toString()); 
  } catch (InstantiationException e) { throw new InternalError(e.toString()); 
  } catch (InvocationTargetException e) { throw new InternalError(e.toString()); 
  } 
}

クラスProxyのgetProxyClassメソッドProxyGeneratorのgenerateProxyClassメソッドを呼び出し、ProxySubject.classのバイナリデータを生成します.

public static byte[] generateProxyClass(final String name, Class[] interfaces)

import sun.misc.ProxyGeneratorでgenerateProxyClassメソッドを呼び出してbinary dataを生成し、ファイルに書き込み、最後に逆コンパイルツールで内部実装原理を表示できます.逆コンパイル後のProxySubject.java Proxy静的メソッドnewProxyInstance

import java.lang.reflect.*;  
public final class ProxySubject extends Proxy  
  implements Subject  
{  
  private static Method m1;  
  private static Method m0;  
  private static Method m3;  
  private static Method m2;  
  public ProxySubject(InvocationHandler invocationhandler)  
  {  
    super(invocationhandler);  
  }  
  public final boolean equals(Object obj)  
  {  
    try 
    {  
      return ((Boolean)super.h.invoke(this, m1, new Object[] {  
        obj  
      })).booleanValue();  
    }  
    catch(Error _ex) { }  
    catch(Throwable throwable)  
    {  
      throw new UndeclaredThrowableException(throwable);  
    }  
  }  
  public final int hashCode()  
  {  
    try 
    {  
      return ((Integer)super.h.invoke(this, m0, null)).intValue();  
    }  
    catch(Error _ex) { }  
    catch(Throwable throwable)  
    {  
      throw new UndeclaredThrowableException(throwable);  
    }  
  }  
  public final void doSomething()  
  {  
    try 
    {  
      super.h.invoke(this, m3, null);  
      return;  
    }  
    catch(Error _ex) { }  
    catch(Throwable throwable)  
    {  
      throw new UndeclaredThrowableException(throwable);  
    }  
  }  
  public final String toString()  
  {  
    try 
    {  
      return (String)super.h.invoke(this, m2, null);  
    }  
    catch(Error _ex) { }  
    catch(Throwable throwable)  
    {  
      throw new UndeclaredThrowableException(throwable);  
    }  
  }  
  static  
  {  
    try 
    {  
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {  
        Class.forName("java.lang.Object")  
      });  
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
      m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);  
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
    }  
    catch(NoSuchMethodException nosuchmethodexception)  
    {  
      throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
    }  
    catch(ClassNotFoundException classnotfoundexception)  
    {  
      throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
    }  
  }  
} 

ProxyGenerator内部でclassバイナリデータを生成する方法については、ソースコードを参照してください.

private byte[] generateClassFile() {  
 /* 
  * Record that proxy methods are needed for the hashCode, equals, 
  * and toString methods of java.lang.Object. This is done before 
  * the methods from the proxy interfaces so that the methods from 
  * java.lang.Object take precedence over duplicate methods in the 
  * proxy interfaces. 
  */ 
 addProxyMethod(hashCodeMethod, Object.class);  
 addProxyMethod(equalsMethod, Object.class);  
 addProxyMethod(toStringMethod, Object.class);  
 /* 
  * Now record all of the methods from the proxy interfaces, giving 
  * earlier interfaces precedence over later ones with duplicate 
  * methods. 
  */ 
 for (int i = 0; i < interfaces.length; i++) {  
   Method[] methods = interfaces[i].getMethods();  
   for (int j = 0; j < methods.length; j++) {  
  addProxyMethod(methods[j], interfaces[i]);  
   }  
 }  
 /* 
  * For each set of proxy methods with the same signature, 
  * verify that the methods' return types are compatible. 
  */ 
 for (List sigmethods : proxyMethods.values()) {  
   checkReturnTypes(sigmethods);  
 }  
 /* ============================================================ 
  * Step 2: Assemble FieldInfo and MethodInfo structs for all of 
  * fields and methods in the class we are generating. 
  */ 
 try {  
   methods.add(generateConstructor());  
   for (List sigmethods : proxyMethods.values()) {  
  for (ProxyMethod pm : sigmethods) {  
    // add static field for method's Method object  
    fields.add(new FieldInfo(pm.methodFieldName,  
   "Ljava/lang/reflect/Method;",  
    ACC_PRIVATE | ACC_STATIC));  
    // generate code for proxy method and add it  
    methods.add(pm.generateMethod());  
  }  
   }  
   methods.add(generateStaticInitializer());  
 } catch (IOException e) {  
   throw new InternalError("unexpected I/O Exception");  
 }  
 /* ============================================================ 
  * Step 3: Write the final class file. 
  */ 
 /* 
  * Make sure that constant pool indexes are reserved for the 
  * following items before starting to write the final class file. 
  */ 
 cp.getClass(dotToSlash(className));  
 cp.getClass(superclassName);  
 for (int i = 0; i < interfaces.length; i++) {  
   cp.getClass(dotToSlash(interfaces[i].getName()));  
 }  
 /* 
  * Disallow new constant pool additions beyond this point, since 
  * we are about to write the final constant pool table. 
  */ 
 cp.setReadOnly();  
 ByteArrayOutputStream bout = new ByteArrayOutputStream();  
 DataOutputStream dout = new DataOutputStream(bout);  
 try {  
   /* 
    * Write all the items of the "ClassFile" structure. 
    * See JVMS section 4.1. 
    */ 
     // u4 magic;  
   dout.writeInt(0xCAFEBABE);  
     // u2 minor_version;  
   dout.writeShort(CLASSFILE_MINOR_VERSION);  
     // u2 major_version;  
   dout.writeShort(CLASSFILE_MAJOR_VERSION);  
   cp.write(dout);  // (write constant pool)  
     // u2 access_flags;  
   dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);  
     // u2 this_class;  
   dout.writeShort(cp.getClass(dotToSlash(className)));  
     // u2 super_class;  
   dout.writeShort(cp.getClass(superclassName));  
     // u2 interfaces_count;  
   dout.writeShort(interfaces.length);  
     // u2 interfaces[interfaces_count];  
   for (int i = 0; i < interfaces.length; i++) {  
  dout.writeShort(cp.getClass(  
    dotToSlash(interfaces[i].getName())));  
   }  
     // u2 fields_count;  
   dout.writeShort(fields.size());  
     // field_info fields[fields_count];  
   for (FieldInfo f : fields) {  
  f.write(dout);  
   }  
     // u2 methods_count;  
   dout.writeShort(methods.size());  
     // method_info methods[methods_count];  
   for (MethodInfo m : methods) {  
  m.write(dout);  
   }  
       // u2 attributes_count;  
   dout.writeShort(0); // (no ClassFile attributes for proxy classes)  
 } catch (IOException e) {  
   throw new InternalError("unexpected I/O Exception");  
 }  
 return bout.toByteArray(); 

まとめ
典型的なダイナミックエージェントによるオブジェクトの作成プロセスは、次の4つのステップに分けられます.
1、InvocationHandlerインタフェースを実現することによって自分の呼び出しプロセッサIvocationHandler handler=new InvocationHandler Impl(…)を作成する.2、ProxyクラスにClassLoaderオブジェクトとインターフェースのセットを指定して動的プロキシクラスClass clazz=Proxy.getProxyClass(classLoader,new Class[]{...})を作成する.3、動的エージェントクラスの構造関数を反射機構により取得し、そのパラメータタイプはプロセッサインタフェースタイプConstructor constructor=clazz.getConstructor(new Class[]{InvocationHandler.class})を呼び出す.4、コンストラクション関数によってプロキシクラスインスタンスを作成する場合、呼び出しプロセッサオブジェクトをパラメータとしてInterface Proxy=(Interface)constructor.newInstance(new Object[](handler))に転送する必要がある.オブジェクト作成プロセスを簡略化するために、ProxyクラスのnewInstanceメソッドは2~4カプセル化され、プロキシオブジェクトの作成を2ステップで完了します.生成されたProxySubjectはProxyクラス実装Subjectインタフェースを継承し,実装されたSubjectのメソッドはプロセッサのinvokeメソッドを実際に呼び出し,invokeメソッドは反射呼び出しを利用して被エージェントオブジェクトのメソッド(Object result=method.invoke(proxied,args))を呼び出す.
米中不足
確かに、Proxyは非常に優美に設計されていますが、interfaceエージェントだけをサポートする束縛から抜け出すことができません.それは、その設計がこの残念さを運命付けているからです.動的に生成されたエージェントクラスの継承関係図を思い出すと、Proxyという共通の親がいることになります.Javaの継承メカニズムは、これらの動的エージェントクラスがclassに対する動的エージェントを実現できないことを運命付けている.なぜなら、Javaでは本質的に多くの継承が通用しないからだ.多くの理由で、classエージェントの必要性を否定することができますが、classダイナミックエージェントをサポートすることがより良いと信じている理由もあります.インタフェースとクラスの区分は、もともと明らかではありませんが、Javaではこのように細分化されています.メソッドの宣言と定義のみから考慮すると,抽象クラスという名前の2つの混合体がある.抽象クラスに対する動的エージェントを実現するには,その内在的な価値もあると信じている.また、インタフェースが実装されていないため、動的エージェントとは永遠に縁がない歴史的なクラスもあります.このようなことは、小さな残念と言わざるを得ない.しかし、完璧ではないのは偉大ではなく、偉大さは本質であり、Javaダイナミックエージェントは佐例である.
読書に感謝して、みんなを助けることができることを望んで、みんなの当駅に対する支持に感謝します!