WO2022222442A1

WO2022222442A1 - Method for client to dynamically call server by means of grpc

Info

Publication number: WO2022222442A1
Application number: PCT/CN2021/129976
Authority: WO
Inventors: 张金亮; 高明慧; 张志军; 何纪成; 卢楷; 郭乃豪; 王洋; 王坤; 杨兰; 陈冬冬; 赵航; 马志勇; 刘进国; 李歌; 冯绍辉; 唐尧; 沙鑫
Original assignee: 北京科东电力控制系统有限责任公司
Priority date: 2021-04-20
Filing date: 2021-11-11
Publication date: 2022-10-27
Also published as: CN113515319A; CN113515319B

Abstract

Disclosed is a method for a client to dynamically call a server by means of a gRPC, comprising: a server configures a preset adaptive JAR package, the adaptive JAR package comprising a Java item, a gRPC module and a gRPC interface, supporting the bidirectional flow of a gRPC and upgrading a core class to a springboot-starter means, and the gRPC interface being an entry which may be dynamically called by the server on the premise that a code of the server is not invasive; and the client sends a call request to the server and receives response data sent by the server, so as to complete the method for a client to dynamically call a server by means of a gRPC. In the present invention, the cost of both a client and a server maintaining a protocol file may be saved, the calling of the client and the server may be achieved while not introducing a gRPC interface package, working costs of personnel may be reduced, and bugs generated by synchronizing the protocol file are reduced.

Description

A method for the client to dynamically call the server through GRPC

technical field

The invention belongs to the technical field of security protection communication security of a power monitoring system, and in particular relates to a method for a client to dynamically call a server through GRPC.

Background technique

Nowadays, driven by the demand of the software ecosystem, distributed has become a common topic. In a distributed environment, in order to bridge the communication between various services, RPC technology came into being. thrift, grpc, dubbo, dubbox, motan, etc.

With the continuous increase in the number of projects designed for the power monitoring network security system, the continuous increase in business requirements, and the continuous increase in the number of grpc interfaces, which means that the content of the grpc protocol file is also increasing, which provides maintenance clients and servers. The project personnel bring certain work costs. The synchronization of the grpc protocol file has become the focus of each project joint debugging, and there are many bugs that should not exist due to the synchronization of the protocol file.

Nowadays, driven by the continuous demand of the software ecosystem, distributed has become a common topic. In a distributed environment, in order to bridge the communication between various services, RPC (Remote Procedure Call) technology came into being, mainly including thrift, grpc, dubbo, dubbox, motan, etc. In the RPC framework, one of the important components of the serialization protocol is to serialize and deserialize the transmitted binary data. For a statically compiled language like java, the advantage is that it is completely object-oriented development. Both ends of the communication need to define the interface protocol in advance, output the file, compile the file into a java file, and import the file from the server, aiming at the protocol interface. Provide function implementation. The client introduces this file, fills in the specified type parameters, and makes a call, thereby realizing the entire link of the GRPC call, see Figure 1 for details.

Before calling any interface of the server, the client must know the definition of the interface, that is, the protocol file. The problems it faces include: (1) The client and the server maintain the protocol files at the same time, and whether the file synchronization is timely. (2) When the client wants to call the server, it must know the protocol file in advance and do a lot of repetitive work.

SUMMARY OF THE INVENTION

In view of the above problems, the present invention proposes a method for the client to dynamically call the server through GRPC, which can save the cost of jointly maintaining the protocol file by both the client and the server, and can also realize the client and the service without introducing the grpc interface package. The call of the terminal reduces the work cost of personnel and reduces the bugs caused by synchronizing the protocol files.

In order to realize the above-mentioned technical purpose and achieve the above-mentioned technical effect, the present invention is realized through the following technical solutions:

A method for the client to dynamically call the server through GRPC, including:

The server configures a preset adaptation jar package, the adaptation jar package includes a java project, a grpc module, a grpc interface, supports GRPC bidirectional flow and upgrades the core class to the springboot-starter mode, and the grpc interface provides the service The entry that can be dynamically called by the server under the premise that the terminal code is non-intrusive;

