java實現RPC

一，服務提供者

工程為battercake-provider，項目結構圖如下圖所示

1.1 先創建一個“賣煎餅”微服務的接口和實現類

package com.jp.service;

public interface BatterCakeService {
    /**
     * 賣煎餅的服務
     */
    public String sellBatterCake(String name);
}

package com.jp.service;

import com.jp.service.BatterCakeService;

/**
 * 賣煎餅服務的實現類
 *
 */
public class BatterCakeServiceImpl implements BatterCakeService {

    public String sellBatterCake(String name) {
        return name+"煎餅,賣的特別好";
    }    
}

1.2 RPC框架調用部分

該部分有兩個關鍵部分：RPC服務提供器和線程處理類

1）RPC服務提供器

1. 將需要發布的服務存儲在一個內存變量serviceList中。（該例就是把賣煎餅服務的實例對象傳入）
2. 啟動socket，server.accept()方法阻塞在那，監聽輸入
3. 針對每一個請求，單獨啟動一個線程處理

package com.jp.rpc;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 * RPC服務提供器
 * 1,將需要發布的服務存儲在一個內存變量serviceList中
 * 2,啟動socket，server.accept()方法阻塞在那，監聽輸入
 * 3,針對每一個請求，單獨啟動一個線程處理
 */
public class RpcProvider {
    
    //存儲注冊的服務列表
    private static List<Object> serviceList;
    
    /**
     * 發布rpc服務
     * @param object 提供（賣煎餅）服務的實例對象 22      * @param port 監聽的端口 23      * @throws Exception
     */
    public static void export(int port,Object... services) throws Exception {
        serviceList=Arrays.asList(services);
        ServerSocket server = new ServerSocket(port);
        Socket client = null;
        while (true) {
            //阻塞等待輸入，每來一個請求就會產生一個socket對象
            client = server.accept();
            //每一個請求，啟動一個線程處理
            new Thread(new ServerThread(client,serviceList)).start();
        }
    }
}

2）線程處理類

ServerThread（socke對象，服務實例列表）線程處理類的代碼，ServerThread主要做以下幾個步驟

1. 讀取客戶端發送的服務名
2. 判斷服務是否發布
3. 如果發布，則走反射邏輯，動態調用，返回結果
4. 如果未發布，則返回提示通知

package com.jp.rpc;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.Socket;
import java.util.List;

public class ServerThread implements Runnable {

    private Socket client = null;

    private List<Object> serviceList = null;

    public ServerThread(Socket client, List<Object> service) {
        this.client = client;
        this.serviceList = service;
    }

    //@Override
    public void run() {
        ObjectInputStream input = null;
        ObjectOutputStream output = null;
        try {
            input = new ObjectInputStream(client.getInputStream());
            output = new ObjectOutputStream(client.getOutputStream());
            // 讀取客戶端要訪問那個service
            Class serviceClass = (Class) input.readObject();
            // 找到該服務類實例
            Object obj = findService(serviceClass);
            if (obj == null) {
                output.writeObject(serviceClass.getName() + "服務未發現");
            } else {
                //利用反射調用該方法，返回結果
                //從請求中得到請求的方法名和方法參數；加上上面得到了服務對象實例；反射得到具體的方法實例；invoke執行
                try {
                    String methodName = input.readUTF();
                    Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                    Object[] arguments = (Object[]) input.readObject();
                    
                    Method method = obj.getClass().getMethod(methodName, parameterTypes);  
                    Object result = method.invoke(obj, arguments);  
                    output.writeObject(result); 
                } catch (Throwable t) {
                    output.writeObject(t);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                client.close();
                input.close();
                output.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

    //到服務列表中找服務實例
    private Object findService(Class serviceClass) {
        for (Object obj : serviceList) {
            boolean isFather = serviceClass.isAssignableFrom(obj.getClass());
            if (isFather) {
                return obj;
            }
        }
        return null;
    }

}

1.3 發布服務

package com.jp.start;

import com.jp.rpc.RpcProvider;
import com.jp.service.BatterCakeService;
import com.jp.service.BatterCakeServiceImpl;

public class RpcBootStrap {
    public static void main(String[] args) throws Exception {
        //實例化“賣煎餅”這個服務的實現類
        BatterCakeService batterCakeService =new BatterCakeServiceImpl();
        //發布賣煎餅的服務：注冊在20006端口，並把提供服務的實例傳入
        RpcProvider.export(20006,batterCakeService);
    }
}

二，服務消費者

消費者工程為battercake-consumer，項目結構圖如下圖所示

2.1 rpc調用部分

分為兩部分：代理類處理器（代理類工廠）和 service的代理類對象（即前面工廠生產返回的）

1）代理類處理器（代理類工廠）

負責生產代理類（傳入服務的名字（類？）；ip；端口）

package com.jp.rpc;

import java.lang.reflect.Proxy;

/**
 * 用於生產服務代理類
 */
public class RpcConsumer {
    public static <T> T getService(Class<T> clazz,String ip,int port) {
        ProxyHandler proxyHandler =new ProxyHandler(ip,port);
        return (T)Proxy.newProxyInstance(RpcConsumer.class.getClassLoader(), new Class<?>[] {clazz}, proxyHandler);
    }
}

2）服務代理類的處理器（該類就是代理類功能的具體實現者，其實就是封裝了調用遠程服務的過程（封裝請求數據發給遠端服務提供者，把提供者返回的結果返回））

1. 建立socket連接
2. 封裝請求數據，發送給服務提供者
3. 返回結果

package com.jp.rpc;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.net.Socket;

public class ProxyHandler implements InvocationHandler {
    
    private String ip;
    private int port;

    public ProxyHandler(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    //@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Socket socket = new Socket(this.ip, this.port);
        ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
        ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
        try {
            output.writeObject(proxy.getClass().getInterfaces()[0]);
            output.writeUTF(method.getName());
            output.writeObject(method.getParameterTypes());
            output.writeObject(args);
            output.flush();
            Object result = input.readObject();
            if (result instanceof Throwable) {
                throw (Throwable) result;
            }
            return result;
        } finally {
            socket.shutdownOutput();
        }
    }

}

2.2 接下來建立一個測試類RpcTest如下

（跑該測試類前，記得運行在battercake-provider端的RpcBootstrap類發布BatterCakeService服務）

package com.jp.start;

import com.jp.rpc.RpcConsumer;
import com.jp.service.BatterCakeService;

public class RpcTest {
    public static void main(String[] args) {
        //生成代理類，三個參數：被代理對象，ip，端口
        BatterCakeService batterCakeService = RpcConsumer.getService(BatterCakeService.class, "127.0.0.1", 20006);
        //調用代理類的方法並獲得結果
        String result = batterCakeService.sellBatterCake("雙蛋");
        System.out.println(result);
    }
}

輸出結果如下

 

 

https://blog.csdn.net/wangyunpeng0319/article/details/78651998

https://www.cnblogs.com/rjzheng/category/1205773.html