Java でインターフェースを動的に作成する方法

この記事では、主に Java でインターフェイス実装メソッドを動的に作成する方法に関する関連情報を紹介します。必要な方は参考にしてください。

インターフェイスの動的実装を使用するアプリケーション シナリオがいくつかあります。 1 、mybatis/jpa およびその他の ORM フレームワークでは、開発のためにインターフェイスにアノテーションを追加できます。実装クラスを記述する必要はなく、実装は実行時に動的に生成されます。

2. dubbo などの分散サービス フレームワークでは、コンシューマーは、ソース コードを分析した後、インターフェイスのプロキシ実装をコンシューマー側で生成するだけで、リモート実装を呼び出すことができます。プロキシはリモート インターフェイスを呼び出します。

3. spring aop これは最も典型的な動的プロキシです。

インターフェースの動的実装を作成するには、JDK 動的プロキシと CGLIB 動的プロキシという 2 つの最も一般的に使用される方法があります。

プロキシ パターンは、一般的に使用されるデザイン パターンであり、その目的は、実際のオブジェクトへのアクセスを制御するために他のオブジェクトにプロキシを提供することです。

プロキシ クラスは、デリゲート クラスのメッセージの前処理、メッセージのフィルタリングと転送、およびメッセージがデリゲート クラスによって実行された後の後続の処理の実行を担当します。

プロキシ層の中間層を通じて、実際のデリゲート クラス オブジェクトへの直接アクセスを効果的に制御でき、カスタマイズされた制御戦略 (Spring の AOP メカニズム) を実装して設計の柔軟性を高めることができます。

以下は JDK 動的プロキシを使用し、このプロセスを示すための簡単なコードを追加します。

1. インターフェイス

package com.yhouse.modules.daos;

public interface IUserDao {
  public String getUserName();
}

2. 実行時にインターフェイス メソッドを呼び出すときの実装 (このプロセスは、インターフェースのメソッド実装とも呼ばれます)

package com.yhouse.modules.daos;

import java.lang.reflect.Proxy;
/**
 * 创建代理
 * @author clonen.cheng
 *
 */
public class Invoker {
  
  
  public Object getInstance(Class<?> cls){    
    MethodProxy invocationHandler = new MethodProxy();    
    Object newProxyInstance = Proxy.newProxyInstance( 
        cls.getClassLoader(), 
        new Class[] { cls }, 
        invocationHandler); 
    return (Object)newProxyInstance;
  }
}

4. テスト

package com.yhouse.modules.daos;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MethodProxy implements InvocationHandler {

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
    //如果传进来是一个已实现的具体类（本次演示略过此逻辑)
    if (Object.class.equals(method.getDeclaringClass())) { 
      try { 
        return method.invoke(this, args); 
      } catch (Throwable t) { 
        t.printStackTrace(); 
      } 
    //如果传进来的是一个接口（核心)
    } else { 
      return run(method, args); 
    } 
    return null;
  }
  
  /**
   * 实现接口的核心方法 
   * @param method
   * @param args
   * @return
   */
  public Object run(Method method,Object[] args){ 
    //TODO     
    //如远程http调用
    //如远程方法调用（rmi)
    //....
    return "method call success!";
  } 

}

このテストコードでは、結果はどうなるか予想します。

コンソールの印刷:

これは、インターフェイスが呼び出されたときに、実装がエージェントに委任されることを意味します。最後に行うべきことは、エージェントでの処理です:

上記のコードでは、インターフェイスのメソッドと引数を取得したら、メソッド名やメソッドのアノテーションに基づいてより豊富な関数を実装するなど、さまざまなことができることがわかります。

理解を深めていただくために、簡単な例でリモート インターフェイスの動的な呼び出しを説明します。

1. プロキシクラスとターゲットクラスを作成するには、共通インターフェイスServiceを実装する必要があります

package com.yhouse.modules.daos;

public class ProxyTest {

  
  public static void main(String[] args) {
    IUserDao invoker=(IUserDao)new Invoker().getInstance(IUserDao.class);
    System.out.println(invoker.getUserName());
  }

}

2. サーバー側でRemoteServiceクラスを作成し、Serviceインターフェイスを実装します。

package com.markliu.remote.service;
/**
 * Service接口。代理类和被代理类抖需要实现该接口
 */
public interface Service {
  public String getService(String name, int number);
}

3. クライアントのリクエストをカプセル化して結果情報を返す Call クラスを作成します

オブジェクト指向の方法でクライアントとサーバー間の通信を容易にするために、クライアントが送信する情報は次のように表現できます。クラスを呼び出します。 Call オブジェクトは、クライアントによって開始されたリモート呼び出しを表します。これには、呼び出しクラス名またはインターフェイス名、メソッド名、メソッド パラメーターの型、メソッド パラメーターの値、およびメソッドの実行結果が含まれます。

package com.markliu.remote.serviceimpl;
import com.markliu.remote.service.Service;
/**
 * 服务器端目标业务类，被代理对象
 */
public class RemoteService implements Service {
  @Override
  public String getService(String name, int number) {
    return name + ":" + number;
  }
}

4. 動的プロキシモードで実際の業務処理クラスを作成し、InvocationHandlerインターフェースを実装します

package com.markliu.local.bean;
import java.io.Serializable;
/**
 * 请求的javabean
 */
