How to use Remote Procedure Call (RPC)

Anyone who has done Socket programming in HTTP request style knows that when we design a communication protocol, the "message header/message body" separation method is very commonly used. The message header tells the other party what the message is for, and the message body Tell the other person what to do.

Comparison of RPC based on HTTP protocol and RPC based on TCP protocol:

RPC between systems based on HTTP protocol is flexible and easy to implement (a variety of open source web server support), open (international standards) and inherently supports calls between heterogeneous platforms, it has been widely used. Corresponding to this is the implementation version of the TCP protocol, which is more efficient, but is more complex to implement, and due to different protocols and standards, it is difficult to facilitate cross-platform and inter-enterprise communication.

HTTP protocol implementation has its disadvantages. Since it is an upper-layer protocol, sending information containing the same content, the number of bytes occupied by HTTP protocol transmission is definitely higher than the number of bytes occupied by TCP protocol transmission. More. Therefore, under the same network environment, the efficiency of transmitting the same content through the HTTP protocol will be lower than the data transmission through the TCP protocol, and the information transmission will take longer. Of course, this gap can be reduced by optimizing the code implementation and using gzip data compression. By weighing the pros and cons and considering the impact of its performance on user experience in the actual environment, RPC based on the HTTP protocol still has great advantages.

1. Implement RPC based on TCP protocol

Service interface:

public interface SayHelloService{
     public String sayHello(String helloArg);
}

Service implementation:

public class SayHelloServiceImpl implements SayHelloService {

    @Override
    public String sayHello(String helloArg) {
        if(helloArg.equals("Hello")) {
            return "hello";
        }else{
            return "bye bye";
        }
    }
}

Service consumer Consumer key code:

// 接口名称
String interfacename = SayHelloService.class.getName();
// 需要远程执行的方法
Method method = SayHelloService.class.getMethod("sayHello", java.lang.String.class);
// 需要传递到远端的参数
Object[] arguments = {"hello"};
Socket socket = new Socket("127.0.0.1", 1234);
// 将方法名称和参数传递到远端
ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
output.writeUTF(interfacename); // 接口名称
output.writeUTF(method.getName()); // 方法名称
output.writeObject(method.getParameterTypes());
output.writeObject(arguments);

// 从远端读取方法的执行结果
ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
Object result = input.readObject();

Service provider Privider key code:

ServiceSocket server = new ServerSocket(1234);
while(true){
    Socket socket = server.accept();

    //读取服务信息
    ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
    String interfacename = input.readUTF();    //接口名称
    String methodName = input.readUTF();    // 方法名称
    Class<?>[] parameterTypes = (Class<?>[])input.readObject(); //参数类型
    Object[] arguments = (Object[]) input.readObject(); //参数对象

    // 执行调用
    Class serviceinterfaceclass = Class.forName(interfacename);
    Object service = service.get(interfacename);
    Method method = serviceinterfaceclass.getMethod(methodName, parameterTypes);
    Object result = method.invoke(service, arguments);

    ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
    output.writeObject(result);
}

2. RPC based on HTTP protocol

Protocol request definition:

public class Request{

    /**
    * 协议编码
    */
    private byte encode;

    /**
    * 命令
    */
    private String command;

    /**
    * 命令长度
    */
    private int commandLength;
}

Protocol response definition:

public class Response {

    /**
    * 编码
    */
    private byte encode;

    /**
    * 响应长度
    */
    private int responseLength;

    /**
    * 响应
    */
    private String response;
}

Key code for client implementation:

// 请求
Request request = new Request();
request.setCommand("HELLO");
request.setCommandLength(request.getCommand().length());
request.setEncode(Encode.UTF8.getValue());

Socket client = new Socket("127.0.0.1", 4567);
OutputStream output = client.getOutputStream();

// 发送请求
ProtocolUtil.writeRequest(output, request);
InputStream input = client.getInputStream();
Response = response = ProtocolUtil.readResponse(input);

Key code for server implementation:

ServerSocket server = new ServerSocket(4567);
while(true){
    Socket client  = server.accept();

    //读取响应数据
    InputStream input = client.getInputStream();
    Request request = ProtocolUtil.readRequest(input);
    OutputStream output = client.getOutputStream();

    // 组装响应
    Response response = new Response();
    response.setEncode(Encode.UTF8.getValue());
    if(request.getCommand().equals("HELLO")){
       response.setResponse("hello!");
    }else {
        response.setResponse("bye bye");
    }

    resposne.setResponseLength(response.getResponse().length());
    ProtocolUtil.writeResponse(output, response);
}

ProtocolUtil code

public class ProtocolUtil {

    public static Request readRequest(InputStream input) throws IOException {
        //读取编码
        byte[] encodeByte = new byte[1];
        input.read(encodeByte);
        byte encode = encodeByte[0];

        //读取命令长度
        byte[] commandLengthBytes = new byte[4];
        input.read(commandLengthBytes);
        int commandLength = ByteUtil.bytes2Int(commandLengthBytes);

        //读取命令
        byte[] commandBytes = new byte[commandLength];
        input.read(commandBytes);
        String command = "";
        if(Encode.GBK.getValue() == encode){
            command = new String(commandBytes, "GBK");
        }else{
            command = new String(commandBytes, "UTF8");
        }

        // 组装请求返回
        Request request = new Request();
        request.setCommand(command);
        request.setEncode(encode);
        request.setCommandLength(commandLength);

        return request;
    }

    public static void writeResponse(OutputStream output, Response response) throws IOExceptiono{
        //将response响应返回给客户端
        output.write(response.getEncode());
       // output.write(response.getResponseLength());
        //直接write一个int类型会截取低8位传输，丢失高8位
        output.write(ByteUtil.int2ByteArray(response.getResponseLength()));
        if(Encode.GBK.getValue() == resposne.getEncode()){
            output.write(response.getResponse().getBytes("GBK"));
        }else{
            output.write(response.getResponse().getBytes("UTF8"));
        }

        output.flush();
    }
}

public static int bytes2Int(byte[] bytes){
    int num = bytes[3] & 0xFF;
    num |= ((bytes[2] << 8) & 0xFF00;
    num |= ((bytes[1] << 16) & 0xFF0000;
    num |= ((bytes[0] << 24) & oxFF000000;

    return num;
}

Related recommendations:

HTTP preliminary notes - Yitoem

http://windows.php.net/ and http://php.net/ both provide PHP download, what is the difference?

The above is the detailed content of How to use Remote Procedure Call (RPC). For more information, please follow other related articles on the PHP Chinese website!