手写RPC通信框架

RPC基本介绍

RPC框架就是一个远程调用，不需要客户端去了解底层通信协议而进行数据交换，现有RPC框架有 Dubbo、Thrift(跨语言）、webservice、hessian，这里就利用网络编程基础尝试着去编写一套 PRC框架

服务器端构建

API包下主体编写

首先初始采用Socket进行通信利用IO进行数据交互，对客户端要提供API调用接口，使得客户端可以利用API中提供的接口，获得服务器端的数据。服务器端模块目录如下：

先编写一个接口，该接口放置在api模块下，实现类放置在provider模块下，这样做目的是让客户端仅加载API包的条件下，可以调用服务器端的实现类完成具体业务逻辑。

public interface IHelloService { String sayHello(String content); String saveUser(User user); }

服务器端需要客户端传递，需要调用的类、方法以及参数，这样服务器端会知晓调用。故完善API包下的类如下：

public class RpcRequest implements Serializable { private String className; private String methodName; private Object[] parameters; public String getClassName() { return className; } public void setClassName(String className) { this.className = className; } public String getMethodName() { return methodName; } public void setMethodName(String methodName) { this.methodName = methodName; } public Object[] getParametes() { return parameters; } public void setParametes(Object[] parameters) { this.parameters = parameters; } } public class User implements Serializable { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age=" + age + '}'; } }

API包中结构基本完成 接下来编写服务器的通信交互与处理逻辑

provider包下主体编写

首先需要晚上HelloService的业务逻辑

public class HelloServiceImpl implements IHelloService { @Override public String sayHello(String content) { System.out.println("request in sayHello:"+content); return "Say Hellp: "+content; } @Override public String saveUser(User user) { System.out.println("request in SaveUser:"+user.toString()); return "SUCCESS"; } }

基本的编写完成，接下来是对交互逻辑代码的编写，首先需要采用Socke进行传输，传输过程中会拿到调用类、方法与参数，故采用反射可以调用类。首先我们先编写传输通信逻辑 在这里IO阻塞部分利用线程池进行优化，使得一个线程处理一个Socket（后续可以利用NIO优化）。

public class RpcProxyServer { ExecutorService executorService= Executors.newCachedThreadPool(); public void publisher(Object service,int port){ ServerSocket serverSocket=null; try { serverSocket = new ServerSocket(port); while (true){ Socket socket= serverSocket.accept(); //每个Socker 交给一个ProcessorHandler来处理 executorService.execute(new ProcessorHandler(socket,service)); } } catch (IOException e) { e.printStackTrace(); }finally { if(serverSocket!=null){ try { serverSocket.close(); } catch (IOException e) { e.printStackTrace(); } } } } }

接下来是反射调用，由于采用线程去优化故需要实现Runnable接口中的run方法，在run方法中完成Socket通信后的I/O流，调用invoke方法完成反射调用逻辑。

public class ProcessorHandler implements Runnable{ private Socket socket; private Object service; public ProcessorHandler(Socket socket, Object service) { this.socket = socket; this.service = service; } @Override public void run() { ObjectInputStream objectInputStream=null; ObjectOutputStream objectOutputStream=null; try { objectInputStream = new ObjectInputStream(socket.getInputStream()); //输入流的信息 //请求类，请求方法名、请求参数 RpcRequest rpcRequest=(RpcRequest)objectInputStream.readObject(); Object result=invoke(rpcRequest);//反射调用本地服务结果写出 objectOutputStream = new ObjectOutputStream(socket.getOutputStream()); objectOutputStream.writeObject(result); objectOutputStream.flush(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException | InvocationTargetException | IllegalAccessException | NoSuchMethodException e) { e.printStackTrace(); }finally { if(objectInputStream!=null){ try { objectInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } if(objectOutputStream!=null){ try { objectOutputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } } private Object invoke(RpcRequest request) throws ClassNotFoundException, InvocationTargetException, IllegalAccessException, NoSuchMethodException { Object[] args=request.getParametes();//拿到客户端请求参数 Class<?>[] types=new Class[args.length]; for(int i=0;i<args.length;i++){ types[i]=args[i].getClass();//去获得参数类型 } Class clazz= Class.forName(request.getClassName());//根据请求去加载类 Method method=clazz.getMethod(request.getMethodName(),types); //去找到类中方法 Object result= method.invoke(service,args);//进行反射调用 return result; } }

服务器端编写完毕。接下来对API模块进行打包，在客户端中pom文件中引用。

客户端模块编写

首先在Pom文件引入编写的api包，编写Socket通信类。

public class RpcNetTransport { private String host; private int port; public RpcNetTransport(String host, int port) { this.host = host; this.port = port; } public Object send(RpcRequest request){ Socket socket; Object result=null; ObjectOutputStream objectOutputStream=null; ObjectInputStream objectInputStream=null; try { socket =new Socket(host,port); //连接服务器 objectOutputStream=new ObjectOutputStream(socket.getOutputStream()); //网络流 objectOutputStream.writeObject(request); //写入传输给服务端的数据 objectOutputStream.flush(); objectInputStream=new ObjectInputStream(socket.getInputStream()); result=objectInputStream.readObject();//接收服务端传回的数据 } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); }finally { if(objectInputStream!=null){ try { objectInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } if(objectOutputStream!=null){ try { objectOutputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } return result; } }

接下来是利用JDK动态代理去调用方法 这里采用了代理模式，借用动态代理去实现调用。

public class RpcProxyClient { public <T> T clientProxy(final Class<T> interfaceCls,final String host,final int port){ return (T) Proxy.newProxyInstance(interfaceCls.getClassLoader(),new Class<?>[]{interfaceCls},new RemoteInvocationHandler(host, port)); } } public class RemoteInvocationHandler implements InvocationHandler { private String host; private int port; public RemoteInvocationHandler(String host, int port) { this.host = host; this.port = port; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { RpcRequest rpcRequest=new RpcRequest(); rpcRequest.setClassName(method.getDeclaringClass().getName()); rpcRequest.setMethodName(method.getName()); rpcRequest.setParametes(args); RpcNetTransport rpcNetTransport=new RpcNetTransport(host,port); return rpcNetTransport.send(rpcRequest); } }

最后客户端调用代码

public class App { public static void main( String[] args ) { RpcProxyClient rpcProxyClient = new RpcProxyClient(); IHelloService iHelloService=rpcProxyClient .clientProxy(IHelloService.class,"localhost",8080); User user = new User(); user.setAge(18); user.setName("洋娃娃"); String result= iHelloService.saveUser(user); System.out.println(result); result= iHelloService.sayHello("杨某"); System.out.println(result); } }

这里的iHelloService实际上利用动态代理对象。 客户端输出结果 后续有精力可以利用NIO去改善IO处理，或者使用Netty框架。rpc通信框架其实与Tomcat的编程思想也大同小异，也可以借此去思路去实现Tomcat，http传输的也是就是一串字符串，有特定协议的字符串，通过浏览器（客户端）去解析。