public class Call implements Serializable{
  private static final long serialVersionUID = 5386052199960133937L;
  private String className; // 调用的类名或接口名
  private String methodName; // 调用的方法名
  private Class<?>[] paramTypes; // 方法参数类型
  private Object[] params; // 调用方法时传入的参数值
  /**
   * 表示方法的执行结果 如果方法正常执行,则 result 为方法返回值,
   * 如果方法抛出异常,那么 result 为该异常。
   */
  private Object result;
  public Call() {}
  public Call(String className, String methodName, Class<?>[] paramTypes, Object[] params) {
    this.className = className;
    this.methodName = methodName;
    this.paramTypes = paramTypes;
    this.params = params;
  }
  // 省略了get和set方法
}

5. プロキシクラスを取得するためのファクトリRemoteServiceProxyFactoryを作成します

package com.markliu.local.service;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import com.markliu.local.bean.Call;

public class ServiceInvocationHandler implements InvocationHandler {

  private Class<?> classType;
  private String host;
  private Integer port;

  public Class<?> getClassType() {
    return classType;
  }
  public ServiceInvocationHandler(Class<?> classType, String host, Integer port) {
    this.classType = classType;
    this.host = host;
    this.port = port;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    // 封装请求信息
    Call call = new Call(classType.getName(), method.getName(), method.getParameterTypes(), args);
    // 创建链接
    Connector connector = new Connector();
    connector.connect(host, port);
    // 发送请求
    connector.sendCall(call);
    // 获取封装远程方法调用结果的对象
    connector.close();
    Object returnResult = call.getResult();
    return returnResult;
  }
}

6.基礎となるソケット通信 Connector クラスは、Call オブジェクトの作成、送受信を担当します

package com.markliu.local.service;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * 动态创建RemoteService代理类的工厂
 */
public class RemoteServiceProxyFactory {

  public static Object getRemoteServiceProxy(InvocationHandler h) {
    Class<?> classType = ((ServiceInvocationHandler) h).getClassType();
    // 获取动态代理类
    Object proxy = Proxy.newProxyInstance(classType.getClassLoader(), 
        new Class[]{classType}, h);
    return proxy;
  }
}

7. リモートサーバーを作成します

package com.markliu.local.service;
// 省略import

/**
 * 负责创建链接
 */
public class Connector {
  private Socket linksocket;
  private InputStream in;
  private ObjectInputStream objIn;
  private OutputStream out;
  private ObjectOutputStream objOut;

  public Connector(){}
  /**
   * 创建链接
   */
  public void connect(String host, Integer port) throws UnknownHostException, IOException {
    linksocket = new Socket(host, port);
    in = linksocket.getInputStream();
    out = linksocket.getOutputStream();
    objOut = new ObjectOutputStream(out);
    objIn = new ObjectInputStream(in);
  }
  /**
   * 发送请求call对象
   */
  public void sendCall(Call call) throws IOException {
    objOut.writeObject(call);
  }
  /**
   * 获取请求对象
   */
  public Call receive() throws ClassNotFoundException, IOException {
    return (Call) objIn.readObject();
  }
  /**
   * 简单处理关闭链接
   */
  public void close() {
    try {
      linksocket.close();
      objIn.close();
      objOut.close();
      in.close();
      out.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

8. ローカルクライアントを作成します

package com.markliu.remote.main;
// 省略import

public class RemoteServer {

  private Service remoteService;
  public RemoteServer() {
    remoteService = new RemoteService();
  }
  public static void main(String[] args) throws Exception {
    RemoteServer server = new RemoteServer();
    System.out.println("远程服务器启动......DONE!");
    server.service();
  }

  public void service() throws Exception {
    @SuppressWarnings("resource")
    ServerSocket serverSocket = new ServerSocket(8001);
    while (true) {
        Socket socket = serverSocket.accept();
        InputStream in = socket.getInputStream();
        ObjectInputStream objIn = new ObjectInputStream(in);
        OutputStream out = socket.getOutputStream();
        ObjectOutputStream objOut = new ObjectOutputStream(out);
        // 对象输入流读取请求的call对象
        Call call = (Call) objIn.readObject();
        System.out.println("客户端发送的请求对象：" + call);
        call = getCallResult(call);
        // 发送处理的结果回客户端
        objOut.writeObject(call);
        objIn.close();
        in.close();
        objOut.close();
        out.close();
        socket.close();
    }
  }

  /**
   * 通过反射机制调用call中指定的类的方法，并将返回结果设置到原call对象中
   */
  private Call getCallResult(Call call) throws Exception {
    String className = call.getClassName();
    String methodName = call.getMethodName();
    Object[] params = call.getParams();
    Class<?>[] paramsTypes = call.getParamTypes();

    Class<?> classType = Class.forName(className);
    // 获取所要调用的方法
    Method method = classType.getMethod(methodName, paramsTypes);
    Object result = method.invoke(remoteService, params);
    call.setResult(result);
    return call;
  }
}

結果:

このプロセスは次のように簡単に要約できます: ローカル インターフェースの呼び出し (クライアント) ---> ローカル インターフェースのプロキシ実装 (クライアント) ----> リモートの実装 (サーバー)

以上がJava でインターフェースを動的に作成する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。