RPC框架（1 - 实现服务端注册一个服务）-阿里云开发者社区

5.实现流程

5.1实现服务端注册一个服务

5.1.1通用接口

基于这样一个假设，那就是客户端已经知道了服务端的地址，这部分会由后续的服务发现机制完善。通用接口

public interface HelloService {
    String hello(HelloObject object);
}

hello方法需要传递一个对象，HelloObject对象，定义如下：

@Data
@AllArgsConstructor
public class HelloObject implements Serializable {
    private Integer id;
    private String message;
}

注意这个对象需要实现Serializable接口，因为它需要在调用过程中从客户端传递给服务端。

默认的序列化机制，即实现Serializable接口即可，不需要实现任何方法。该接口没有任何方法，只是一个标记而已，告诉Java虚拟机该类可以被序列化了。然后利用ObjectOutputStream进行序列化和用ObjectInputStream进行反序列化。

问题一：为何要实现序列化？

答：序列化就是对实例对象的状态(State 对象属性而不包括对象方法)进行通用编码（如格式化的字节码）并保存，以保证对象的完整性和可传递性。简而言之：序列化，就是为了在不同时间或不同平台的JVM之间共享实例对象，只有经过序列化，才能兼容对象在磁盘文本以及在网络中的传输，以及恢复对象的时候反序列化等操作。

在Java中常见的几个类，如：Interger/String等，都实现了java.io.Serializable接口。这个序列化接口没有任何方法和域，仅用于标识序列化语意；实现 Serializable 接口的类是可序列化的，没有实现此接口的类将不能被序列化和反序列化。序列化类的所有子类本身都是可序列化的，不再需要显式实现 Serializable 接口。

如没有实现Serializable接口，在序列化时，使用ObjectOutputStream的write（object）方法将对象保存时将会出现异常。其实 java.io.Serializable 只是一个没有属性和方法的空接口。

问题二：为何一定要实现 Serializable 才能进行序列化呢？

用 ObjectOutputStream 来持久化对象，对于此处抛出的异常，如果被写对象类型是String、数组、Enum、Serializable，就可以进行序列化，否则将抛出NotSerializableException。

拓展：serialVersionUID 用来表明类的不同版本间的兼容性。Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。

接着我们在服务端对这个接口进行实现，实现的方式也很简单，返回一个字符串就行：

public class HelloServiceImpl implements HelloService {
    private static final Logger logger = LoggerFactory.getLogger(HelloServiceImpl.class);
    @Override
    public String hello(HelloObject object) {
        logger.info("接收到：{}", object.getMessage());
        return "这是掉用的返回值，id=" + object.getId();
    }
}

5.1.2传输协议

服务端需要哪些信息，才能唯一确定服务端需要调用的接口的方法呢？

待调用接口的名称
待调用方法名称
待调用方法的参数（由于方法重载的缘故）
待调用方法的参数类型

重载：发生在同一个类中，方法名必须相同，参数列表（参数个数、类型不同，多个参数的顺序）必须不同，方法返回值和访问修饰符可以不同，发生在编译时（编译器会根据参数列表进行匹配，确定方法，如果失败，编译器报错，这叫做重载分辨）。

每个重构的方法（构造函数）都必须有独一无二的参数类型列表。最常见的地方就是构造器的重载，即构造函数。

好处：面向对象的特点，代码逻辑更简洁、明了。

那么服务端知道以上四个条件，就可以找到这个方法并且调用了。我们把这四个条件写到一个对象里，到时候传输时传输这个对象就行了。即RpcRequest对象：

@Data
@Builder
public class RpcRequest implements Serializable {
    /**
     * 待调用接口名称
     */
    private String interfaceName;
    /**
     * 待调用方法名称
     */
    private String methodName;
    /**
     * 调用方法的参数
     */
    private Object[] parameters;
    /**
     * 调用方法的参数类型
     */
    private Class<?>[] paramTypes;
}

那么服务器调用完这个方法后，需要给客户端返回哪些信息呢？

如果调用成功的话，显然需要返回值，如果调用失败了，就需要失败的信息，这里封装成一个RpcResponse对象：

