一个最简单的RPC调用Demo01

下一篇博客地址：https://blog.csdn.net/qq_41115379/article/details/118710080

RPC的定义

一个RPC最最简单的过程就是客户端调用服务端的一个方法，服务端返回执行方法的返回值给客户端

前置知识

下面就是一个简单的从数据库中取数据的例子

对注解的解释：

@Builder

@Data//提供了读写属性，还提供了 equals() hashCode() toString()这些方法
@Builder//这个注解是为类生成相对略微复制的构建器API 就是所谓的提供一个内部的Builder
@NoArgsConstructor//这个是生成一个无参的构造函数
@AllArgsConstructor//这个是生成一个 全部参数的构造函数

ObjectOutputStreamflush()函数：

  public void flush() throws IOException {
        bout.flush();
    }
//调用flush方法 作用是刷新流，将写入所有缓冲的输出字节并刷新到基础流

Socket

http://c.biancheng.net/view/1199.html javaServerSocket和Socket类

定义：他是一个套接字，ip地址+端口号。

所以这边创建方法就是 直接new了一个Socket

ServerSocket：

负责接受客户连接请求，并生成与客户端连接的Socket.相当于就是服务端的Socket.他是和Socket类相对应的用于表示通信双方中的服务器端，用于在服务器上开一个端口，被动地等待数据（使用accept()方法）并建立连接进行数据交互

ObjectOutputStream/ObjectInputStream

首先要知道他们是以”对象“为数据源，但必须将传输的对象进行序列化和反序列化（序列化以后的对象可以保存到磁盘中，也可以在网络上传输，使不同的计算机可以共享对象）

ObjectOutputStream objectOutputStream=new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream objectInputStream=new ObjectInputStream(socket.getInputStream());
//首先是Socket的这两个方法
getInputStream()方法就是一个输入流，而这个输入流具体就是Socket 从服务器中发回的数据
getOutputStream()方法就是得到一个输出流，就是发送给服务器端的数据

首先是创建一个User对象

package RPCVersion01;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 这个对象是客户端和服务端都已知的，客户端需要得到这个pojo对象数据。服务端需要操作这个对象
 */
@Data//提供了读写属性，还提供了 equals() hashCode() toString()这些方法
@Builder//这个注解是为类生成相对略微复制的构建器API 就是所谓的提供一个内部的Builder
@NoArgsConstructor//这个是生成一个无参的构造函数
@AllArgsConstructor//这个是生成一个 全部参数的构造函数
public class User implements Serializable {
    private Integer id;
    private String userName;
    private Boolean sex;

}

对应服务接口

package RPCVersion01;

/**
 * 定义客户端需要调用，服务端需要提供对应的服务接口
 */
public interface UserService {
    //客户端提供这个接口调用服务端的实现类
    User getUserByUserId(Integer id);
}

实现接口功能

package RPCVersion01;

import java.util.Random;
import java.util.UUID;

/**
 * 服务端实现service接口
 */
public class UserServiceImpl implements UserService {
    @Override
    public User getUserByUserId(Integer id) {
        System.out.println("客户端查询了"+id+"的用户");
        //模拟从数据库中取用户的行为
        Random random=new Random();
        //这里就调用了那个builder方法
        User user=User.builder().userName(UUID.randomUUID().toString()).id(id).sex(random.nextBoolean()).build();
        return user;
    }
}

建立Socket连接

package RPCVersion01;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Random;

/**
 * 客户端建立Socket连接，传输id给服务端，得到返回的User对象
 */
public class RPCClient {
    public static void main(String[] args) {
        try{
            //建立Socket连接 这里Socket就会抛出异常
            Socket socket=new Socket("127.0.0.1",8899);
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(socket.getOutputStream());
            ObjectInputStream objectInputStream=new ObjectInputStream(socket.getInputStream());
            //传给服务器id
            objectOutputStream.writeInt(new Random().nextInt());
            //调用flush方法 作用是刷新流，将写入所有缓冲的输出字节并刷新到基础流
            objectOutputStream.flush();
            //服务器查询数据，返回对应的对象
            User user= (User) objectInputStream.readObject();
            System.out.println("服务端返回的User"+user);
        } catch (UnknownHostException e) {
            System.out.println("UnknownHostException");
        } catch (IOException e) {
            System.out.println("IOException");
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFoundException");
            e.printStackTrace();
        }
    }
}

BIOS监听Socket

package RPCVersion01;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端以BIO的方式监听Socket
 * 如果有数据的话就调用对应服务的实现类来执行任务
 * 将结果返回给客户端
 */
public class RPCServer {
    public static void main(String[] args) {
        UserServiceImpl userService=new UserServiceImpl();
        try{
            //这边是和Socket进行对应连接，得到对应的接口
            //这个参数就是创建到绑定固定端口的套接字
            ServerSocket serverSocket=new ServerSocket(8899);
            System.out.println("服务端启动了");
            //使用BIO的方式 监听Socket
           while (true){
           //这边使用accept方法来进行接收数据
                Socket socket=serverSocket.accept();
                //开启一个线程去处理
                new Thread(()->{
                    try{
                        ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());
                        ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream());
                        //读取客户端这边传过来的id
                        Integer id=ois.readInt();
                        User userByUserId=userService.getUserByUserId(id);
                        //写入User对象给客户端
                        oos.writeObject(userByUserId);
                        oos.flush();
                    }catch (Exception e){
                        e.printStackTrace();
                        System.out.println("从IO中读取数据错误");
                    }
                }).start();
            }

        } catch (IOException e) {
            //创建ServerSocket产生的异常
            e.printStackTrace();
            System.out.println("服务器启动失败");
        }
    }
}

代码运行结果

结论

这个例子以不到百行的代码，实现了客户端和服务端的一个远程过程调用。但他很不完善，连消息格式都没有统一。

最大痛点如下：

1.只能调用服务端Service唯一确定的方法，如果有两个方法要调用呢？

2.返回值只支持User对象，如果需要传一个字符串或者一个Dog，String对象

3.客户端不够通用，host,post和调用的方法都待定