Data processing method and device for microservice, equipment and readable storage medium

Abstract

The application discloses a data processing method and device for microservices, equipment and a readable storage medium. The method comprises the following steps: determining a target persistent interface from each persistent interface of a first microservice; wherein the persistent interface is used for storing interface data into a local database; determining a first storage object for storing interface data into the local database from the target persistent interface; constructing a second storage object based on the first storage object, and storing the interface data into a preset shared database and the local database through the second storage object; and the application can more conveniently realize data sharing between each microservice.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of data processing, in particular to a data processing method and device for microservices, equipment and readable storage medium. BACKGROUND

[0002] Microservices mainly adopts domain-driven design (Domain-driven design, DDD for short), divides an application into multiple independent domains, and each independent domain can become a separate service. By adopting microservice architecture, the flexibility and scalability of the application can be significantly improved, but this brings a problem: it is difficult to share data between different microservices. In order to solve this problem, the following five ways are usually used in the prior art: way one, extra development services to solve the cross-service data sharing problem; way two, use data warehouse to solve data sharing; way three, use redundant data in the service, keep the data that needs to be shared in the application using additional attributes when modeling, so that these redundant data can meet the data sharing requirement; way four, directly access the database of the other party; way five, use database middleware; however, the above five ways have the following disadvantages: for way one, customized development is required, there is no general type, and each service data model change must be followed, otherwise data inconsistency will occur; for way two, data warehouse is generally used for enterprise level, and it is too heavy, costly and slow to see effect to solve the single application system; for way three, the amount of data that can be redundant in the service is limited, otherwise the system performance will be affected; for way four, it will lead to complex application configuration, and will cause the data model of the local service to be tightly coupled with other services, and if the data model of the other party changes, the defined query statement may not be executed; for way five, the database middleware also has the problem of tight coupling with the data model of other services.

[0003] Therefore, how to more conveniently realize data sharing between microservices has become a technical problem to be solved by those skilled in the art. SUMMARY

[0004] The purpose of the present application is to provide a data processing method, device and equipment for microservices, and readable storage medium, which can more conveniently realize data sharing between microservices.

[0005] According to one aspect of the present application, a data processing method for microservices is provided, the method comprising:

[0006] determining a target persistence interface from each persistence interface of a first microservice; wherein the persistence interface is used to store interface data into a local database;

[0007] determining a first storage object for storing interface data into a local database from the target persistence interface;

[0008] constructing a second storage object based on the first storage object, and storing interface data into a preset shared database and the local database respectively through the second storage object.

[0009] Optionally, the determining of the target persistence interface from the Repository interfaces of the first microservice specifically comprises:

[0010] scanning Repository interfaces of the first microservice when detecting that the first microservice built by using Spring Boot is started;

[0011] setting the Repository interface added with a preset shared annotation as a target Repository interface.

[0012] Optionally, the determining of the first storage object for storing interface data into a local database from the target persistence interface specifically comprises:

[0013] scanning a variable using an Autowired annotation in the target Repository interface, and taking the variable as the first storage object.

[0014] Optionally, the constructing of the second storage object based on the first storage object, and the storing of interface data into a preset shared database and the local database respectively through the second storage object specifically comprises:

[0015] obtaining address information of the shared database;

[0016] forming a second storage object that inherits the first storage object and has a function of storing interface data into the shared database according to the address information;

[0017] replacing the first storage object in the target Repository interface with the second storage object.

[0018] Optionally, the method further comprises:

[0019] obtaining a query request for querying interface data in the first microservice generated by a second microservice;

[0020] determining a first query object for querying interface data from a local database from the target persistence interface;

[0021] obtaining address information of the shared database, and constructing a second query object based on the address information and the first query object;

[0022] acquiring interface data of the first microservice from the shared database according to the query request by using the second query object;

[0023] sending the acquired interface data to the second microservice.

[0024] Optionally, the method further comprises:

[0025] acquiring a query request for querying interface data in a third microservice generated by the first microservice;

[0026] judging whether the identification information of the third microservice exists in a preset permission list;

