Shulou(Shulou.com)06/03 Report--

This article introduces the "handwritten a RPC framework method tutorial" related knowledge, in the actual case operation process, many people will encounter such a dilemma, then let the editor lead you to learn how to deal with these situations! I hope you can read it carefully and be able to achieve something!

Introduction

When developing a single project, everyone must have written similar code. That is, the service provider and the service caller are in one service.

Public interface HelloService {public String sayHello (String content);} public class HelloServiceImpl implements HelloService {@ Override public String sayHello (String content) {return "hello," + content;}} public class Test {public static void main (String [] args) {HelloService helloService = new HelloServiceImpl (); String msg = helloService.sayHello ("world"); / / hello world System.out.println (msg);}}

However, due to the many disadvantages of single service, many companies have split the irrelevant functions into different services.

How to invoke a remote service in the same way as a local service? At this point we have to mention the RPC framework (Remote Procedure Call, remote procedure call). He helps us to shield the implementation of network communication, serialization and other operations, so that it is as convenient to invoke remote services as to invoke local services.

Well-known RPC frameworks include Spring Cloud, Alibaba's Dubbo,Facebook 's Thrift,Google grpc, and so on.

The procedure of calling RPC

The procedure for a RPC call is as follows

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

After the caller sends the request, the method and parameters called by the proxy class are assembled into a message body that can be transmitted over the network.

The caller sends the message body to the provider

The provider decodes the message to get the parameters of the call

The provider reflection executes the corresponding method and returns the result

Let's analyze how the rpc framework is implemented. Where can we expand? In order to give you a more vivid understanding, I wrote a github project, from simple to difficult to implement a rpc framework, welcome star

Https://github.com/erlieStar/simple-rpc

Generate proxy classes

As we said earlier, after the caller executes the method, it actually executes the method of the proxy class, which helps us with serialization and codec operations. So how do you generate a proxy class?

Let's take a look at the mainstream approach.

Both Facebook's Thrift and Google's grpc define a schema file, and then execute the program to help you generate client-side proxy classes and interfaces. The caller requests directly with the generated proxy class, and the provider inherits the generated interface.

The biggest advantage of this method is that it can communicate in multiple languages, that is, a schema file can generate Java programs or Python programs. The caller is the Java program, and the provider is the Python program that can communicate normally. And it is a binary protocol, and the communication efficiency is relatively high.

There are several ways to generate proxy classes in Java

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

JDK dynamic proxy (implement InvocationHandler interface)

Bytecode manipulation class library (such as cglib,Javassist)

In Dubbo, there are two ways to generate proxy classes, jdk dynamic proxy and Javassist. The default is javassist. As for the reason? Of course, javassist is more efficient.

Agreement

Why do you need a protocol? Spring Cloud communicates through the Http protocol, so which protocol does Dubbo communicate through?

Why do you need an agreement?

Because the data is transmitted in binary form in the network, the request data of RPC is not sent to the provider as a whole, but may be split into multiple packets, so how does the provider identify the data?

For example, in a text ABCDEF, the data received by the provider in turn may be ABCDEF or ABCDEF. What should the provider do with the data?

It's easy. Just make a rule. There can be many kinds of rules. Here are three examples.

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Fixed length protocol. The length of the protocol content is fixed. If you read 50 byte and start the decode operation, you can refer to the FixedLengthFrameDecoder of Netty.

Special Terminator, which defines a delimiter at the end of the message. If you read\ n, it means that a data has been read and read all the time without reading it. You can refer to the DelimiterBasedFrameDecoder of Netty.

Variable length protocol (protocol header + protocol body), a fixed length is used to represent the length of the message body, and the rest is the message body. If you like, the protocol header will also put some commonly used attributes. The Header of the Http protocol is the protocol header, such as content-type,content-length, etc. You can refer to Netty's DelimiterBasedFrameDecoder.

Dubbo communicates through custom protocols. The format of the protocol header is as follows

The meaning of each bit is as follows

Why should Dubbo customize the protocol instead of the ready-made Http protocol?

The main reason is that custom protocols can improve performance.

The request packet of Http protocol is relatively large and has a lot of useless content. Custom protocols can simplify a lot of content.

The Http protocol is stateless and reestablishes the connection every time, and closes the connection after the response is completed.

Serialization

The content of the protocol header is represented by bits, and the protocol body is encapsulated into objects in the application. For example, Dubbo encapsulates the request into Request and the response into Response.

As we said earlier, the data transmitted over the network must be binary data, but the input parameters of the caller and the return values of the provider are objects, so the process of serialization and deserialization is required.

There are several ways to serialize

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

JDK native serialization

JSON

Protobuf

Kryo

Hessian2

MessagePack

When we choose the way to serialize, we mainly consider the following factors

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Efficiency

Space overhead

Versatility and compatibility

Security.

communication

There are four common IO models

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Synchronous blocking IO (Blocking IO)

Synchronous non-blocking IO (Non-blocking IO)

IO Multiplexing (IO Multiplexing)

Asynchronous IO (Asynchronous IO)

Because RPC is generally used in high concurrency scenarios, we choose this model of IO multiplexing. IO multiplexing of Netty is based on the Reactor development pattern. In the following articles, I will analyze how this development pattern supports high concurrency.

Registration center

The function of the registry is similar to that of the phone book. The mapping relationship between the service name and the specific service address is saved. When we want to communicate with a service, we only need to look up the address of the service according to the service name.

More importantly, the phone book is dynamic. When the address of a service changes, the address in the phone book will change. When a service is not available, the address in the phone book will disappear.

This dynamic phone book is the registry.

There are many ways to implement a registry, such as Zookeeper,Redis,Nocas.

Introduce the way to implement the registry with Zookeeper

Zookeeper has two types of nodes, persistent nodes and temporary nodes

When we register the service with zookeeper, we use a temporary node so that when the service is disconnected, the node can be deleted

The node type explains that the persistent node creates the node as a persistent node, and the data will always be stored on the zookeeper server. Even if the session between the client creating the node and the server is closed, the node will not be deleted. The persistent sequence node adds the ordered characteristics of the node to the persistent node. The temporary node creates the node as a temporary node, and the data is not always stored on the zookeeper server. When the client session that created the temporary node closes, the node is deleted on the corresponding zookeeper server. The temporary order node adds the ordered feature of the node on the basis of the temporary node.

How do I communicate when the registration center is all dead?

When a zookeeper dies, it automatically switches to another zookeeper. It's okay to hang up all, because dubbo keeps a copy of the mapping locally, which can be saved in Map or in a file.

If the new service is registered with the registry, will the local cache be updated?

If you register for monitoring, of course it will be updated. When the listening node or child node changes, the corresponding content will be pushed to the listening client, and you can update the local cache.

The events in Zookeeper are as follows

You can think of this monitoring as a distributed observer mode.

This is the end of the "handwritten method tutorial of a RPC Framework". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.