The client sends a call request to the server, and accepts the response data sent by the server to complete the method that the client dynamically calls the server through GRPC.

Optionally, the implementation method of the adaptation jar package includes:

Build a java project using the java integration framework springboot;

Use spring-ioc and JDK reflection mechanism to implement request routing;

Using the springboot-starter mode, the core class is made into a switch configuration and introduced into the spring environment, so that the original code is non-invasive and can be used out of the box.

Optionally, the method for implementing the adaptation jar package specifically includes the following steps:

Build the java project framework;

Integrate GRPC framework;

Carry out the logic development of the adaptation jar package.

Optionally, the building a java project framework specifically includes the following steps:

Select the jdk development version of java;

Adopt springboot integration framework;

Use Maven to build projects and introduce third-party dependencies.

Optionally, the fusion GRPC framework specifically includes the following steps:

Import GRPC dependencies;

Write a GRPC protocol file. Only one Service is defined in the file, and only one interface to be implemented is provided in the Service.

Optionally, the logical development of the adaptation jar package specifically includes the following steps:

Create a java implementation class that inherits the interface protocol class of the interface. Only by inheriting the specified interface protocol class can the request be forwarded to the specific implementation class when the client calls the protocol interface;

Write dynamic calling logic in the implementation method body of the interface;

The interface is automatically registered in the GRPC interface registration list.

Optionally, the specific process of configuring the preset adaptation jar package by the server is as follows:

The server side introduces the jar package. If it is a maven project, the pom dependency is introduced, and the core class of the jar package is injected into the spring environment.

Compared with the prior art, the beneficial effects of the present invention:

Based on the power monitoring network security system architecture, the invention uses the characteristics of java language to create an adaptation jar package, and links the grpc client and server server together without the constraints of the proto file protocol, so that the grpc client You can access any server-side interface. It solves the problem that the grpc client needs to import the specified proto file or the package compiled by the proto file when calling the server, and also solves the problem that the proto file is synchronized between the client and the server respectively. The development process is simplified, the workload is reduced, and the project risk is reduced.

Description of drawings

In order to make the content of the present invention easier to be understood clearly, the present invention will be described in further detail below according to specific embodiments and in conjunction with the accompanying drawings, wherein:

FIG. 1 is a frame diagram of a method for a client to dynamically call a server through GRPC in the present invention.

Detailed ways

In order to make the objectives, technical solutions and advantages of the present invention clearer, the present invention will be further described in detail below with reference to the embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention, and are not used to limit the protection scope of the present invention.

The application principle of the present invention will be described in detail below with reference to the accompanying drawings.

The present invention provides a method for a client to dynamically call a server through GRPC, which specifically includes the following steps:

(1) The server configures a preset adaptation jar package, the adaptation jar package includes a java project, a grpc module, a grpc interface, supports GRPC bidirectional flow and upgrades the core class to the springboot-starter mode, and the grpc interface is Provide an entry that can be dynamically called by the server without being intrusive to the server code;

(2) The client sends a call request to the server, and accepts the response data sent by the server to complete the method of dynamically calling the server by the client through GRPC.

The method for dynamically invoking the server through GRPC by the client in the present invention will be described in detail below with reference to FIG. 1 and a specific implementation process.

1. Develop and adapt jar package

Adapting the jar package is the core part of the whole invention

The purpose of adapting the jar package is to provide an entry that can be dynamically invoked by the server without being intrusive to the server code.

The specific implementation method of adapting the jar package is: using the java integration framework springboot to build a java project; using spring-ioc and JDK reflection mechanism to implement request routing; using the springboot-starter mode to make the core class into a switch configuration and introduce it into the spring environment to achieve this There is no intrusion to the original code, and it can be used out of the box.

Adapt the usage of the jar package: the server introduces the jar package, if it is a maven project, then the pom dependency is introduced, and the core class of the jar package is injected into the spring environment.

The development of the adaptation jar package is divided into three steps. The first step is to build the java project framework, the second step is to integrate the GRPC framework, and the third step is to develop the main logic of the adaptation package.