[0027] if yes, forwarding the query request to the third microservice according to address information of the third microservice in the permission list, so that the third microservice directly sends interface data for the query request to the first microservice.

[0028] In order to achieve the above-mentioned purpose, the application further provides a data processing device for microservice, the device comprises:

[0029] a screening module, configured to determine a target persistent interface from each persistent interface of a first microservice; wherein the persistent interface is used for storing interface data into a local database;

[0030] a first determining module, configured to determine a first storage object for storing interface data into a local database from the target persistent interface;

[0031] a processing module, configured to construct a second storage object based on the first storage object, and store interface data into a preset shared database and the local database through the second storage object.

[0032] Optionally, the device further comprises:

[0033] an acquiring module, configured to acquire a query request for querying interface data in the first microservice generated by a second microservice;

[0034] a second determining module, configured to determine a first query object for querying interface data from a local database from the target persistent interface;

[0035] a constructing module, configured to acquire address information of the shared database, and construct a second query object based on the address information and the first query object;

[0036] The query module is configured to acquire interface data of the first micro service from the shared database according to the query request by using the second query object.

[0037] The sending module is configured to send the acquired interface data to the second micro server.

[0038] In order to achieve the above-mentioned purpose, the present application further provides a computer device, which specifically comprises a memory, a processor and a computer program stored in the memory and executable on the processor, and the processor implements the steps of the above-mentioned data processing method for micro services when executing the computer program.

[0039] In order to achieve the above-mentioned purpose, the present application further provides a computer readable storage medium, which stores a computer program, and the computer program implements the steps of the above-mentioned data processing method for micro services when executed by a processor.

[0040] The data processing method, device and equipment for micro services and the computer readable storage medium provided by the present application can store the data that needs to be shared in micro services into a shared database through the modification of the persistent interface in the micro services, and can use the data shared by other micro services through the modified persistent interface, just like using the data in the local database, so that the data sharing between various micro services can be more conveniently realized. BRIEF DESCRIPTION OF DRAWINGS

[0041] Various other advantages and benefits will become apparent to those of ordinary skill in the art upon reading the following detailed description of the preferred embodiments. The accompanying drawings are included to provide a description of the preferred embodiments and are not intended to limit the scope of the application. Moreover, the same reference numerals are intended to denote the same components throughout the accompanying drawings. In the drawings:

[0042] Figure 1 An optional flowchart of the data processing method for micro services provided for embodiment one;

[0043] Figure 2 An optional flowchart of the data processing method for micro services provided for embodiment one;

[0044] Figure 3 An optional component structure diagram of the data processing device for micro services provided for embodiment three;

[0045] Figure 4 An optional hardware architecture diagram of the computer device provided for embodiment four. DETAILED DESCRIPTION

[0046] In order to make the objects, technical solutions and advantages of the present application clearer, the present application will be further described in detail below with reference to the drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and should not be used to limit the present application. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative labor fall within the scope of the present application.

[0047] Embodiment one

[0048] The embodiment of the present application provides a data processing method for microservices, as shown in the method specifically comprises the following steps: Figure 1

[0049] Step S101: determining a target persistence interface from each persistence interface of a first microservice; wherein the persistence interface is used to store interface data into a local database.

[0050] The microservice is a variant of a service-oriented architecture (SOA) architectural style in a software development technique, which advocates dividing a single application into a group of small microservices, and each microservice coordinates and cooperates with each other to provide the final function for users. In a microservice, there are multiple persistence interfaces for storing data, and through the persistence interface, the data generated in the interface can be stored into the database.

[0051] Specifically, step S101 comprises:

[0052] Step A1: when it is detected that the first microservice built by using Spring Boot is started, scanning each Repository interface of the first microservice;

[0053] The microservice developed by Spring Boot stores data into the database through Spring Boot JPA (Java Persistence API, Java Persistence API), and specifically, stores data into the database by using the Repository interface.

[0054] Step A2: setting the Repository interface added with a preset shared annotation as a target Repository interface;

[0055] The preset shared annotation is a Java annotation (Annotation) also known as Java annotation, which is an annotation mechanism introduced by JDK5.0; the annotation is commonly used to provide some compiler, compile-time and runtime instructions. It should be noted that the preset shared annotation is not a standardized annotation of Spring Boot itself. ​

[0056] In this embodiment, a preset sharing annotation is added to the Repository interface of the microservice in advance to enable targeted data sharing.

[0057] Step S102: Determine a first storage object from the target persistent interface for storing interface data in a local database.

[0058] In each persistence interface, a storage class for data storage and a query class for data retrieval are set in advance. When data storage is required, the storage class is instantiated as a storage object, and when data retrieval is required, the query class is instantiated as a query object.

[0059] Specifically, step S102 includes:

[0060] The variables annotated with Autowired are scanned in the target Repository interface and used as the first storage object.

[0061] The first storage object is used to store the interface data generated in the target Repository interface into the corresponding local database; it should be noted that the Autowired annotation is a standardized annotation of Spring Boot itself.

[0062] Step S103: Construct a second storage object based on the first storage object, and store the interface data in the preset shared database and the local database respectively through the second storage object.

[0063] like Figure 2 As shown, in this embodiment, the second storage object not only inherits all the functions of the first storage object, but also provides the function of storing data in a shared database. This embodiment modifies the original persistent interface used for storing data, so that the modified persistent interface can not only store data in a local database, but also store data in a shared database.

[0064] Specifically, step S103 includes:

[0065] Step B1: Obtain the address information of the shared database;

[0066] Step B2: Form a second storage object that inherits from the first storage object and has the function of storing interface data into the shared database according to the address information;

[0067] Step B3: Replace the first storage object in the target Repository interface with the second storage object.

[0068] By replacing the first storage object in the target Repository interface with the second storage object, subsequent use of the target Repository interface can store data generated in the target Repository interface in both the local database and the shared database, thereby achieving data sharing for the first microservice.

[0069] Further, the method further comprises:

[0070] Step C1: obtaining a query request for querying interface data in the first microservice generated by the second microservice;

[0071] Step C2: determining a first query object for querying interface data from the local database from the target persistence interface;

[0072] Preferably, the first query object is determined from the target Repository interface;

[0073] Step C3: obtaining address information of the shared database, and constructing a second query object based on the address information and the first query object;

[0074] In this embodiment, the second query object inherits the data query function of the first query object, and by modifying the original persistence interface, the modified persistence interface can query data from the shared database;

[0075] Step C4: obtaining interface data of the first microservice from the shared database according to the query request using the second query object;

[0076] Step C5: sending the obtained interface data to the second microservice;

[0077] In this embodiment, not only can the data of the microservice be stored in the shared database through the modified persistence interface, but also the data in the shared database can be shared to other microservices. When querying data, Filter filtering logic can be generated according to the query request, and data can be queried from the shared database according to the generated Filter filtering logic.

[0078] Further, the method further comprises:

[0079] Step D1: obtaining a query request for querying interface data in the third microservice generated by the first microservice;

[0080] Step D2: determining whether the identification information of the third microservice exists in the preset permission list;

[0081] If yes, the query request is forwarded to the third microservice according to the address information of the third microservice in the permission list, so that the third microservice directly sends interface data for the query request to the first microservice.

[0082] In the embodiment, for the microservice which does not want to share data to the shared database, i.e. for the microservice existing in the permission list, the data exchange can also be performed in the manner of steps D1 to D3 described above. It should be noted that if the identification information of the third microservice does not exist in the preset permission list, the interface data of the third microservice is acquired from the shared database according to the query request in the manner of steps C1 to C5 described above, and the acquired interface data is sent to the first microservice.

[0083] As shown in Figure 2 In the embodiment, the data which needs to be shared in the microservice can be stored in the shared database by modifying the persistent interface in the microservice, and other microservices can use the data shared by other microservices like using the data in the local database through the modified persistent interface. The embodiment can more conveniently realize the data sharing between the microservices.

[0084] Embodiment two

[0085] The embodiment of the application provides a data processing method for a microservice, which is applied to a Datahub data bus adopting a Client-Server (client-server) architecture, wherein the client Client acts as a jar package for each microservice locally, and the server Server acts as a service and is independently run, and the method specifically comprises the following steps:

[0086] Step S301: a first microservice sends a storage request to a first client Client;

[0087] The first client Client is arranged on the first microservice.

[0088] Step S302: the first client Client determines a target persistent interface from each persistent interface of the first microservice; wherein the persistent interface is used for storing interface data into a local database;

[0089] Specifically, step S302 comprises:

[0090] The first client Client scans each Repository interface of the first microservice, and sets the Repository interface added with a preset shared annotation as a target Repository interface.

[0091] Step S303: The first client Client determines a first storage object for storing interface data to a local database from the target persistence interface;

[0092] Specifically, step S303 includes:

[0093] The first client Client scans a variable using an Autowired annotation in the target Repository interface, and takes the variable as the first storage object.

[0094] Step S304: The first client Client constructs a second storage object based on the first storage object, and sends interface data to the server Server through the second storage object;

[0095] Specifically, step S304 includes:

[0096] The first client Client obtains address information of the server Server;

[0097] The first client Client forms a second storage object that inherits the first storage object and has the address information of the server Server to send interface data to the server Server;

[0098] The first client Client replaces the first storage object in the target Repository interface with the second storage object.

[0099] Step S305: The server Server stores the received interface data of the first microservice to a shared database.

[0100] Further, the method further includes:

[0101] Step S306: The first microservice sends a query request for querying interface data of a second microservice to the first client Client.

[0102] Step S307: The first client Client determines a first query object for querying interface data from a local database from the target persistence interface.

[0103] Step S308: The first client Client obtains address information of the server Server, and constructs a second query object based on the address information and the first query object.

[0104] Step S309: The first client Client sends the query request to the server Server by using the second query object.

[0105] Step S310: The server Server judges whether the identification information of the second microservice exists in the preset permission list, if yes, step S311 is executed, if not, step S312 is executed.

[0106] Step S311: The server Server forwards the query request to the second microservice according to the address information of the second microservice in the permission list, so that the second microservice sends the interface data for the query request to the first microservice directly.

[0107] Step S312: The server Server obtains the interface data of the second microservice from the shared database according to the query request.

[0108] Step S313: The server Server sends the obtained interface data to the first client Client.

[0109] Step S314: The first client Client sends the received interface data to the first microservice.

[0110] Embodiment three

[0111] The embodiment of the application provides a data processing device for a microservice, as shown in the figure, which specifically comprises the following components: Figure 3

[0112] The screening module 301 is used for determining a target persistence interface from each persistence interface of the first microservice; wherein the persistence interface is used for storing interface data into a local database;

[0113] The first determination module 302 is used for determining a first storage object for storing interface data into a local database from the target persistence interface.

[0114] The processing module 303 is used for constructing a second storage object based on the first storage object, and storing interface data into a preset shared database and the local database through the second storage object.

[0115] Specifically, the screening module 301 is used for:

[0116] When it is detected that the first microservice built by using Spring Boot is started, scanning each Repository interface of the first microservice;

[0117] ​Set the Repository interface added with the preset shared annotation as a target Repository interface.

[0118] Specifically, the first determining module 302 is configured to:

[0119] Scan out a variable using the Autowired annotation in the target Repository interface, and take the variable as the first storage object.

[0120] Specifically, the processing module 303 is configured to:

[0121] Obtain address information of the shared database.

[0122] Form a second storage object that inherits the first storage object and has the function of storing interface data in the shared database according to the address information.

[0123] Replace the first storage object in the target Repository interface with the second storage object.

[0124] Further, the apparatus further comprises:

[0125] The obtaining module is configured to obtain a query request for querying interface data in the first microservice generated by a second microservice.

[0126] The second determining module is configured to determine a first query object for querying interface data from a local database from the target persistence interface.

[0127] The constructing module is configured to obtain address information of the shared database, and construct a second query object based on the address information and the first query object.

[0128] The querying module is configured to obtain interface data of the first microservice from the shared database according to the query request by using the second query object.

[0129] The sending module is configured to send the obtained interface data to the second microservice.

[0130] Further, the apparatus further comprises:

[0131] The judging module is configured to obtain a query request for querying interface data in a third microservice generated by the first microservice; judge whether the identification information of the third microservice exists in a preset permission list; if yes, forward the query request to the third microservice according to address information of the third microservice in the permission list, so that the third microservice directly sends interface data for the query request to the first microservice.

[0132] Embodiment Four

[0133] The embodiments also provide a computer device, such as a smartphone, a tablet computer, a notebook computer, a desktop computer, a rack server, a blade server, a tower server, or a rack-mounted server (including a single server or a server cluster composed of multiple servers), etc. that can execute programs. As shown in the figure, the computer device 40 of the embodiments at least includes, but is not limited to, a memory 401 and a processor 402 that can be connected to each other through a system bus. It should be noted that, Figure 4 Figure 4 Only the computer device 40 with the components 401-402 is shown, but it should be understood that all the shown components are not required to be implemented, and more or fewer components can be alternatively implemented.

[0134] In the embodiments, the memory 401 (i.e., a readable storage medium) includes a flash memory, a hard disk, a multimedia card, a card-type memory (e.g., an SD or DX memory, etc.), a random access memory (RAM), a static random access memory (SRAM), a read-only memory (ROM), an electrically erasable programmable read-only memory (EEPROM), a programmable read-only memory (PROM), a magnetic memory, a magnetic disk, an optical disk, etc. In some embodiments, the memory 401 can be an internal storage unit of the computer device 40, such as a hard disk or a memory of the computer device 40. In other embodiments, the memory 401 can also be an external storage device of the computer device 40, such as a plug-in hard disk, a smart media card (SMC), a secure digital (SD) card, a flash card, etc. equipped on the computer device 40. Of course, the memory 401 can also include both the internal storage unit and the external storage device of the computer device 40. In the embodiments, the memory 401 is generally used to store an operating system and various application software installed on the computer device 40. In addition, the memory 401 can also be used to temporarily store various data that have been output or will be output.

[0135] The processor 402 can be a central processing unit (CPU), a controller, a microcontroller, a microprocessor, or other data processing chip for microservices in some embodiments. The processor 402 is generally used to control the overall operation of the computer device 40.

[0136] Specifically, in the embodiments, the processor 402 is configured to execute a program of a data processing method for microservices stored in the memory 401, and the program of the data processing method for microservices, when executed, implements the following steps: ​

[0137] determining a target persistence interface from the persistence interfaces of the first microservice, wherein the persistence interface is used to store interface data into a local database;

[0138] determining a first storage object for storing interface data into a local database from the target persistence interface;

[0139] constructing a second storage object based on the first storage object, and storing interface data into a preset shared database and the local database through the second storage object.

[0140] The specific embodiment process of the above method steps can be referred to Embodiment One, which will not be repeated here.

[0141] Embodiment Five

[0142] The embodiment also provides a computer readable storage medium, such as a flash memory, a hard disk, a multimedia card, a card memory (for example, an SD or DX memory, etc.), a random access memory (RAM), a static random access memory (SRAM), a read-only memory (ROM), an electrically erasable programmable read-only memory (EEPROM), a programmable read-only memory (PROM), a magnetic memory, a magnetic disk, an optical disk, a server, an App application store, etc., which stores a computer program, and the computer program is executed by a processor to implement the following method steps:

[0143] determining a target persistence interface from the persistence interfaces of the first microservice, wherein the persistence interface is used to store interface data into a local database;

[0144] determining a first storage object for storing interface data into a local database from the target persistence interface;

[0145] constructing a second storage object based on the first storage object, and storing interface data into a preset shared database and the local database through the second storage object.

[0146] The specific embodiment process of the above method steps can be referred to Embodiment One, which will not be repeated here.

[0147] It should be noted that, in this text, the term "comprising", "including" or any other variant thereof is intended to cover non-exclusive inclusion, so that the process, method, article or device including a series of elements not only includes those elements, but also includes other elements not explicitly listed, or includes elements inherent to such process, method, article or device. Without more limitations, the element defined by the statement "including a" does not exclude the presence of other identical elements in the process, method, article or device including the element.

[0148] The above-mentioned embodiment numbers of the application are only for description, not representing the advantages and disadvantages of the embodiments.

[0149] Through the above description of the embodiments, those skilled in the art can clearly understand that the above-mentioned embodiment methods can be realized by software and the necessary general hardware platform, of course, they can also be realized by hardware, but in many cases the former is a better embodiment.

[0150] The above is only the preferred embodiment of the application, and does not limit the patent scope of the application, any equivalent structure or equivalent process transformation using the content of the application specification and drawings, or direct or indirect application in other related technical fields, are also included in the patent protection scope of the application.

Claims

1. A data processing method for microservices, characterized in that, The method comprises: determining a target persistence interface from each persistence interface of the first microservice, wherein the persistence interface is used to store interface data into a local database; determining a first storage object for storing interface data into the local database from the target persistence interface; constructing a second storage object based on the first storage object, and storing interface data into a preset shared database and the local database through the second storage object; wherein the target persistence interface is determined from each persistence interface of the first microservice, specifically comprising: scanning each Repository interface of the first microservice when detecting that the first microservice built using Spring Boot is started; setting the Repository interface added with a preset shared annotation as a target Repository interface; the first storage object is constructed into a second storage object based on the first storage object, and interface data is stored into a preset shared database and the local database through the second storage object, specifically comprising: obtaining address information of the shared database; forming a second storage object which inherits the first storage object and has the function of storing interface data into the shared database according to the address information; replacing the first storage object in the target Repository interface with the second storage object.

2. The data processing method for microservices according to claim 1, wherein, the first storage object is determined from the target persistence interface for storing interface data into the local database, specifically comprising: scanning a variable using an Autowired annotation in the target Repository interface, and taking the variable as the first storage object.

3. The data processing method for microservices of claim 1, wherein, The method further comprises: obtaining a query request for querying interface data in the first microservice generated by a second microservice; determining a first query object for querying interface data from the local database from the target persistence interface; obtaining address information of the shared database, and constructing a second query object based on the address information and the first query object; obtaining interface data of the first microservice from the shared database according to the query request by using the second query object; sending the obtained interface data to the second microservice.

4. The data processing method for microservices of claim 1, wherein, The method further comprises: obtaining a query request for querying interface data in a third microservice generated by the first microservice; judging whether the identification information of the third microservice exists in a preset permission list; if yes, forwarding the query request to the third microservice according to the address information of the third microservice in the permission list, so that the third microservice sends interface data for the query request directly to the first microservice.

5. A data processing apparatus for microservices, characterized in that, The device comprises: a screening module for determining a target persistence interface from each persistence interface of the first microservice, wherein the persistence interface is used to store interface data into a local database; a first determination module for determining a first storage object for storing interface data into the local database from the target persistence interface; The processing module is configured to construct a second storage object based on the first storage object, and store interface data into a preset shared database and the local database respectively through the second storage object. The screening module is specifically configured to: scan each Repository interface of the first microservice when detecting that the first microservice built by using Spring Boot is started; set the Repository interface added with the preset shared annotation as a target Repository interface; The processing module is specifically configured to: obtain address information of the shared database; form a second storage object which inherits the first storage object and has the interface data stored into the shared database according to the address information; replace the first storage object in the target Repository interface with the second storage object.

6. The data processing apparatus for microservices according to claim 5, wherein, The device further comprises: an obtaining module configured to obtain a query request for querying interface data in the first microservice generated by a second microservice; a second determining module configured to determine a first query object for querying interface data from a local database from the target persistence interface; a constructing module configured to obtain address information of the shared database, and construct a second query object based on the address information and the first query object; a querying module configured to obtain interface data of the first microservice from the shared database according to the query request by using the second query object; a sending module configured to send the obtained interface data to the second microservice.

7. A computer device comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the steps of the method in any one of claims 1 to 4 when executing the computer program.

8. A computer-readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor to implement the steps of the method in any one of claims 1 to 4.

Images