@Data
public class RpcResponse<T> implements Serializable {
    /**
     * 响应状态码
     */
    private Integer statusCode;
    /**
     * 响应状态补充信息
     */
    private String message;
    /**
     * 响应数据
     */
    private T data;
    public static <T> RpcResponse<T> success(T data) {
        RpcResponse<T> response = new RpcResponse<>();
        response.setStatusCode(ResponseCode.SUCCESS.getCode());
        response.setData(data);
        return response;
    }
    public static <T> RpcResponse<T> fail(ResponseCode code) {
        RpcResponse<T> response = new RpcResponse<>();
        response.setStatusCode(code.getCode());
        response.setMessage(code.getMessage());
        return response;
    }
}

这里还多写了两个静态方法，用于快速生成成功与失败的响应对象。其中，statusCode属性可以自行定义，客户端服务端一致即可。

静态方法：先于其他方法初始化，系统会为静态方法分配一个固定的内存空间（方法区中的静态方法区），只会被初始化一次。而普通方法，会随着对象的调用而加载，当使用完毕，会自动释放掉空间。

普通方法的好处是，动态规划了内存空间的使用，节省内存资源。静态方法，方便，运行快，而如果全部方法都用静态方法，那么每个方法都要有一个固定的空间，这样的话太占内存。

拓展：Java方法区存的是什么样的东西？

方法区存着类的信息，常量和静态变量，即类被编译后的数据。（线程共享的）

5.1.3客户端实现-动态代理

客户端方面，由于在客户端这一侧我们并没有接口的具体实现类，就没有办法直接生成实例对象。这时，我们可以通过动态代理的方式生成实例，并且调用方法时生成需要的RpcRequest对象并且发送给服务端。

这里我们采用JDK动态代理，代理类是需要实现InvocationHandler接口的。

public class RpcClientProxy implements InvocationHandler {
    private String host;
    private int port;
    public RpcClientProxy(String host, int port) {
        this.host = host;
        this.port = port;
    }
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Class<T> clazz) {
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class<?>[]{clazz}, this);
    }
}

我们需要传递host和port来指明服务端的位置。并且使用getProxy()方法来生成代理对象。

InvocationHandler接口需要实现invoke()方法，来指明代理对象的方法被调用时的动作。在这里，我们显然就需要生成一个RpcRequest对象，发送出去，然后返回从服务端接收到的结果即可：

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        RpcRequest rpcRequest = RpcRequest.builder()
                .interfaceName(method.getDeclaringClass().getName())
                .methodName(method.getName())
                .parameters(args)
                .paramTypes(method.getParameterTypes())
                .build();
        RpcClient rpcClient = new RpcClient();
        return ((RpcResponse) rpcClient.sendRequest(rpcRequest, host, port)).getData();
    }

生成RpcRequest很简单，我使用Builder模式来生成这个对象。发送的逻辑我使用了一个RpcClient对象来实现，这个对象的作用，就是将一个对象发过去，并且接收返回的对象。

public class RpcClient {
    private static final Logger logger = LoggerFactory.getLogger(RpcClient.class);
    public Object sendRequest(RpcRequest rpcRequest, String host, int port) {
        try (Socket socket = new Socket(host, port)) {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
            objectOutputStream.writeObject(rpcRequest);
            objectOutputStream.flush();
            return objectInputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            logger.error("调用时有错误发生：", e);
            return null;
        }
    }
}

我的实现很简单，直接使用Java的序列化方式，通过Socket传输。创建一个Socket，获取ObjectOutputStream对象，然后把需要发送的对象传进去即可，接收时获取ObjectInputStream对象，readObject()方法就可以获得一个返回的对象。

socket通信（数据传送）：socket主要包含了客户端和服务端

客户端：主要用来发送数据，主要参数为server的ip地址，和端口号；然后进行流的输出，随后一定需要注意socket的shutdownOutput关闭，否则会出现异常

服务端：ServerClient。服务启动后，会一直存在，不会关闭。服务器主要是依赖服务器端口是否匹配
serversocket、进行inputstream流的读取

socket通信大致过程

服务器端创建一个ServerSocket对象监听某个端口，然后调用accept()方法等待客户连接。

