11.1 Basic introduction to RPC
-
RPC (Remote Procedure Call) — Remote procedure call is a computer communication protocol. The protocol allows a program running on one computer to call a subprogram of another computer without the programmer having to program this interaction
-
Two or more applications are distributed on different servers, and the calls between them are like local method calls.
3) Common RPC frameworks are: relatively well-known such as Ali's Dubbo, Google's gRPC, Go rpcx, Apache thrift,
Spring Cloud under Spring.
11.2 RPC call flow chart
11.3 PRC call process description
1) The service consumer (client) calls the service in a local call
2) The client stub is responsible for encapsulating methods, parameters, etc. into a message body capable of network transmission after receiving the call
3) The client stub encodes the message and sends it to the server
4) The server stub receives the message and decodes it
5) The server stub Call the local service based on the decoding result
6) Local service execution and return the result to the server stub
7) The server stub encodes the returned import result and sends it to the consumer
8) The client stub receives the message and decodes it
9) The service consumer (client) gets the result
Summary: The goal of RPC is to encapsulate these steps 2-8 , users do not need to care about these details, you can complete the remote service call like calling a local method
11.4 Implement dubbo RPC yourself (based on Netty)
11.4.1 Requirements
- The bottom layer of dubbo uses Netty as the network communication framework, requiring Netty to implement a simple RPC framework
- Imitating dubbo, the consumer and the provider agree on the interface and protocol. The consumer calls the provider's service remotely. The provider returns a string, and the consumer prints the data returned by the provider. The underlying network communication uses Netty 4.1.20
11.4.2 Design instructions
- Create an interface and define abstract methods. Used for agreements between consumers and providers.
- Create a provider, this class needs to listen to consumer requests and return data according to the convention.
- Create a consumer, this class needs to transparently call its own non-existent method, internally need to use Netty to request the provider to return data
- Analysis chart developed
11.4.3 Code implementation
//这个是接口，是服务提供方和 服务消费方都需要
public interface HelloService {
String hello(String mes);
}
public class HelloServiceImpl implements HelloService{
private static int count = 0;
//当有消费方调用该方法时， 就返回一个结果
@Override
public String hello(String mes) {
System.out.println("收到客户端消息=" + mes);
//根据mes 返回不同的结果
if(mes != null) {
return "你好客户端, 我已经收到你的消息 [" + mes + "] 第" + (++count) + " 次";
} else {
return "你好客户端, 我已经收到你的消息 ";
}
}
}
Server
//ServerBootstrap 会启动一个服务提供者，就是 NettyServer
public class ServerBootstrap {
public static void main(String[] args) {
NettyServer.startServer("127.0.0.1", 7000);
}
}
public class NettyServer {
public static void startServer(String hostName, int port) {
//不同的启动方式
startServer0(hostName,port);
}
//编写一个方法，完成对NettyServer的初始化和启动
private static void startServer0(String hostname, int port) {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup,workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new StringDecoder());//编码
pipeline.addLast(new StringEncoder());//解码
pipeline.addLast(new NettyServerHandler()); //业务处理器
}
}
);
ChannelFuture channelFuture = serverBootstrap.bind(hostname, port).sync();
System.out.println("服务提供方开始提供服务~~");
channelFuture.channel().closeFuture().sync();
}catch (Exception e) {
e.printStackTrace();
}
finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
//服务器这边handler比较简单
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//获取客户端发送的消息，并调用服务
System.out.println("msg=" + msg);
//客户端在调用服务器的api 时，我们需要定义一个协议
//比如我们要求 每次发消息是都必须以某个字符串开头 "HelloService#hello#你好"
if(msg.toString().startsWith(ClientBootstrap.providerName)) {
String result = new HelloServiceImpl().hello(msg.toString()
.substring(msg.toString().lastIndexOf("#") + 1));
ctx.writeAndFlush(result);
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
Client
public class ClientBootstrap {
//这里自定义协议头
public static final String providerName = "HelloService#hello#";
public static void main(String[] args) throws Exception{
//创建一个消费者
NettyClient customer = new NettyClient();
//创建代理对象
HelloService service = (HelloService) customer.getBean(HelloService.class, providerName);
for (;; ) {
Thread.sleep(2 * 1000);
//通过代理对象调用服务提供者的方法(服务)
String res = service.hello("你好 dubbo~");
System.out.println("调用的结果 res= " + res);
}
}
}
public class NettyClient {
//创建线程池
private static ExecutorService executor = Executors.
newFixedThreadPool(Runtime.getRuntime().availableProcessors());
private static NettyClientHandler client;
private int count = 0;
//编写方法使用代理模式，获取一个代理对象 与服务器交互的自定义的协议信息
public Object getBean(final Class<?> serivceClass, final String providerName) {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class<?>[]{serivceClass}, (proxy, method, args) -> {
System.out.println("(proxy, method, args) 进入...." + (++count) + " 次");
//{} 部分的代码，客户端每调用一次 hello, 就会进入到该代码
if (client == null) {
initClient();
}
//设置要发给服务器端的信息
//providerName 协议头 args[0] 就是客户端调用api hello(???), 参数
client.setPara(providerName + args[0]);
return executor.submit(client).get();
});
}
//初始化客户端
private static void initClient() {
client = new NettyClientHandler();
//创建EventLoopGroup
NioEventLoopGroup group = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(
new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new StringDecoder());
pipeline.addLast(new StringEncoder());
pipeline.addLast(client);
}
}
);
try {
bootstrap.connect("127.0.0.1", 7000).sync();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class NettyClientHandler extends ChannelInboundHandlerAdapter implements Callable {
private ChannelHandlerContext context;//上下文
private String result; //返回的结果
private String para; //客户端调用方法时，传入的参数
//与服务器的连接创建后，就会被调用, 这个方法是第一个被调用(1)
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println(" channelActive 被调用 ");
context = ctx; //因为我们在其它方法会使用到 ctx，所以赋值传给了context
}
//收到服务器的数据后，调用方法 (4)
@Override
public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println(" channelRead 被调用 ");
result = msg.toString();
notify(); //唤醒等待的线程
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
//被代理对象调用, 发送数据给服务器，-> wait -> 等待被唤醒(channelRead) -> 返回结果 (3)-》5
@Override
public synchronized Object call() throws Exception {
System.out.println(" call1 被调用 ");
context.writeAndFlush(para);
//进行wait
wait(); //等待channelRead 方法获取到服务器的结果后，唤醒
System.out.println(" call2 被调用 ");
return result; //服务方返回的结果
}
//(2)
void setPara(String para) {
System.out.println(" setPara ");
this.para = para;
}
}