The following is the specific implementation method:

Step 1: Build the java project framework:

1.1 Developed based on jdk1.8 version

Select the jdk development version of java, here select jdk1.8.

1.2 Adopt springboot integration framework

Springboot can quickly build and start a java project, built-in startup container, and the Springboot framework integrates many common components, such as database jdbc, redis, etc. And after the project is packaged into a jar package, the startup method can be started directly through java-jar, which is convenient and fast.

1.3 Use Maven to build projects and introduce third-party dependencies

Maven is a component for managing java projects. It does not need to download and import the external packages that the project depends on. It provides automatic loading through the configuration file (pom.xml).

Step 2: Integrate the GRPC framework:

In the current environment, GRPC is used as a way of remote process interaction between projects, and this article is also a dynamic call based on GRPC, so it is necessary to introduce the created java project into the GRPC framework, and write and implement the code required by GRPC.

2.1 Import GRPC dependencies

In the project's pom.xml (Maven's configuration file), introduce the relevant maven dependencies of GRPC on the java language, grpc-protobuf, protobuf-java-util, grpc-netty, grpc-stub and protobuf-maven-plugin components, these dependencies support The java project integrates the grpc framework, and completes the creation and compilation of the .proto protocol file.

2.2 Write GRPC protocol file (protobuf file)

Create a grpc protocol file, a .proto file. Only one Service is defined in this file, and only one interface to be implemented is provided in the Service (this interface is the only entry for the client to access the server), and the interface name is Caller(Parameters param) returns Object , param is used as the input parameter. The parameter contains the bean name of the target class to be called in spring, the name of the target method to be called, and the input parameter of the target method to be called. Configure the grpc protocol file path in the project's pom.xml file. When the project is executing the compilation action, the grpc protocol file is compiled into a java file and marked into a jar for project introduction and code invocation.

Step 3 The main logic development of the adaptation package:

This step is mainly divided into three small steps. The first step is to implement the protocol interface in Section 2.2. The second step is to write the main dynamic calling logic in the interface implementation method body. The third step is to automatically register the interface in the GRPC interface registration list.

3.1 Implement the protocol interface in step 2.2

Create a java implementation class to inherit the interface protocol class generated after compiling the interface protocol in Section 2.2. Only if the specified interface protocol class is inherited, the client can forward the request to the specific implementation class when the client calls the protocol interface.

3.2 Write the main dynamic calling logic in the interface implementation method body

This step is mainly divided into three points. The first point is to parse the method input parameters, the second point is to route the parsed value to the target class and method, and the third point is to call the target class and method through reflection.

The first point, parsing method input parameters

The method input parameters mainly include the class name of the target (the method actually called by the client), the name of the target method, and the parameters of the target method.

The second point is to route to the target class and method through the parsed value

Since the adaptation jar package can take effect after it is introduced into the server, it means that the adaptation package can obtain the context of the internal environment of the server. The context of the internal environment of the java project generally refers to the context of the Spring environment. Then, you can Using the context of the Spring environment to find the target class and method through the parsed value mainly depends on the principle and API of Spring IOC.

The third point, call the target class and method through reflection

Since Java is a statically compiled language, the specified API cannot be used after dynamically capturing the target. Therefore, after obtaining the real target class and method, use the reflection mechanism of Java to call the target class and method to obtain the return value.

3.3 Automatically register the interface to the GRPC interface registration list

In order to simplify the operation of the server after introducing the adaptation package and reduce the intrusiveness to the server code, the operation of registering the interface in the server GRPC interface registration list is changed to automatic registration, that is, the main server introduces the adaptation package , when the server starts, the interface is registered in the interface registration list by itself to provide external services.

The principle of this step is implemented by means of the spring-boot-autoconfigure package provided by the Springboot framework.

2. The server project introduces the adaptation jar package

Take the java project managed by Maven as an example

The server project pom.xml file introduces the adaptation jar

3. The client project introduces the GRPC protocol file

The client needs to call the server through the GRPC interface. This interface is the protocol interface defined in step 2.2, so the client needs to import the compiled file of the interface protocol.

