不使用其他框架实现RPC远程调用
回顾RPC框架
| 节点 | 角色说明 |
|---|---|
| Provider | 提供远程服务的服务提供方 |
| Consumer | 调用远程服务的服务消费方 |
| Registry | 服务注册与发现的注册中心 |
Dubbo最重要的三个角色就是服务提供方、服务消费方、注册中心。
下面我们通过Java原生API实现远程调用，不使用任何第三方框架！
服务提供方
package rpc.provider;
/**
* 服务提供方 接口
*
* @author zab
* @date 2020-05-16 17:51
*/
public interface ProviderService {
String testMethod(String ping);
}
package rpc.provider;
/**
* 服务提供方 实现
*
* @author zab
* @date 2020-05-16 17:52
*/
public class ProviderServiceImpl implements ProviderService {
@Override
public String hello(String str) {
return str == null ? "hello consumer." : str + "---> hello consumer. I can do something else for you！";
}
}
服务“注册中心”
这里的注册中心是写死的，只是描述原理，功能很死板。
package rpc.server;
import java.io.File;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* RPC服务端，将provider的服务发布成远程服务，供消费者调用
*
* @author zab
* @date 2020-05-16 17:55
*/
public class RpcServer {
/**
* 自定义线程池，自定义线程工厂和拒绝策略
*/
static Executor executor = new ThreadPoolExecutor(10, 10, 0,
TimeUnit.SECONDS, new LinkedBlockingDeque<>(),
r -> {
Thread t = new Thread(r);
t.setName("myThread");
return t;
},
(r, executor) -> System.out.println(r.toString() + " is discard")
);
/**
* 处理RPC请求调用
*/
public static void startServer(String hostName, int port) throws Exception {
ServerSocket server = new ServerSocket();
server.bind(new InetSocketAddress(hostName, port));
try {
while (true) {
executor.execute(new RpcHandleTask(server.accept()));
}
} finally {
server.close();
}
}
/**
* 接收TCP数据，根据接口，反射调用接口实现类provider的方法
*/
private static class RpcHandleTask implements Runnable {
Socket socket = null;
public RpcHandleTask(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
ObjectInputStream input = null;
ObjectOutputStream output = null;
try {
input = new ObjectInputStream(socket.getInputStream());
//读出接口名
String interfaceName = input.readUTF();
//找到接口所在相对地址
String path = interfaceName.substring(0, interfaceName.lastIndexOf("."));
Class<?> clazz = Class.forName(interfaceName);
//找到接口所在文件下所有文件
File[] files = new File(clazz.getResource("/").getFile() + path.replaceAll("\\.", "\\/")).listFiles();
for (File file : files) {
//找文件，而不是文件夹
if (!file.isDirectory()) {
//path不一定是provider实现类的，这里需要实现类的path
String implPath = path + "." + file.getName().replaceAll(".class", "");
//获取实现类的class
Class<?> implClass = Class.forName(implPath);
//不是接口，并且实现类的接口名和传过来的接口名一致
if (!implClass.isInterface() && interfaceName.equals(implClass.getInterfaces()[0].getName())) {
//获取消费者传过来的接口方法
String methodName = input.readUTF();
//获取消费者传过来的接口参数类型
Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
Method method = implClass.getMethod(methodName, parameterTypes);
Object[] arguments = (Object[]) input.readObject();
//移花接木，调用实现类的方法
Object result = method.invoke(implClass.newInstance(), arguments);
output = new ObjectOutputStream(socket.getOutputStream());
output.writeObject(result);
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (output != null) {
try {
output.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (input != null) {
try {
input.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
}
服务消费方
package rpc;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.Socket;
/**
* 服务消费者远程调用服务提供方，处理连接、反序列化之类工作
*
* @author zab
* @date 2020-05-16 16:50
*/
public class RpcConsumer {
public Object remoteCall(final Class clazz, final InetSocketAddress addr,Object[] args) throws Throwable{
Socket socket = null;
ObjectOutputStream output = null;
ObjectInputStream input = null;
try {
socket = new Socket();
socket.connect(addr);
output = new ObjectOutputStream(socket.getOutputStream());
output.writeUTF(clazz.getName());
Method[] methods = clazz.getMethods();
for (Method method : methods) {
output.writeUTF(method.getName());
output.writeObject(method.getParameterTypes());
output.writeObject(args);
}
input = new ObjectInputStream(socket.getInputStream());
return input.readObject();
} finally {
if (socket != null) socket.close();
if (output != null) output.close();
if (input != null) input.close();
}
}
}
测试
package rpc;
import rpc.provider.ProviderService;
import rpc.server.RpcServer;
import java.net.InetSocketAddress;
public class Test {
static {
startServer();
}
public static void main(String[] args) throws Throwable {
RpcConsumer consumer = new RpcConsumer();
Object[] objArgs = {"调用远程方法--"};
Object providerService = consumer.remoteCall(ProviderService.class, new InetSocketAddress("localhost", 8083), objArgs);
System.out.println(providerService.toString());
}
private static void startServer() {
new Thread(new Test()::runServer).start();
}
private void runServer() {
try {
//远程TCP服务打开，provide发布到远程
RpcServer.startServer("localhost", 8083);
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试结果
技术分析
1、测试类：通过静态代码块调用独立线程启动服务。可以发现，服务消费方，只需要知道服务提供方的接口和地址端口，即可工作。
2、服务消费方：通过socket连接服务注册中心，传入要调用哪个接口、什么参数、何种方法。最后就拿到socket返回的输入流
3、服务注册中心：通过自定义线程池来处理连接，注册中心作为一个socket服务端，根据客户端传过来的接口反射获取接口路径，找到同路径下的该接口实现类，根据接口方法名，调用实现类的方法，最后把结果写入流，通过socket回写给服务消费方。
4、服务提供方：很简单，就一个hello方法。
阅读本案例代码，需要你掌握哪些java基础知识？
1、如何自定义线程池
2、反射原理
3、网络编程
4、Java8新特性
偷个懒，代码拷起来太麻烦！github链接在此：
https://github.com/Jackson-zhanganbing/message-middleware-demo.git
浙公网安备 33010602011771号