客户端程序创建一个Socket对象，请求与服务器端程序建立连接。

服务器端程序接收客户端连接请求，创建一个新的线程，在新的线程中处理调用。

打开连接服务器与客户端程序中的Socket的输入/输出流（socket.getOutputStream()）。

利用输入/输出流，按照一定的协议对Socket进行读/写操作。

关闭输入\输出流和Socket

5.1.4服务端实现-反射调用

服务端的实现就简单多了，使用一个ServerSocket监听某个端口，循环接收连接请求，如果发来了请求就创建一个线程，在新线程中处理调用。这里创建线程采用线程池：

public class RpcServer {
    private final ExecutorService threadPool;
    private static final Logger logger = LoggerFactory.getLogger(RpcServer.class);
    public RpcServer() {
        int corePoolSize = 5;
        int maximumPoolSize = 50;
        long keepAliveTime = 60;
        BlockingQueue<Runnable> workingQueue = new ArrayBlockingQueue<>(100);
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, workingQueue, threadFactory);
    }
}

这里简化了一下，RpcServer暂时只能注册一个接口，即对外提供一个接口的调用服务，添加register方法，在注册完一个服务后立刻开始监听：

public void register(Object service, int port) {
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            logger.info("服务器正在启动...");
            Socket socket;
            while((socket = serverSocket.accept()) != null) {
                logger.info("客户端连接！Ip为：" + socket.getInetAddress());
                threadPool.execute(new WorkerThread(socket, service));
            }
        } catch (IOException e) {
            logger.error("连接时有错误发生：", e);
        }
    }

这里向工作线程WorkerThread传入了socket和用于服务端实例service。

WorkerThread实现了Runnable接口，用于接收RpcRequest对象，解析并且调用，生成RpcResponse对象并传输回去。run方法如下：

@Override
    public void run() {
        try (ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream())) {
            RpcRequest rpcRequest = (RpcRequest) objectInputStream.readObject();
            Method method = service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamTypes());
            Object returnObject = method.invoke(service, rpcRequest.getParameters());
            objectOutputStream.writeObject(RpcResponse.success(returnObject));
            objectOutputStream.flush();
        } catch (IOException | ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            logger.error("调用或发送时有错误发生：", e);
        }
    }

其中，通过class.getMethod方法，传入方法名和方法参数类型即可获得Method对象。如果你上面RpcRequest中使用String数组来存储方法参数类型的话，这里你就需要通过反射生成对应的Class数组了。通过method.invoke方法，传入对象实例和参数，即可调用并且获得返回值。

5.1.5测试

服务端侧，我们已经在上面实现了一个HelloService的实现类HelloServiceImpl，我们只需要创建一个RpcServer并且把这个实现类注册进去就行了：

public class TestServer {
    public static void main(String[] args) {
        HelloService helloService = new HelloServiceImpl();
        RpcServer rpcServer = new RpcServer();
        // 将HelloServiceImpl注册到rpcServer,同时也启动了服务器
        rpcServer.register(helloService, 9000);
    }
}

服务端开放在9000端口。

客户端方面，我们需要通过动态代理，生成代理对象，并且调用，动态代理会自动帮我们向服务端发送请求的：

public class TestClient {
    public static void main(String[] args) {
        RpcClientProxy proxy = new RpcClientProxy("127.0.0.1", 9000);
        HelloService helloService = proxy.getProxy(HelloService.class);
        HelloObject object = new HelloObject(12, "This is a message");
        String res = helloService.hello(object);
        System.out.println(res);
    }
}

我们这里生成了一个HelloObject对象作为方法的参数。

首先启动服务端，再启动客户端,测试结果：

// 服务端输出：
服务器正在启动...
客户端连接！Ip为：127.0.0.1
接收到：This is a message
// 客户端输出：
这是调用的返回值，id=12

RPC框架（1 - 实现服务端注册一个服务）

5.实现流程

5.1实现服务端注册一个服务

5.1.1通用接口

5.1.2传输协议

5.1.3客户端实现-动态代理

5.1.4服务端实现-反射调用

5.1.5测试

热门文章

最新文章

相关电子书

相关实验场景