1 涉及主要知識點

  1、RMI(Remote Method Invocation)：遠端方法呼叫是一種計算機之間利用遠端物件互相呼叫實現雙方通訊的一種通訊機制。使用這種機制，某一臺計算機上的物件可以呼叫另外 一臺計算機上的物件來獲取遠端資料。RMI是Enterprise JavaBeans的支柱，是建立分散式Java應用程式的方便途徑。RMI的基本框架如下圖所示：

      
本案例中的遠端代理的基本模型如下：

2 專案詳解

  專案需求：客戶端LocalClient請求呼叫遠端伺服器端RemoteServer的業務類RemoteService的方法getService，並將方法結果返回。其中將客戶端請求方法的資訊封裝成Call物件，再將方法的返回結果設定進call物件中，即B/S之間傳遞call物件，因此Call物件需要實現Serializable介面。底層Socket通訊由Connector負責。由於涉及到遠端代理，這裡採用JDK動態代理模式。採用工廠模式，根據給定的伺服器的host和port，以及類名，由工廠RemoteServiceProxyFactory獲取代理類。代理模式中，代理類和目標類需要實現共同的介面Service，客戶端針對Service介面程式設計。
  以上過程基本描述了所涉及到了類名，系統類結構圖如下：

package com.markliu.remote.service;
/**
 * Service介面。代理類和被代理類抖需要實現該介面
 */
public interface Service {
    public String getService(String name, int number);
}

  （2）伺服器端建立RemoteService類，實現了Service 介面。

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

  （3）建立封裝客戶端請求和返回結果資訊的Call類。
  為了便於按照面向物件的方式來處理客戶端與伺服器端的通訊,可以把它們傳送的資訊用 Call 類來表示。一個 Call 物件表示客戶端發起的一個遠端呼叫,它包括呼叫的類名或介面名、方法名、方法引數型別、方法引數值和方法執行結果。

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方法
}

  （4）建立動態代理模式中實際的業務處理類，實現了InvocationHandler 介面。

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

  （5）建立獲取代理類的工廠RemoteServiceProxyFactory。

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

  （6）建立底層Socket通訊的Connector類，負責建立攔截、傳送和接受Call物件。

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

  （7）建立遠端伺服器。

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

  （8）建立本地客戶端。

package com.markliu.local.main;
import java.lang.reflect.InvocationHandler;
import com.markliu.local.service.RemoteServiceProxyFactory;
import com.markliu.local.service.ServiceInvocationHandler;
import com.markliu.remote.service.Service;

public class LocalClient {
    public static void main(String[] args) {
        String host = "127.0.0.1";
        Integer port = 8001;
        Class<?> classType = com.markliu.remote.service.Service.class;
        InvocationHandler h = new ServiceInvocationHandler(classType, host, port);
        Service serviceProxy = (Service) RemoteServiceProxyFactory.getRemoteServiceProxy(h);
        String result = serviceProxy.getService("SunnyMarkLiu", 22);
        System.out.println("呼叫遠端方法getService的結果：" + result);
    }
}

  LocalClient 呼叫 RemoteServer 端的RemoteService物件的 getService(name,age)方法的執行結果如下：
        

3 發現的問題

  Socket同時使用ObjectInputStream和ObjectOutputStream傳輸序列化物件時的順序問題：
  在網路通訊中，主機與客戶端若使用ObjectInputStream與ObjectOutputStream建立物件通訊，必須注重宣告此兩個物件的順序。
  伺服器端先建立ObjectInputStream後建立ObjectOutputStream，則對應地客戶端要先建立ObjectOutputStream後建立ObjectInputStream，否則會造成兩方互相等待資料而導致死鎖。
  原因是建立ObjectInputStream物件時需要先接收一定的header資料，接收到這些資料之前會處於阻塞狀態。

  public ObjectInputStream(InputStream in) throws IOException的官方API顯示：
Creates an ObjectInputStream that reads from the specified InputStream. A serialization stream header is read from the stream and verified. This constructor will block until the corresponding ObjectOutputStream has written and flushed the header.
  在建立ObjectInputStream物件時會檢查ObjectOutputStream所傳過來了頭資訊，如果沒有資訊將一直會阻塞。
  正確的做法：
  Server:

    ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());  
    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());  

  Client:

    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());  
    ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());  

4 極客祕籍

  現在我們有一個有趣的問題，就是客戶端在建立動態代理類時候，需要有伺服器端的Service介面和RemoteService類，否則客戶端在呼叫Proxy.newProxyInstance方法是會報找不到類型別和介面等錯誤。本案例中簡單的採用將這些類複製一份到客戶端。
  還有一種不錯的方式-動態類下載。以上這些類可以“貼上”URL，告訴客戶端RMI系統去尋找需要的類檔案。建立動態代理類的時候，如果本地沒有發現這些類，則從根據URL下載類檔案。所以需要一個簡單的Web伺服器來提供這些類檔案，也需要提供客戶端的安全引數等。