4. The client requests the server

Get the server address, build the GRPC client, call the protocol interface defined in step 2.2, the input parameters are the bean name of the target class in the server spring, the target method name, the target method input parameters, and start the request.

Applications

The following is combined with DataCenter, one of the projects running online, which is a data query and conversion business project, which contains hundreds of business interfaces. First, add the pom dependencies of the adaptation package to the pom file of DataCenter as follows:

Another data middle-end project is responsible for capturing data from various data sources and transmitting other data warehouses. The English name is Pier. Now the pom file in the Pier project is also added to the pom dependency of the adaptation package, as follows:

Configure the target service and method I want to request in the Pier project. This time, the configuration file is used, as follows:

Each part tag is a type of request, where name is the name of the part, which is unique; server is the name of the registry in the target service; bean is the name of the class where the target method is located; method is the target method; params is the target method parameter; Pier When the project starts the service, it reads the configuration file, integrates the parameters in the configuration file, and requests the Caller method of the target service (this method is the method in the adaptation package). The core method body is as follows:

After testing, the target method in the target server can be accessed normally according to the parameters in the configuration file.

At this point, a client based on the power monitoring network security system architecture dynamically communicates through GRPC.

The technology of calling the server has been completed.

The basic principles and main features of the present invention and the advantages of the present invention have been shown and described above. Those skilled in the art should understand that the present invention is not limited by the above-mentioned embodiments, and the descriptions in the above-mentioned embodiments and the description are only to illustrate the principle of the present invention. Without departing from the spirit and scope of the present invention, the present invention will have Various changes and modifications fall within the scope of the claimed invention. The claimed scope of the present invention is defined by the appended claims and their equivalents.

Claims

A method for a client to dynamically call a server through GRPC, comprising:

The server configures a preset adaptation jar package, the adaptation jar package includes a java project, a grpc module, a grpc interface, supports GRPC bidirectional flow and upgrades the core class to the springboot-starter mode, and the grpc interface provides the service The entry that can be dynamically called by the server under the premise that the terminal code is non-intrusive;

The client sends a call request to the server, and accepts the response data sent by the server to complete the method that the client dynamically calls the server through GRPC.
The method for dynamically invoking a server through GRPC by a client according to claim 1, is characterized in that:

The implementation method of the adaptation jar package includes:

Build a java project using the java integration framework springboot;

Use spring-ioc and JDK reflection mechanism to implement request routing;

Using the springboot-starter mode, the core class is made into a switch configuration and introduced into the spring environment, so that the original code is non-invasive and can be used out of the box.
The method for dynamically invoking a server through GRPC by a client according to claim 2, wherein the method for implementing the adaptation jar package specifically comprises the following steps:

Build the java project framework;

Integrate GRPC framework;

Carry out the logic development of the adaptation jar package.
The method for dynamically invoking a server by a client through GRPC according to claim 2, wherein the building a java project framework specifically includes the following steps:

Select the jdk development version of java;

Adopt springboot integration framework;

Use Maven to build projects and introduce third-party dependencies.
The method for dynamically invoking a server through GRPC by a client according to claim 2, wherein the integrated GRPC framework specifically comprises the following steps:

Import GRPC dependencies;

Write a GRPC protocol file. Only one Service is defined in the file, and only one interface to be implemented is provided in the Service.
The method for dynamically invoking a server through GRPC by a client according to claim 5, wherein the logical development of the adaptation jar package specifically includes the following steps:

Create a java implementation class that inherits the interface protocol class of the interface. Only by inheriting the specified interface protocol class can the request be forwarded to the specific implementation class when the client calls the protocol interface;

Write dynamic calling logic in the implementation method body of the interface;

The interface is automatically registered in the GRPC interface registration list.
The method for dynamically invoking a server by a client through GRPC according to claim 1, wherein the specific process of configuring a preset adaptation jar package on the server is as follows:

The server side introduces the jar package. If it is a maven project, the pom dependency is introduced, and the core class of the jar package is injected into the spring environment.