本篇内容主要讲解“java rpc框架的原理是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“java rpc框架的原理是什么”吧!
RPC基础概念
RPC就是远程过程调用协议，其作用就是客户端与服务端之间的远程调用，就像本地自己调用一样，让服务端进行服务化，功能唯一性，负载热点流量。
RPC能够让本地应用简单、高效地调用服务器中的过程（服务）。它主要应用在分布式系统。如Hadoop中的IPC组件。但怎样实现一个RPC框架呢？
从下面几个方面思考，仅供参考：
1.通信模型：假设通信的为A机器与B机器，A与B之间有通信模型，在Java中一般基于BIO或NIO；。
2.过程（服务）定位：使用给定的通信方式，与确定IP与端口及方法名称确定具体的过程或方法；
3.远程代理对象：本地调用的方法(服务)其实是远程方法的本地代理，因此可能需要一个远程代理对象，对于Java而言，远程代理对象可以使用Java的动态对象实现，封装了调用远程方法调用；
4.序列化，将对象名称、方法名称、参数等对象信息进行网络传输需要转换成二进制传输，这里可能需要不同的序列化技术方案。如:thrift,protobuf,Arvo等。
下面用简单的原生java socket来实现rpc调用，方便大家更深层了解rpc原理
服务类接口
package socketrpc;
2
3 public interface IHello {
4 String sayHello(String string);
5 }服务实现类
1 package socketrpc.server;
2
3 import socketrpc.IHello;
4
5 public class HelloServiceImpl implements IHello {
6
7 @Override
8 public String sayHello(String string) {
9 return "你好:".concat ( string );
10 }
11 }客户端实现
package socketrpc.client;
import socketrpc.IHello;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;
public class RpcClientProxy<T> implements InvocationHandler {
private Class<T> serviceInterface;
private InetSocketAddress addr;
public RpcClientProxy(Class<T> serviceInterface, String ip,String port) {
this.serviceInterface = serviceInterface;
this.addr = new InetSocketAddress(ip, Integer.parseInt ( port ));
}
public T getClientIntance(){
return (T) Proxy.newProxyInstance (serviceInterface.getClassLoader(),new Class<?>[]{serviceInterface},this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = null;
ObjectOutputStream output = null;
ObjectInputStream input = null;
try {
// 2.创建Socket客户端，根据指定地址连接远程服务提供者
socket = new Socket();
socket.connect(addr);
// 3.将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
output = new ObjectOutputStream(socket.getOutputStream());
output.writeUTF(serviceInterface.getName());
output.writeUTF(method.getName());
output.writeObject(method.getParameterTypes());
output.writeObject(args);
// 4.同步阻塞等待服务器返回应答，获取应答后返回
input = new ObjectInputStream(socket.getInputStream());
return input.readObject();
} finally {
if (socket != null) socket.close();
if (output != null) output.close();
if (input != null) input.close();
}
}
public static void main(String[] args) {
RpcClientProxy client = new RpcClientProxy<>(IHello.class,"localhost","6666");
IHello hello = (IHello) client.getClientIntance ();
System.out.println (hello.sayHello ( "socket rpc" ));
}
}服务端实现
package socketrpc.server;
import socketrpc.IHello;
import java.io.IOException;
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.HashMap;
public class RpcServer {
private static final HashMap<String, Class<?>> serviceRegistry = new HashMap<>();
private int port;
public RpcServer(int port) {
this.port =port;
}
public RpcServer register(Class serviceInterface, Class impl) {
serviceRegistry.put(serviceInterface.getName(), impl);
return this;
}
public void run() throws IOException {
ServerSocket server = new ServerSocket();
server.bind(new InetSocketAddress (port));
System.out.println("start server");
ObjectInputStream input =null;
ObjectOutputStream output =null;
Socket socket=null;
try {
while(true){
socket = server.accept ();
input =new ObjectInputStream(socket.getInputStream());
String serviceName = input.readUTF();
String methodName = input.readUTF();
System.out.println (methodName);
Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
Object[] arguments = (Object[]) input.readObject();
Class serviceClass = serviceRegistry.get(serviceName);
if (serviceClass == null) {
throw new ClassNotFoundException(serviceName + " not found");
}
Method method = serviceClass.getMethod(methodName, parameterTypes);
Object result = method.invoke(serviceClass.newInstance(), arguments);
output = new ObjectOutputStream (socket.getOutputStream());
output.writeObject(result);
}
} catch (Exception e){
e.printStackTrace();
}finally {
if (output != null) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) throws IOException {
new RpcServer ( 6666 ).register ( IHello.class,HelloServiceImpl.class).run ();
}
}启动服务端和客户端后运行结果如下
客户端代码简单讲解
private Class<T> serviceInterface;
2 private InetSocketAddress addr;
3
4 public RpcClientProxy(Class<T> serviceInterface, String ip,String port) {
5 this.serviceInterface = serviceInterface;
6 this.addr = new InetSocketAddress(ip, Integer.parseInt ( port ));
7 }
8
9 public T getClientIntance(){
10 return (T) Proxy.newProxyInstance (serviceInterface.getClassLoader(),new Class<?>[]{serviceInterface},this);
11 }传入接口类和ip端口,调用getClientIntance方法时,对当前接口进行代理,实际调用方法为
1 @Override
2 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
3
4 Socket socket = null;
5 ObjectOutputStream output = null;
6 ObjectInputStream input = null;
7
8 try {
9 // 2.创建Socket客户端，根据指定地址连接远程服务提供者
10 socket = new Socket();
11 socket.connect(addr);
12
13 // 3.将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
14 output = new ObjectOutputStream(socket.getOutputStream());
15 output.writeUTF(serviceInterface.getName());
16 output.writeUTF(method.getName());
17 output.writeObject(method.getParameterTypes());
18 output.writeObject(args);
19
20 // 4.同步阻塞等待服务器返回应答，获取应答后返回
21 input = new ObjectInputStream(socket.getInputStream());
22 return input.readObject();
23 } finally {
24 if (socket != null) socket.close();
25 if (output != null) output.close();
26 if (input != null) input.close();
27 }
28 }遵循下面步骤
1：创建socket，并和远程进行三次连接握手【socket.connect(addr)】。
2：封装socket输出流【ObjectOutputStream】。
3：输出类名称，方法名称，参数类型和参数值给server。
4：获取socket输入流，等待server返回结果。
服务端代码简单讲解
1 public RpcServer(int port) {
2 this.port =port;
3 }
4
5 public RpcServer register(Class serviceInterface, Class impl) {
6 serviceRegistry.put(serviceInterface.getName(), impl);
7 return this;
8 }初始化服务端，将服务类注册到hashMap【模拟spring上下文】
1 public void run() throws IOException {
2
3 ServerSocket server = new ServerSocket();
4 server.bind(new InetSocketAddress (port));
5 System.out.println("start server");
6 ObjectInputStream input =null;
7 ObjectOutputStream output =null;
8 Socket socket=null;
9 try {
10 while(true){
11 socket = server.accept ();
12 input =new ObjectInputStream(socket.getInputStream());
13
14 String serviceName = input.readUTF();
15 String methodName = input.readUTF();
16 System.out.println (methodName);
17 Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
18 Object[] arguments = (Object[]) input.readObject();
19 Class serviceClass = serviceRegistry.get(serviceName);
20 if (serviceClass == null) {
21 throw new ClassNotFoundException(serviceName + " not found");
22 }
23 Method method = serviceClass.getMethod(methodName, parameterTypes);
24 Object result = method.invoke(serviceClass.newInstance(), arguments);
25 output = new ObjectOutputStream (socket.getOutputStream());
26 output.writeObject(result);
27 }
28 } catch (Exception e){
29 e.printStackTrace();
30 }finally {
31 if (output != null) {
32 try {
33 output.close();
34 } catch (IOException e) {
35 e.printStackTrace();
36 }
37 }
38 if (input != null) {
39 try {
40 input.close();
41 } catch (IOException e) {
42 e.printStackTrace();
43 }
44 }
45 if (socket != null) {
46 try {
47 socket.close();
48 } catch (IOException e) {
49 e.printStackTrace();
50 }
51 }
52 }
53
54 }服务端执行做了以下几件事：
1：绑定端口，阻塞等待客户端调用【socket = server.accept ()】。
2：封装输入流【socket.getInputStream()】。
3：从输入流中获取到接口名，方法名，参数类型，参数值。
4：找到初始化时hashmap中的服务类。
5：反射获取服务实现类方法并根据请求参数进行服务调用。
6：封装输出流【ObjectOutputStream】，并且返回结果。
到目前为止，整个简单的socket实现的RPC服务就已经全部完成了，可以优化的部分。
1：序列化局限，原生序列化只能序列化实现了【Serializable】接口的服务类，并且序列化复杂对象时，内容庞大效率极低，需要高效的序列化协议进行序列化参数方法等必要请求入参
2：BIO性能局限，socket服务端采用默认的BIO来阻塞获取输入流，效率低下，需采用NIO等异步非阻塞服务端方案，例如netty,mina和java nio等。
3：在大型企业级RPC解决方案中，客户端和服务端的长连接需要一直保持，否则每次调用时都要重新进行三次握手和四次挥手，这样频繁的创建tcp连接对机器性能是极大的损耗，对socket的连接可以采用apache pool2连接池等方案
4：服务端负载，需要考虑服务自动发现，让客户端在不需要重启的情况下能动态感知服务端的变化，从而实现热部署等。可以采用办法定时自动轮询，zookeeper等。
5：服务端服务类执行异常，客户端感知等。
到此，相信大家对“java rpc框架的原理是什么”有了更深的了解，不妨来实际操作一番吧！这里是亿速云网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
