CN115185495A - Method, system, equipment and storage medium for splitting single application micro-service - Google Patents
Method, system, equipment and storage medium for splitting single application micro-service Download PDFInfo
- Publication number
- CN115185495A CN115185495A CN202210843226.2A CN202210843226A CN115185495A CN 115185495 A CN115185495 A CN 115185495A CN 202210843226 A CN202210843226 A CN 202210843226A CN 115185495 A CN115185495 A CN 115185495A
- Authority
- CN
- China
- Prior art keywords
- track
- service
- micro
- single application
- application
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3692—Test management for test results analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention belongs to the field of micro-service decoupling, and discloses a method, a system, equipment and a storage medium for splitting a single application micro-service, which comprises the steps of obtaining a monitoring log of a test case execution process of a single application to obtain a single application track; calling a FoSCI framework according to the monomer application track to obtain a monomer application splitting scheme; acquiring a monomer application source code, and splitting a monomer application according to the monomer application source code, a monomer application track and a monomer application splitting scheme to obtain a plurality of micro services; acquiring monitoring logs of the execution process of test cases of a plurality of micro services to obtain micro service tracks; comparing the single application track with the micro-service track to obtain track similarity, and outputting the split micro-service when the track similarity is greater than a preset threshold value; otherwise, obtaining and updating the current splitting scheme according to the splitting scheme after manual modification, and repeating the steps. The split micro-service forms a closed loop, a scheme is continuously optimized, and the split micro-service can be guaranteed to fall to the ground.
Description
Technical Field
The invention belongs to the field of micro-service decoupling, and relates to a method, a system, equipment and a storage medium for splitting a single application micro-service.
Background
Micro-services are small, autonomous services that work together. In a single application, some abstraction layers or modules are usually created to ensure the cohesiveness of the code, so as to avoid the difficult maintenance phenomenon caused by the increasing of the code base. The micro-service uses the concept of cohesiveness on an independent service, and the boundary of the service is determined according to the boundary of the service, so that the position where a certain function code should be placed can be easily determined, and because the service is concentrated in a certain boundary, a plurality of related problems caused by overlarge code base can be well avoided.
With the continuous development of micro services, the micro services are used more and more frequently in enterprises, and the capability of quickly and accurately implementing the splitting is a common expectation of micro service using enterprises. In this regard, much research has been done by the academia. At present, the splitting method is classified according to the selection mode of the splitting boundary, the micro-service splitting method comprises a data-driven method, a structure-driven method, a field-driven method and a method for extracting business logic according to track information to split, and the methods make certain contribution in the field of implementing automatic splitting of the micro-service.
However, there are still some problems with these current microservice splitting approaches. For example, the current micro-service splitting method can only split the micro-service, the work of realizing closed-loop optimization of the micro-service splitting scheme is very little, and after the splitting is implemented, more attention is paid to measuring the quality of the split scheme by using indexes, so that the split micro-service cannot be realized on the ground.
Disclosure of Invention
The invention aims to overcome the defect that the split micro-service cannot be guaranteed to be realized by landing after the split is implemented in the existing micro-service splitting scheme in the prior art, and provides a method, a system, equipment and a storage medium for splitting a single application micro-service.
In order to achieve the purpose, the invention adopts the following technical scheme to realize the purpose:
in a first aspect of the present invention, a method for splitting a single application microservice includes:
s1: acquiring a monitoring log of a test case execution process of the single application to obtain a single application track;
s2: calling a FoSCI framework according to the monomer application track to obtain a monomer application splitting scheme;
s3: acquiring a single application source code, and splitting single application according to the single application source code, the single application track and a single application splitting scheme to obtain a plurality of micro services;
s4: acquiring monitoring logs of the execution process of test cases of a plurality of micro services to obtain micro service tracks;
s5: comparing the single application track with the micro-service track to obtain track similarity, and outputting the split micro-service when the track similarity is greater than a preset threshold; otherwise, acquiring and updating the current splitting scheme according to the manually modified splitting scheme, and returning to the S3.
Optionally, the obtaining a monitoring log of a test case execution process of the monolithic application to obtain a monolithic application track includes:
monitoring the execution process of the test case of the single application based on a dynamic pile inserting technology to extract a monitoring log, and cleaning and filtering repeated data or noise data in the monitoring log to obtain single application track data;
formalizing the monomer application track data according to the following formula to obtain a monomer application track:
AT i ＝{a_trace_id i ，a_call_set i }
wherein, AT i For the ith track of the monolithic application track, a _ trace _ id i Number of i-th track, a _ call _ set, representing a track of monomer applications i Representing all calling relationship sets in the ith track of the single application track; a _ call _ set i ＝{ac 1 ，...，ac l ，...，ac k }; wherein k is the number of calling relations in the ith track of the single application track; ac l The first calling relation in the ith track of the single application track is obtained; ac l ＝(method1，method2，m1 para ，m2 para Class1, class2, m1_ return, and m2_ return), where method1 represents a source method name in the ith call relation, method2 represents a destination method name in the ith call relation, m1_ para represents an entry type of the source method in the ith call relation, m2_ para represents an entry type of the destination method in the ith call relation, class1 represents a class name where the source method in the ith call relation is located, class2 represents a class name where the destination method in the ith call relation is located, m1_ return represents a return value type of the source method in the ith call relation, and m2_ return represents a return value type of the destination method in the ith call relation.
Optionally, the calling the FoSCI framework according to the monomer application trajectory to obtain the monomer application splitting scheme includes:
converting the monomer application track according to the input requirement of the FoSCI framework and inputting the converted monomer application track into the FoSCI framework to obtain a monomer application splitting scheme;
the single application splitting scheme comprises an entity set SC and an interface set I:
SC＝{SC t }＝{service_name t ，entity_set t }
I＝{I t }＝{service_name t ，interface_set t }
wherein, service _ name t Denotes the name, entity _ set, of the t-th micro-service t Represents the set of all entities under the t-th microservice, entity _ set t ＝{entity 1 ，...，entity q Q represents the number of entities in the t-th microservice, entity q Name representing entity q in the tth microservice; interface _ set t Represents all interface _ sets under the tth micro-service t ＝{o 1 ，...，o n In which o n As the nth method, o n = oper, oper _ para, oper _ return, oper represents the method name of the nth method in the interface, oper _ para represents the entry parameter type of the nth method, and oper _ return represents the return value type of the nth method.
Optionally, the splitting the application of the single body according to the single body application source code, the single body application track, and the single body application splitting scheme includes:
creating a plurality of micro-service code directories according to an entity set in a single application splitting scheme, copying all contents in a single application source code to each micro-service code directory, taking a class which does not belong to the current micro-service in each micro-service code directory as a dummy class, clearing logics and annotations in all methods in the dummy class and injecting exceptions;
each micro service respectively creates a micro service tool class: the method comprises the steps of creating a code file for recording each piece of track information, a code file for serializing transmission data, a code file for acquiring the context of current application and a code file for managing micro-service objects;
determining an entry class of each micro service according to an interface set in the single application splitting scheme, and creating a service class of each micro service according to method information of the entry class of each micro service; creating a service registration class under each micro service, and registering the service class of the micro service in the service registration class;
expressing the calling relation in each track in the single application track as a result in a calling chain form to obtain a plurality of calling chains, and identifying the class nodes of cross-service in each calling chain by combining an entity set to obtain an agent class set under each micro-service; modifying the content of the proxy class set under each micro service so that the current micro service can communicate with the related micro service;
introduce configuration of an inter-service communication framework within a pom.xml file under each micro-service; and a configuration to inject a rest interface in a web.xml file under each microservice.
Optionally, the obtaining the monitoring logs of the test case execution processes of the multiple micro services to obtain the micro service trajectory includes:
according to the single application track, after method calling is carried out in the code of each micro service and a calling log is inserted into a place with a return value, each micro service is deployed on a server, the same test case as that in S1 is used for carrying out testing and acquisition of a monitoring log, and the micro service track is obtained:
MT i ＝{m_trace_id i ,m_call_set i }
wherein, MT i M _ trace _ id, the ith trace of the microservice trace i Number, m _ call _ set, of ith trace representing micro service trace i Representing all calling relationship sets in the ith trace of the micro service trace; m _ call _ set i ＝{mc1，...，mc l ，...，mc k }; wherein k is the number of calling relations in the ith trace of the micro-service trace, mc l The first calling relation in the ith track of the micro service track is obtained; mc of mc l ＝(method1，method2，ml para ，m2 para ，class1，class2，m1_return，m2-return)。
Optionally, the comparing the single application trajectory and the micro-service trajectory to obtain the trajectory similarity includes:
comparing the ith track of the single application track with the ith track of the micro-service track by the following formula:
len(a_call_set i )＝len(m_call_set i )
a_call_set i .ac k ＝m_call_set i .mc k
wherein len (a _ call _ set) i ) Calling the length of a relation set for the ith track of the single application track; len (m _ call _ set) i ) Calling the length of a relation set for the ith track of the micro-service track; a _ call _ set i .ac k Calling a kth calling relation in a relation set for the ith track of the single application track; m _ call _ set i .mc k Calling the kth calling relation in the relation set for the ith track of the micro-service track;
when the ith track of the single application track and the ith track of the micro service track meet the formula, the ith track of the single application track is consistent with the ith track of the micro service track; otherwise, inconsistency;
the trajectory similarity is obtained by: trajectory similarity = number of single application trajectories that are consistent with the number of trajectories in the microservice trajectory/total number of trajectories.
Optionally, the preset threshold is 90%.
In a second aspect of the present invention, a single application micro-service splitting system includes:
the single application track acquisition module is used for acquiring a monitoring log of the execution process of the test case of the single application to obtain a single application track;
the splitting scheme acquisition module is used for calling the FoSCI framework according to the single application track to obtain a single application splitting scheme;
the splitting module is used for acquiring the single application source codes and splitting the single application according to the single application source codes, the single application tracks and the single application splitting scheme to obtain a plurality of micro services;
the micro-service track acquisition module is used for acquiring monitoring logs of the test case execution process of a plurality of micro-services to obtain a micro-service track;
the verification module is used for comparing the single application track and the micro-service track to obtain track similarity, and outputting the split micro-service when the track similarity is greater than a preset threshold value; otherwise, acquiring and updating the current splitting scheme and triggering the splitting module according to the manually modified splitting scheme.
In a third aspect of the present invention, a computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor implements the steps of the single application micro-service splitting method when executing the computer program.
In a fourth aspect of the present invention, a computer-readable storage medium stores a computer program, which when executed by a processor, implements the steps of the monolithic application microservice splitting method described above.
Compared with the prior art, the invention has the following beneficial effects:
the method for splitting the single application micro-service comprises the steps of firstly extracting a single application running track by using a group of test cases, splitting the single application to generate a primary splitting scheme based on the running track, then splitting a single application code based on the primary splitting scheme to obtain a plurality of micro-services, realizing the flow from the splitting scheme to the code splitting of the single application, saving time cost and labor cost, then testing and extracting the running tracks of the plurality of micro-services by using the test cases consistent with the single application, comparing the extracted single application running track with the micro-service running track, and feeding back whether the splitting scheme is reasonable or not according to the comparison result. If the splitting scheme is unreasonable, the user can also customize and modify the splitting scheme and optimize the splitting result. The method for splitting the micro-service by the single body not only considers the generation of the split code, but also evaluates the rationality of the splitting scheme according to the result of the split code, so that the splitting work of the micro-service forms a closed loop, the scheme is continuously optimized, a satisfactory splitting result is finally generated, and the split micro-service can be realized on the ground.
Drawings
FIG. 1 is a flowchart of a method for splitting a single application microserver according to an embodiment of the present invention;
FIG. 2 is a flow diagram illustrating the sequence of cross-service invocation after monolithic application automation of an embodiment of the present invention;
fig. 3 is a block diagram of a split system of a single application microservice according to an embodiment of the present invention.
Detailed Description
In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be obtained by a person skilled in the art without making any creative effort based on the embodiments in the present invention, shall fall within the protection scope of the present invention.
It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
The invention is described in further detail below with reference to the accompanying drawings:
referring to fig. 1, in an embodiment of the present invention, a method for splitting a single application microservice is provided, where a single application source code and a dynamic running track are used to perform work of splitting and landing the microservice. Specifically, the monomer application micro-service splitting method comprises the following steps:
s1: acquiring a monitoring log of a test case execution process of the single application to obtain a single application track;
s2: calling a FoSCI framework according to the monomer application track to obtain a monomer application splitting scheme;
s3: acquiring a single application source code, and splitting single application according to the single application source code, the single application track and a single application splitting scheme to obtain a plurality of micro services;
s4: acquiring monitoring logs of the execution process of test cases of a plurality of micro services to obtain micro service tracks;
s5: comparing the single application track with the micro-service track to obtain track similarity, and outputting the split micro-service when the track similarity is greater than a preset threshold value; otherwise, acquiring and updating the current splitting scheme according to the manually modified splitting scheme and returning to the S3.
The method for splitting the single application micro-service comprises the steps of firstly extracting a single application running track by using a group of test cases, splitting the single application to generate a primary splitting scheme based on the running track, then splitting a single application code based on the primary splitting scheme to obtain a plurality of micro-services, realizing the flow from the splitting scheme to the code splitting of the single application, saving time cost and labor cost, then testing and extracting the running track of the plurality of micro-services by using the test cases consistent with the single application, comparing the extracted single application running track with the micro-service running track, and feeding back whether the splitting scheme is reasonable or not according to the comparison result. If the splitting scheme is unreasonable, the user can also customize and modify the splitting scheme and optimize the splitting result. The method for splitting the micro-service by the single body not only considers the generation of split codes, but also evaluates the rationality of a splitting scheme according to the result of splitting the codes, so that the splitting work of the micro-service forms a closed loop, the scheme is continuously optimized, a satisfactory splitting result is finally generated, and the split micro-service can be realized on the ground.
In a possible implementation manner, the obtaining a monitoring log of a test case execution process of a monolithic application to obtain a monolithic application track includes:
based on the dynamic pile inserting technology, the execution process of the test case of the single application is monitored to extract the monitoring log, and repeated data or noise data in the monitoring log are cleaned and filtered to obtain single application track data.
Formalizing the monomer application track data according to the following formula to obtain a monomer application track:
AT i ＝{a_trace_id i ，a_call_set i }
wherein, AT i For the ith track of the monolithic application track, a _ trace _ id i Number of i-th track, a _ call _ set, representing a track of monomer applications i Representing all calling relationship sets in the ith track of the single application track; a _ call _ set i ＝{ac 1 ，...，ac l ，...，ac k }; wherein k is in the ith track of the single application trackThe number of calling relations; ac l The first calling relation in the ith track of the single application track is obtained; ac l ＝(method1，method2，m1 para ，m2 para Class1, class2, m1_ return, m 2-return), where method1 represents a source method name in the ith call relation, method2 represents a destination method name in the ith call relation, m1_ para represents an entry type of the source method in the ith call relation, m2_ para represents an entry type of the destination method in the ith call relation, class1 represents a class name where the source method in the ith call relation is located, class2 represents a class name where the destination method in the ith call relation is located, m1_ return represents a return value type of the source method in the ith call relation, and m2_ return represents a return value type of the destination method in the ith call relation.
Specifically, based on the dynamic instrumentation technology, when the test case execution process of the single application is monitored to extract the monitoring log, a dynamic instrumentation tool Kieker can be adopted to insert monitoring codes in front of and behind the position of the single application needing monitoring, so as to realize dynamic monitoring of the function level codes. There are many duplicate or noisy data in the directly extracted monitoring log, which need to be cleared out of the data set, and then the trace data set of the cleared noisy data is formally represented.
In a possible embodiment, the calling the FoSCI framework according to the monomer application trajectory to obtain the monomer application splitting scheme includes: and (4) converting the monomer application track according to the input requirement of the FoSCI framework and inputting the converted monomer application track into the FoSCI framework to obtain a monomer application resolution scheme.
The single application splitting scheme comprises an entity set SC and an interface set I:
SC＝{SC t }＝{service_name t ，entity_set t }
I＝{I t }＝{service_name t ，interface_set t }
wherein, service _ name t Denotes the name, entity _ set, of the t-th microservice t Represents the set of all entities under the t-th microservice, entity _ set t ＝{entity 1 ，...，entity q Q represents the number of entities in the t-th microservice, entity q Name representing entity q in the tth microservice; interface _ set t Represents all interface sets under the t-th microservice, interface _ set t ＝{o 1 ，...，o n In which o is n As the nth method, o n = oper, oper _ para, oper _ return, oper represents the method name of the nth method in the interface, oper _ para represents the entry parameter type of the nth method, and oper _ return represents the return value type of the nth method.
In a possible embodiment, the splitting the monolithic application according to the monolithic application source code, the monolithic application track, and the monolithic application splitting scheme includes: creating a plurality of micro-service code directories according to an entity set in a single application splitting scheme, copying all contents in a single application source code to each micro-service code directory, taking a class which does not belong to the current micro-service in each micro-service code directory as a dummy class, clearing logics and annotations in all methods in the dummy class and injecting exceptions; creating a microservice tool class: the method comprises the steps of creating a code file for recording each piece of track information, a code file for serializing transmission data, a code file for acquiring the context of current application and a code file for managing micro-service objects; determining an entry class of each micro service according to an interface set in the single application splitting scheme, and creating a service class of each micro service according to method information of the entry class of each micro service; creating a service registration class under each micro service, and registering the service class of the micro service in the service registration class; expressing the calling relation in each track in the single application track as a result in a calling chain form to obtain a plurality of calling chains, and identifying the class nodes of cross-service in each calling chain by combining an entity set to obtain an agent class set under each micro-service; modifying the content of the proxy class set under each micro service to enable the current micro service to communicate with the related micro service; introduce configuration of an inter-service communication framework within a pom.xml file under each micro-service; and a configuration to inject a rest interface in a web.xml file under each microservice.
Specifically, the splitting of the monomer application according to the monomer application source code, the monomer application track and the monomer application splitting scheme comprises the following steps:
step S301: a micro-service item code catalog is created. And creating a corresponding micro service code directory according to the entity set SC in the splitting scheme, and copying all contents in the single application source code. In addition, the class which does not belong to the current micro service is used as the dummy class, logic in all methods in the dummy class is cleared and exception is injected, and meanwhile, all annotations are also cleared, so that error reporting during deployment is prevented.
Step S302: a microservice tool class is created. Creating EvaluatorLogger.java for recording information of each track; creating serializationUtil for serializing transmission data; creating spring content. Java for microservice object management.
Step S303: a microservice service class is created. And determining the entry class of each micro service based on the interface set I in the splitting scheme, and creating the service class of each micro service according to the method information of the entry and the like. After creating the service class, a service registration class named jaxrsconfiguration.
Step S304: a proxy class for the microservice is created. And (3) sorting the single application tracks, wherein the calling relationship in each track is expressed as a result in a calling chain form: call _ chain i = ({ (class 1.method1, class1.method 2), (class 1.method2, class2.method 3) }. And then, in combination with an entity set SC, identifying the class nodes of the cross-service in each calling chain, and finally obtaining a proxy class set under each micro-service. The content of these classes is then modified to allow communication with another associated microservice.
Step S305: and modifying the configuration file information. Introduce configuration of an inter-service communication framework within the pom.xml file under each micro-service to support inter-service communication. Xml also needs to be modified, in which the configuration of the rest interface is injected to support remote invocation.
In particular, referring to FIG. 2, the sequence of cross-service calls after monolithic application automation is shown. When communication is needed between two microservices, a requesting service needs to perform a service agent to complete the request process, and the requested service needs to define a service class for receiving the request, so a class1 agent class is used to represent the requesting agent class in fig. 2, and a class2 service class represents the service class for receiving the request. Specifically, the method comprises the following steps:
for example, class1 calls the method in class2 for the first time, firstly, communication proxy needs to be performed in a class1 proxy class, a class2 object is created through a class1 proxy class calling a class2 service class request, a class2 service class receives the request and then instantiates a class2 object, the instantiated object is added to an object manager, the object manager returns an object Identification (ID), the class2 service class returns the ID to the class1 proxy class, the class2 service class can directly take out a corresponding object from the object manager as long as the ID is taken up when the next method execution request is performed, and then, the corresponding method is called to execute. This completes one communication across services.
In a possible implementation manner, the obtaining a monitoring log of a test case execution process of a plurality of micro services and obtaining a micro service trajectory includes: and according to the single application track, inserting a call log after method call is carried out in the code of each micro-service and a place with a return value, then deploying each micro-service on a server, and carrying out test and monitoring log acquisition by using the same test case as that in the S1 to obtain the micro-service track.
Specifically, based on the single application track, a call log is inserted after each method call of the split micro service code and a place with a return value, and is used for tracking the running track of the split service code. And deploying the code of the split micro service on the server and running the code. The test was performed using the same test case as in S1. After the operation is finished, all the test logs are taken out, the test logs are sorted, and finally, a micro-service track is output:
MT i ＝{m_trace_id i ，m_call_set i }
wherein, MT i M _ trace _ id, the ith trace of the microservice trace i Number, m _ call _ set, of ith trace representing micro service trace i Representing all calling relationship sets in the ith trace of the micro-service trace; m _ call _ set i ＝{mc 1 ，...，mc l ，...，mc k }; wherein k is the number of calling relations in the ith trace of the micro-service trace, mc l The first calling relation in the ith trace of the micro service trace is obtained; mc of l ＝(method1，method2，m1 para ，m2 para ，class1，class2，m1_return，m2_return)。
In a possible embodiment, the comparing the single application trajectory and the micro service trajectory to obtain the trajectory similarity includes:
comparing the ith track of the single application track with the ith track of the micro-service track by the following formula:
len(a_call_set i )＝len(m_call_set i )
a_call_set i .ac k ＝m_call_set i .mc k
wherein len (a _ call _ set) i ) Calling the length of a relation set for the ith track of the single application track; len (m _ call _ set) i ) Calling the length of a relation set for the ith track of the micro-service track; a _ call _ set i .ac k Calling a kth calling relation in a relation set for the ith track of the single application track; m _ call _ set i .mc k And calling the kth calling relation in the relation set for the ith track of the micro service track.
When the ith track of the single application track and the ith track of the micro service track meet the formula, the ith track of the single application track is consistent with the ith track of the micro service track; otherwise, inconsistency; then, the trajectory similarity is obtained by the following formula: trajectory similarity = number of single application trajectories that are consistent with the trajectory in the microservice trajectory/total number of trajectories.
Specifically, considering that the log insertion implemented by the micro service landing is performed according to the single application track in the front and a certain error may exist after the splitting, in this embodiment, the preset threshold of the track similarity is set to 90%, and the track similarity reaches above 90%, so that the success of the automatic service of the micro service can be confirmed.
If the threshold value is not reached, firstly, which tracks are not executed need to be checked, and then whether log records are inserted into the relevant positions of the tracks is confirmed. If all checked, it may be caused by unreasonable part of the splitting scheme, and the splitting scheme may be manually adjusted, and then the adjusted splitting scheme is input to step S3, and the splitting is performed again to generate a new micro service. And then, verifying the track consistency again until the consistency condition is adjusted to be met, wherein the obtained micro service is an optimal splitting result, and outputting the split micro service.
In order to make the objects, features and advantages of the present invention more apparent and understandable, embodiments of the present invention are described in detail below with reference to specific embodiments. In the embodiment, the application jpeg store of the pet store is taken as an example to automatically serve the single application source code, and the specific steps are as follows:
step S11: based on a dynamic instrumentation technology, monitoring the execution process of the jpeg store source code on the test case, extracting a monitoring log, cleaning data in the monitoring log to obtain a monomer application track, wherein the monomer application track is shown in table 1 specifically:
TABLE 1 Single body application trajectory chart
Step S21: and identifying the microservice based on the FoSCI framework, and acquiring a splitting scheme. The splitting scheme comprises an entity set SC and an interface set I. The entity set SC is specifically shown in table 2:
table 2 entity set SC table
The interface set I is specifically shown in table 3:
table 3 interface set I table
Step S31: and based on the single application source code, the single application track and the single application splitting scheme, the micro-service scheme in the splitting scheme is realized by landing. The method specifically comprises the following steps:
step S301: a micro-service code directory is created. There are four microservices in the microservice scheme, so four code directories of 0, 1, 2 and 3 are created, and all contents in the source directory are copied to four directories respectively. There are 4 entities in the microservice of No. 0, there are 6 entities in the microservice of No. 1, there are 3 entities in the microservice of No. 2, there are 3 entities in the microservice of No. 3, carry on the content to the entity not belonging to corresponding microservice and remove and carry on the abnormal injection.
Step S302: a microservice tool class is created. Four classes, evaluatorlogger.
Step S303: a microservice service class is created. Based on the interface set I in the monolithic application splitting scheme, it can be respectively determined that the entry class of the microservice No. 0 is OrderActionBean, the entry class of the microservice No. 1 is CatalogActionBean, the entry class of the microservice No. 2 is cartactactionbean, and the entry class of the microservice No. 3 is AccountActionBean. And establishing corresponding service classes for the four classes. And creating a service registration class named JAXRSConturation.java under the root directory of each micro service, and registering the corresponding service class therein.
Step S304: a proxy class for the microservice is created. Based on the single application track, the agent class of the micro service No. 0 is OrderService, the micro service No. 1 has no calling behavior between services, so that the agent class does not exist, the agent class of the micro service No. 2 has CatalogActionBean and Cart, and the agent class of the micro service No. 3 has AccountActionBean. And processing the remote calling party to support the mutual calling between the services.
Step S305: and modifying the configuration file information. Introduce configuration of an inter-service communication framework within the pom.xml file under each micro-service to support inter-service communication. Xml also needs to be modified, and the configuration of the rest interface is injected into the web, so as to support remote calling.
Step S41: and deploying the codes of the micro-services after the initial splitting on the server, obtaining the running logs of the codes, and extracting the micro-service tracks. And comparing the consistency of the single application track and the micro-service track after landing on the ground based on the single application track, if the single application track and the micro-service track are consistent, outputting the split micro-service, and if the single application track and the micro-service track are inconsistent, adjusting the splitting scheme to step S31.
The following are embodiments of the apparatus of the present invention that may be used to perform embodiments of the method of the present invention. For details not disclosed in the device embodiments, reference is made to the method embodiments of the invention.
Referring to fig. 3, in a further embodiment of the present invention, a single application micro-service splitting system is provided, which can be used to implement the above single application micro-service splitting method. The single application track acquisition module is used for acquiring a monitoring log of a test case execution process of the single application to obtain a single application track; the splitting scheme acquisition module is used for calling the FoSCI framework according to the single application track to obtain a single application splitting scheme; the splitting module is used for acquiring a single application source code, splitting the single application according to the single application source code, the single application track and the single application splitting scheme to obtain a plurality of micro services; the micro-service track acquisition module is used for acquiring monitoring logs of the execution process of the test cases of the micro-services to obtain a micro-service track; the verification module is used for comparing the single application track and the micro-service track to obtain track similarity, and outputting the split micro-service when the track similarity is greater than a preset threshold value; otherwise, acquiring and updating the current splitting scheme and triggering the splitting module according to the manually modified splitting scheme.
In a possible implementation manner, the obtaining a monitoring log of a test case execution process of a monolithic application to obtain a monolithic application track includes:
based on the dynamic pile inserting technology, the execution process of the test case of the single application is monitored to extract the monitoring log, and repeated data or noise data in the monitoring log are cleaned and filtered to obtain single application track data.
Formalizing the monomer application track data according to the following formula to obtain a monomer application track:
AT i ＝{a_trace_id i ，a_call_set i }
wherein, AT i For the ith track of the monolithic application track, a _ trace _ id i Number of i-th track, a _ call _ set, representing a track of monomer applications i Representing all calling relationship sets in the ith track of the single application track; a _ call _ set i ＝{ac 1 ，...，ac l ，...，ac k }; wherein k is the number of calling relations in the ith track of the single application track; ac l The first calling relation in the ith track of the single application track is obtained; ac l ＝(method1，method2，m1 para ，m2 para Class1, class2, m1_ return, m 2-return), where method1 represents a source method name in the l-th call relation, method2 represents a destination method name in the l-th call relation, m1_ para represents an entry type of the source method in the l-th call relation, m2_ para represents an entry type of the destination method in the l-th call relation, class1 represents a class name where the source method in the l-th call relation is located, class2 represents a class name where the destination method in the l-th call relation is located, m1_ return represents a return value type of the source method in the l-th call relation, and m2_ return represents a return value type of the destination method in the l-th call relation.
In a possible embodiment, the calling the FoSCI framework according to the monomer application trajectory to obtain the monomer application splitting scheme includes: and (4) converting the monomer application track according to the input requirement of the FoSCI framework and inputting the converted monomer application track into the FoSCI framework to obtain a monomer application resolution scheme.
The single application splitting scheme comprises an entity set SC and an interface set I:
SC＝{SC t }＝{service_name t ，entity_set t }
I＝{I t }＝{service_name t ，interface_set t }
wherein, service _ name t Denotes the name, entity _ set, of the t-th microservice t Represents all entity sets under the t-th microservice, entity _ set t ＝{entity 1 ，...，entity q Q represents the number of entities in the t-th microservice, entity q Name representing entity q in the tth microservice; interface _ set t Represents all interface _ sets under the tth micro-service t ＝{o 1 ，...，o n In which o is n As the nth method, o n = oper, oper _ para, oper _ return, oper represents the method name of the nth method in the interface, oper _ para represents the entry parameter type of the nth method, and oper _ return represents the return value type of the nth method.
In a possible embodiment, the splitting the monolithic application according to the monolithic application source code, the monolithic application track, and the monolithic application splitting scheme includes:
creating a plurality of micro-service code directories according to an entity set in a single application splitting scheme, copying all contents in a single application source code to each micro-service code directory, taking a class which does not belong to the current micro-service in each micro-service code directory as a dummy class, clearing logics and comments in all methods in the dummy class and injecting exceptions; each micro service respectively creates a micro service tool class: the method comprises the steps of creating a code file for recording each piece of track information, a code file for serializing transmission data, a code file for acquiring the context of current application and a code file for managing micro-service objects; determining an entry class of each micro service according to an interface set in the single application splitting scheme, and creating a service class of each micro service according to method information of the entry class of each micro service; creating a service registration class under each micro service, and registering the service class of the micro service in the service registration class; representing the calling relation in each track in the single application track as a result in a calling chain form to obtain a plurality of calling chains, and identifying class nodes across services in each calling chain by combining an entity set to obtain a proxy class set under each micro service; modifying the content of the proxy class set under each micro service so that the current micro service can communicate with the related micro service; introduce configuration of inter-service communication framework within a pom.xml file under each micro-service; and a configuration to inject a rest interface in a web.xml file under each microservice.
In a possible implementation manner, the obtaining a monitoring log of a test case execution process of a plurality of micro services to obtain a micro service trajectory includes: according to the single application track, after method calling is carried out in the code of each micro service and a calling log is inserted in a place with a return value, each micro service is deployed on a server, the same test case as that in S1 is used for obtaining a test and monitoring log, and the micro service track is obtained:
MT i ＝{m_trace_id i ，m_call_set i }
wherein, MT i M _ trace _ id, the ith trace of the microservice trace i Number, m _ call _ set, of ith trace representing micro service trace i Representing all calling relationship sets in the ith trace of the micro-service trace; m _ call _ set i ＝{mc 1 ，...，mc l ，...，mc k }; wherein k is the number of calling relations in the ith trace of the micro-service trace, mc l The first calling relation in the ith track of the micro service track is obtained; mc of l ＝(method1，method2，m1 para ，m2 para ，class1，class2，m1_return，m2_return)。
In a possible embodiment, the comparing the single application trajectory and the micro-service trajectory to obtain the trajectory similarity includes:
comparing the ith track of the single application track with the ith track of the micro-service track by the following formula:
len(a_call_set i )＝len(m_call_set i )
a_call_set i .ac k ＝m_call_set i .mc k
wherein len (a _ call _ set) i ) Calling the length of a relation set for the ith track of the single application track; len (m _ call _ set) i ) Calling the length of a relation set for the ith track of the micro-service track; a _ call _ set i .ac k Calling the kth calling relation in the relation set for the ith track of the single application track; m _ call _ set i .mc k And calling the kth calling relation in the relation set for the ith track of the micro service track.
When the ith track of the single application track and the ith track of the micro service track meet the formula, the ith track of the single application track is consistent with the ith track of the micro service track; otherwise, inconsistency; then, the trajectory similarity is obtained by the following formula: trajectory similarity = number of single application trajectories that are consistent with the number of trajectories in the microservice trajectory/total number of trajectories.
In one possible embodiment, the preset threshold is 90%.
All relevant contents of each step related to the embodiment of the single application micro-service splitting method may be referred to the functional description of the functional module corresponding to the single application micro-service splitting system in the embodiment of the present invention, and are not described herein again.
The division of the modules in the embodiments of the present invention is schematic, and only one logical function division is provided, and in actual implementation, there may be another division manner, and in addition, each functional module in each embodiment of the present invention may be integrated in one processor, or may exist alone physically, or two or more modules are integrated in one module. The integrated module can be realized in a hardware mode, and can also be realized in a software functional module mode.
In yet another embodiment of the present invention, a computer device is provided that includes a processor and a memory for storing a computer program comprising program instructions, the processor for executing the program instructions stored by the computer storage medium. The Processor may be a Central Processing Unit (CPU), or may be other general-purpose Processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), an off-the-shelf Programmable gate array (FPGA) or other Programmable logic device, a discrete gate or transistor logic device, a discrete hardware component, etc., which is a computing core and a control core of the terminal, and is specifically adapted to load and execute one or more instructions in a computer storage medium to implement a corresponding method flow or a corresponding function; the processor provided by the embodiment of the invention can be used for the operation of the monomer application micro-service splitting method.
In yet another embodiment of the present invention, the present invention further provides a storage medium, specifically a computer-readable storage medium (Memory), which is a Memory device in a computer device and is used for storing programs and data. It is understood that the computer readable storage medium herein can include both built-in storage medium in the computer device and, of course, extended storage medium supported by the computer device. The computer-readable storage medium provides a storage space storing an operating system of the terminal. Also, one or more instructions, which may be one or more computer programs (including program code), are stored in the memory space and are adapted to be loaded and executed by the processor. It should be noted that the computer-readable storage medium may be a high-speed RAM memory, or may be a non-volatile memory (non-volatile memory), such as at least one disk memory. One or more instructions stored in the computer-readable storage medium may be loaded and executed by a processor to implement the corresponding steps of the method for splitting the monolithic application microservice in the foregoing embodiments.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
Finally, it should be noted that: the above embodiments are only for illustrating the technical solutions of the present invention and not for limiting the same, and although the present invention is described in detail with reference to the above embodiments, those of ordinary skill in the art should understand that: modifications and equivalents may be made to the embodiments of the invention without departing from the spirit and scope of the invention, which is to be covered by the claims.
Claims (10)
1. A method for splitting a single application micro-service is characterized by comprising the following steps:
s1: acquiring a monitoring log of a test case execution process of the single application to obtain a single application track;
s2: calling a FoSCI framework according to the monomer application track to obtain a monomer application splitting scheme;
s3: acquiring a single application source code, and splitting single application according to the single application source code, the single application track and a single application splitting scheme to obtain a plurality of micro services;
s4: acquiring monitoring logs of the execution process of test cases of a plurality of micro services to obtain a micro service track;
s5: comparing the single application track with the micro-service track to obtain track similarity, and outputting the split micro-service when the track similarity is greater than a preset threshold; otherwise, acquiring and updating the current splitting scheme according to the manually modified splitting scheme and returning to the S3.
2. The method for splitting the single application micro-service according to claim 1, wherein the obtaining of the monitoring log of the test case execution process of the single application comprises:
based on a dynamic pile inserting technology, monitoring the execution process of the test case of the single application to extract a monitoring log, and cleaning and filtering repeated data or noise data in the monitoring log to obtain single application track data;
formalizing the monomer application track data according to the following formula to obtain a monomer application track:
AT i ＝{a_trace_id i ，a_call_set i }
wherein, AT i For the ith track of the monolithic application track, a _ trace _ id i Number of i-th track, a _ call _ set, representing a track of monomer applications i Representing all calling relationship sets in the ith track of the single application track; a _ call _ set i ＝{ac 1 ，...，ac l ，...，ac k }; wherein k is the number of calling relations in the ith track of the single application track; ac l The first calling relation in the ith track of the single application track is obtained; ac l ＝(method1，method2，m1 para ，m2 para Class1, class2, m1_ return, m2_ return), where method1 represents the source method name in the l-th calling relationship, method2 represents the destination method name in the l-th calling relationship, m1_ para represents the entry type of the source method in the l-th calling relationship, m2_ para represents the entry type of the destination method in the l-th calling relationship, class1 represents the class name of the source method in the l-th calling relationship, class2 represents the class name of the destination method in the l-th calling relationship, m1_ return represents the return value type of the source method in the l-th calling relationship, and m2_ return represents the l-th calling relationshipl return value types of the destination method in the call relation.
3. The method for splitting the monomer application microservice according to claim 2, wherein the step of calling the FoSCI framework according to the monomer application trajectory to obtain the monomer application splitting scheme comprises:
converting the monomer application track according to the input requirement of the FoSCI frame and inputting the converted monomer application track into the FoSCI frame to obtain a monomer application splitting scheme;
the single application splitting scheme comprises an entity set SC and an interface set I:
SC＝{SC t }＝{service_name t ，entity_set t }
I＝{I t }＝{service_name t ，interface_set t }
wherein, service _ name t Denotes the name, entity _ set, of the t-th micro-service t Represents the set of all entities under the t-th microservice, entity _ set t ＝{entity 1 ，...，entity q Q represents the number of entities in the t-th microservice, entity q Name representing entity q in the tth microservice; interface _ set t Represents all interface _ sets under the tth micro-service t ＝{o 1 ，...，o n In which o is n As the nth method, o n = (operator, operator _ para, operator _ return), operator represents the method name of the nth method in the interface, operator _ para represents the nth method entry type, and operator _ return represents the nth method return value type.
4. The monolithic application microservice splitting method of claim 3, wherein splitting a monolithic application according to a monolithic application source code, a monolithic application track, and a monolithic application splitting scheme comprises:
creating a plurality of micro-service code directories according to an entity set in a single application splitting scheme, copying all contents in a single application source code to each micro-service code directory, taking a class which does not belong to the current micro-service in each micro-service code directory as a dummy class, clearing logics and annotations in all methods in the dummy class and injecting exceptions;
each micro service respectively creates a micro service tool class: the method comprises the steps of creating a code file for recording each piece of track information, a code file for serializing transmission data, a code file for acquiring the context of current application and a code file for managing micro-service objects;
determining an entry class of each micro service according to an interface set in the single application splitting scheme, and creating a service class of each micro service according to method information of the entry class of each micro service; creating a service registration class under each micro service, and registering the service class of the micro service in the service registration class;
representing the calling relation in each track in the single application track as a result in a calling chain form to obtain a plurality of calling chains, and identifying class nodes across services in each calling chain by combining an entity set to obtain a proxy class set under each micro service; modifying the content of the proxy class set under each micro service to enable the current micro service to communicate with the related micro service;
introduce configuration of an inter-service communication framework within a pom.xml file under each micro-service; and a configuration to inject the rest interface in a web.xml file under each microservice.
5. The method for splitting the single application microservice according to claim 4, wherein the obtaining the monitoring logs of the test case execution process of the plurality of microservices to obtain the microservice trajectory comprises:
according to the single application track, after method calling is carried out in the code of each micro service and a calling log is inserted in a place with a return value, each micro service is deployed on a server, the same test case as that in S1 is used for obtaining a test and monitoring log, and the micro service track is obtained:
MT i ＝{m_trace_id i ，m_call_set i }
wherein, MT i Is a mini-suitI-th track, m _ trace _ id, of the service track i Number, m _ call _ set, of ith trace representing micro service trace i Representing all calling relationship sets in the ith trace of the micro service trace; m _ call _ set i ＝{mc 1 ，...，mc l ，...，mc k }; wherein k is the number of calling relations in the ith trace of the micro-service trace, mc l The first calling relation in the ith track of the micro service track is obtained; mc of l ＝(method1，method2，m1 para ，m2 para ，class1，class2，m1_return，m2_return)。
6. The method for splitting the monomer application micro-service according to claim 5, wherein the comparing the monomer application trajectory with the micro-service trajectory to obtain the trajectory similarity comprises:
comparing the ith track of the single application track with the ith track of the micro-service track by the following formula:
len(a_call_set i )＝len(m_call_set i )
a_call_set i .ac k ＝m_call_set i .mc k
wherein len (a _ call _ set) i ) Calling the length of a relation set for the ith track of the single application track; len (m _ call _ set) i ) Calling the length of a relation set for the ith track of the micro-service track; a _ call _ set i .ac k Calling the kth calling relation in the relation set for the ith track of the single application track; m _ call _ set i .mc k Calling a kth calling relation in a relation set for the ith track of the micro-service track;
when the ith track of the single application track and the ith track of the micro service track meet the formula, the ith track of the single application track is consistent with the ith track of the micro service track; otherwise, inconsistency;
the trajectory similarity is obtained by: trajectory similarity = number of single application trajectories that are consistent with the trajectory in the microservice trajectory/total number of trajectories.
7. The method for splitting a monomer application micro-service according to claim 1, wherein the preset threshold is 90%.
8. A monomer application microservice splitting system, comprising:
the single application track acquisition module is used for acquiring a monitoring log of the execution process of the test case of the single application to obtain a single application track;
the splitting scheme acquisition module is used for calling the FoSCI framework according to the single application track to obtain a single application splitting scheme;
the splitting module is used for acquiring the single application source codes and splitting the single application according to the single application source codes, the single application tracks and the single application splitting scheme to obtain a plurality of micro services;
the micro-service track acquisition module is used for acquiring monitoring logs of the test case execution process of a plurality of micro-services to obtain a micro-service track;
the verification module is used for comparing the single application track and the micro-service track to obtain track similarity, and outputting the split micro-service when the track similarity is greater than a preset threshold value; otherwise, acquiring and updating the current splitting scheme and triggering the splitting module according to the manually modified splitting scheme.
9. A computer device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, wherein the processor when executing the computer program implements the steps of the monolithic application microservice splitting method of any of claims 1 to 7.
10. A computer-readable storage medium storing a computer program, wherein the computer program when executed by a processor implements the steps of the monolithic application microservice splitting method according to any of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210843226.2A CN115185495A (en) | 2022-07-18 | 2022-07-18 | Method, system, equipment and storage medium for splitting single application micro-service |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210843226.2A CN115185495A (en) | 2022-07-18 | 2022-07-18 | Method, system, equipment and storage medium for splitting single application micro-service |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115185495A true CN115185495A (en) | 2022-10-14 |
Family
ID=83519934
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210843226.2A Pending CN115185495A (en) | 2022-07-18 | 2022-07-18 | Method, system, equipment and storage medium for splitting single application micro-service |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115185495A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116775171A (en) * | 2023-08-25 | 2023-09-19 | 太平金融科技服务(上海)有限公司深圳分公司 | Architecture switching method and device, electronic equipment and storage medium |
-
2022
- 2022-07-18 CN CN202210843226.2A patent/CN115185495A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116775171A (en) * | 2023-08-25 | 2023-09-19 | 太平金融科技服务(上海)有限公司深圳分公司 | Architecture switching method and device, electronic equipment and storage medium |
| CN116775171B (en) * | 2023-08-25 | 2023-12-05 | 太平金融科技服务(上海)有限公司深圳分公司 | Architecture switching method and device, electronic equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7681182B1 (en) | Including function call graphs (FCG) generated from trace analysis data within a searchable problem determination knowledge base | |
| EP2228726B1 (en) | A method and system for task modeling of mobile phone applications | |
| US20180046455A1 (en) | System and Method of Configuring A Data Store For Tracking And Auditing Real-Time Events Across Different Software Development Tools In Agile Development Environments | |
| CN115129736B (en) | Rule event dynamic loading and updating method based on rule engine and related equipment | |
| TW201737126A (en) | Method and device for executing data recovery operation | |
| CN110928772A (en) | Test method and device | |
| CN104216912A (en) | Method and device for achieving non-intrusive service form workflow | |
| US11385898B2 (en) | Task orchestration method for data processing, orchestrator, device and readable storage medium | |
| CN110659018B (en) | Method and device for realizing flow engine | |
| CN111290958B (en) | Method and device for debugging intelligent contract | |
| Heit et al. | An architecture for the deployment of statistical models for the big data era | |
| US10528456B2 (en) | Determining idle testing periods | |
| CN115185495A (en) | Method, system, equipment and storage medium for splitting single application micro-service | |
| CN116560626A (en) | Data processing method, system, equipment and storage medium based on custom rules | |
| CN113742228A (en) | Test, data playback and recording method, system, device, equipment and medium | |
| CN112541746A (en) | Full-stack automatic arrangement method and system | |
| CN111552648A (en) | Automatic verification method and system for application | |
| CN115185825A (en) | Interface test scheduling method and device | |
| CN114092246A (en) | Problem positioning method and device for financial transaction link | |
| US8631391B2 (en) | Method and a system for process discovery | |
| CN114706738A (en) | Method and device for automatically burying point at client | |
| CN109857390B (en) | Annotation transmission method of Git warehouse file annotation system | |
| Salva et al. | Autofunk, a fast and scalable framework for building formal models from production systems | |
| CN113220592A (en) | Processing method and device for automated testing resources, server and storage medium | |
| CN111970329A (en) | Method, system, equipment and medium for deploying cluster service |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |