RPC框架原理
RPC,是Remote Procedure Call 即远程过程调用,对标的是本地调用,本地调用相当于之前自己写的demo里面每个模块之间的调用,例如controller调用service,service调用dao层,这些都是发生在本地并且是同一个服务器下的,如果项目上线的话,其实也还是相当于在一台服务器里面完成的接口调用,只不过用的是Http 方式以RestFUL风格的调用。而RPC就是在不同的服务器之下,远程调用其他服务器中的一个方法,这也可以理解成分布式雏形,为了实现高性能,需要把不同的方法放在不同的服务器之中,在这个服务器集群之中互相远程调用之间的方法。
项目主体
本项目使用的是Github上的一个开源项目。项目地址 项目基础是一个Maven项目,用了lombok,本来在项目基础上集成一下mybatis实现真正的数据库业务,但是普通的maven项目做mybatis麻烦(配置一大堆),懒得搞。
贴代码:
实现一个实体类用来做业务:
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
private int id;
private String name;
private boolean sex;
}
RPC 客户端 Client
public class RPCClient {
public static void main(String[] args) {
ClientProxy clientProxy = new ClientProxy("127.0.0.1", 8899);
UserService proxy = clientProxy.getProxy(UserService.class);
User user = proxy.getUserNameById(new Random().nextInt(500));
System.out.println("从服务端获取的用户为: " + user);
int row = proxy.insertUserById(User.builder().name("XXX").sex(true).id(10).build());
System.out.println("向服务器插入数据: " + row + "条");
}
}
Server 端
public class RPCServer {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
try {
ServerSocket serverSocket = new ServerSocket(8899);
System.out.println("服务端启动了");
//Blocking I/O 方式
while (true){
Socket socket = serverSocket.accept();
//开启线程处理
new Thread(() -> {
try {
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
//读取client传来的id
RPCRequest request = (RPCRequest) ois.readObject();
//反射
Method method = userService.getClass().getMethod(request.getMethodName(),request.getParamsTypes());
Object invoke = method.invoke(userService, request.getParams());
//写回user给Client
oos.writeObject(RPCResponse.success(invoke));
oos.flush();
} catch (IOException | ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
System.out.println("从IO中读取数据错误");
}
}).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
为了实现项目的消息格式一致,创建了Request,Response,类似于Http的。
RPCRequest
/**
* client 传入service接口名,方法名,参数,参数类型
* server通过反射获取调用方法
*/
@Data
@Builder
public class RPCRequest implements Serializable{
// 服务类名,接口名,服务端接口名指向实现类
private String interfaceName;
// 方法名
private String methodName;
// 参数列表
private Object[] params;
// 参数类型
private Class<?>[] paramsTypes;
}
RPCResponse
/**
* 将传输的对象抽象成Object,这样就可以支持多类型
*/
@Data
@Builder
public class RPCResponse implements Serializable {
// 状态信息
private int code;
private String message;
// 具体数据
private Object data;
public static RPCResponse success(Object data){
return RPCResponse.builder().code(200).data(data).build();
}
public static RPCResponse fail(){
return RPCResponse.builder().code(500).message("服务器发生错误").build();
}
}
客户端根据不同的Service动态代理,代理对象增强公共行为。
底层通信:
public class IOClient {
public static RPCResponse sendRequest(String host, int port, RPCRequest request){
try {
Socket socket = new Socket(host, port);
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
System.out.println(request);
oos.writeObject(request);
oos.flush();
RPCResponse response = (RPCResponse) ois.readObject();
return response;
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
return null;
}
}
}
使用动态代理对不同的方法的Request封装
@AllArgsConstructor
public class ClientProxy implements InvocationHandler {
private String host;
private int port;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
RPCRequest request = RPCRequest.builder().interfaceName(method.getDeclaringClass().getName())
.methodName(method.getName())
.params(args).paramsTypes(method.getParameterTypes()).build();
RPCResponse response = IOClient.sendRequest(host, port, request);
return response.getData();
}
public <T>T getProxy(Class<T> clazz){
Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, this);
return (T)o;
}
}
业务类随便写写吧
public interface UserService {
User getUserNameById(int id);
int insertUserById(User user);
}
public class UserServiceImpl implements UserService {
@Override
public User getUserNameById(int id) {
System.out.println("客户端查询了id为" + id + "的用户");
Random random = new Random();
User user = User.builder().id(id).name(UUID.randomUUID().toString()).sex(random.nextBoolean()).build();
return user;
}
@Override
public int insertUserById(User user) {
System.out.println("插入数据成功:" + user);
return 1;
}
}
基本上就这些内容,用一个图总结一下执行流程: