A Microservice Extraction Method Based on Program Static Attributes and Graph Neural Networks

Abstract

The present invention discloses a microservice extraction method based on program static attributes and graph neural networks, including: performing static analysis on a target monolithic application to obtain the static attributes of the application program, including three static relationships between classes and the feature representation of each class; respectively constructing a graph encoder model based on a graph attention network for each static relationship, using the reconstruction error as the loss function of each model, and obtaining a joint loss function through weighted aggregation; using the program static attributes and the joint loss function to jointly train each model, and after the training is completed, weighted aggregation is performed on the generated feature embedding representations to obtain the final feature representation of each class; based on the final feature representation, clustering operations are performed on each class in the monolithic application to obtain a series of candidate microservices. The present invention is based on the static analysis of the monolithic application, comprehensively considers and combines the attribute information of multiple levels contained in the application, thereby ensuring the rationality of the obtained microservice extraction results.

Description

Technical Field

[0001] The present invention belongs to the technical field of microservices, and in particular, relates to a microservice extraction method based on program static attributes and graph neural networks. Background Art

[0002] The microservice architecture is a hot topic in the field of software engineering in recent years. This architecture is a service-oriented distributed software development architecture that advocates decomposing a single application into several loosely coupled micro-services. Each service can be deployed and run independently, and the services coordinate and call each other through a lightweight communication mechanism. Therefore, compared with the monolithic architecture, the microservice architecture has natural advantages in terms of scalability and maintainability, and many enterprises have also chosen to migrate their systems from the monolithic architecture to the microservice architecture.

[0003] Microservice extraction is mainly responsible for reasonably extracting classes with the same business functions from a monolithic architecture system to form a set of candidate microservices, thus providing an important basis for building a microservice architecture.

[0004] The existing microservice extraction methods mainly include the following three categories: (1) Methods based on static analysis: These methods obtain candidate microservices by analyzing the static structure of program source code. (2) Methods based on dynamic analysis: These methods obtain microservice splitting schemes by analyzing some behavioral characteristics during the dynamic operation of the program. The implementation of the method usually requires based on pre-constructed test cases and related monitoring tools. (3) Methods based on metadata analysis: These methods use abstract software architecture descriptions as input data to analyze and identify microservices, such as UML diagrams, use cases, etc.

[0005] For example, the Chinese patent document with the publication number CN115794105A discloses a microservice extraction method, including: obtaining the interaction relationship between classes and the semantic data of each class in the application program; respectively constructing a structural similarity matrix and a semantic similarity matrix of the application program according to the interaction relationship between classes and the semantic data of each class; integrating the structural similarity matrix and the semantic similarity matrix to obtain a class similarity matrix of the application program; performing clustering processing on the class similarity matrix to extract the microservices of the application program.

[0006] The Chinese patent document with the publication number CN115309634A discloses a microservice extraction method, hierarchically partitioning the source code; obtaining the sequence diagram of each method in the control layer through reverse engineering, and obtaining the class diagrams of the entity layer, the database access layer, and other layers; performing display business function modeling on the sequence diagram; performing implicit business function modeling on the class diagram; extracting candidate microservices of the source code based on the business function model through spectral clustering.

[0007] The existing microservice extraction methods mainly have the problem of overly one-sided analysis basis. For the information contained in the application itself, most methods only consider the structural information or semantic information of the application, and few methods combine the two and further consider other aspects of information. Insufficient comprehensive data analysis may cause deviations in microservice identification, thus affecting the quality of the generated candidate microservices. Summary of the Invention

[0008] In view of the deficiencies in the existing methods, the present invention provides a microservice extraction method based on program static attributes and graph neural networks. By comprehensively considering multiple aspects of static attributes in the application program, it is ensured that the monolithic application is divided into candidate microservices as reasonably as possible.

[0009] A microservice extraction method based on program static attributes and graph neural networks includes the following steps:

[0010] (1) Perform static analysis on the target monolithic application to obtain the static attributes of the application program, including three static relationships between classes and the feature representation of each class;

[0011] (2) For each static relationship, construct a graph encoder model based on the graph attention network, use the reconstruction error as the loss function of each model, and obtain the joint loss function through weighted aggregation;

[0012] (3) Use the obtained program static attributes and the joint loss function to jointly train each model. After the training is completed, weight-aggregate the feature embedding representations generated by each model to obtain the final feature representation of each class;

[0013] (4) Based on the feature representation of each class, use the clustering algorithm to cluster each class in the monolithic application to obtain a series of candidate microservices.

[0014] In step (1), the three static relationships between classes include inheritance relationship, association relationship, and dependency relationship;

[0015] Among them, the inheritance relationship means that a class inherits all the functions of another class and implements its own unique functions, which is identified by the extends keyword in the program; the association relationship means that an object of another class is included in the fields of a class; the dependency relationship means that an object of another class is constructed and used in the method of a class, and the object is a parameter, variable, or return value of the method.

[0016] Extract the three static relationships based on the abstract syntax tree corresponding to the source code, and further obtain the graph representations G1, G2, and G3 of the three static relationships; among them, the nodes of the graph represent the classes in the application program, and the directed edges represent the corresponding static relationships between classes.

[0017] The process of obtaining the feature representation of each class is as follows:

[0018] (1-1) Find all the entry methods in the application, and obtain the correspondence between classes and program entry according to the execution trace corresponding to each entry method, so as to obtain the structural feature X1 of the class.

[0019] If the i-th class appears in the execution trace corresponding to the j-th entry method, then X1(i, j) = 1, otherwise X1(i, j) = 0.

[0020] (1-2) Extract the text information (including class names, field names, method names, variable names, etc.) contained in the abstract syntax tree corresponding to the class source code and form a word sequence; then perform further preprocessing on the word sequence, including three steps: word segmentation, stop word removal, and stemming; finally, use the tf-idf model to map the word sequence corresponding to each class into a vector representation to obtain the semantic feature X2 of the class.

[0021] Among them, the word segmentation process includes two steps. The first step is to further split each word in the sequence into multiple words according to whitespace and punctuation marks, and the second step is to check and split each word according to the Camel-Case naming rule; stop word removal means removing the common English stop words (such as a, on, to, etc.) contained in the sequence; stemming means replacing each word in the sequence with its corresponding root form, such as converting apples to apple.

[0022] Using the tf-idf model to map the word sequence corresponding to each class into a vector representation to obtain the semantic feature X2 of the class, the formula is as follows:

[0023]

[0024] Among them, count(i,j) is the number of times the j-th word in the dictionary appears in the word sequence of the i-th class, and the dictionary corresponding to the model is obtained by merging all word sequences and removing duplicates; count(i,*) is the length of the word sequence of the i-th class, N(j) is the number of word sequences containing the j-th word in the dictionary, and N is the total number of word sequences, that is, the number of classes.

[0025] (1-3) Find all the entity classes in the application, and check in turn whether there is a static relationship between each class and each entity class, so as to determine the correspondence between classes and data entities, and obtain the data dependency feature X3 of the class.

[0026] If there is one or more static relationships from the i-th class to the j-th entity class, then X3(i, j) = 1, otherwise X3(i, j) = 0; if the i-th class and the j-th entity class are the same class, it is stipulated that X3(i, j) = 1.

[0027] (1 - 4) Concatenate the above three groups of feature matrices X1, X2, and X3 to obtain the complete feature representation X = (X1, X2, X3) of the class.

[0028] Step (2) is specifically as follows:

[0029] Each static relationship corresponds to a graph encoder model with the same structure. The graph encoder model based on the graph attention network is described as follows:

[0030] The input data of the model is the feature matrix X of the class and the static relationship graph G corresponding to the model; the structure of the model consists of two layers of graph encoders and two layers of graph decoders. The output of each layer is h' = [h1', h2', …, h n '], where n is the number of nodes, and the feature vector h i ' corresponding to the i-th node is calculated as follows:

[0031]

[0032] where K is the number of attentions used in the multi-head attention mechanism, W k is the weight matrix of the k-th attention, represents the attention score of node j to node i under the k-th attention, N i represents the set of neighbor nodes corresponding to the i-th node, h j is the feature vector corresponding to the j-th node in the current layer input h = [h1, h2, …, h n , and σ represents the activation function; the attention score is calculated as follows:

[0033]

[0034] where a k is the weight vector, LeakyRelu is an activation function, and || represents the concatenation operation;

[0035] The output of the last layer of the graph encoder corresponds to the feature embedding representation Z of the nodes, and the output of the last layer of the graph decoder corresponds to the reconstructed node attributes The loss function L of the model is designed based on the reconstruction error and is specifically composed of two parts: the reconstruction error in terms of attributes and the reconstruction error in terms of the graph structure, which is defined as follows:

[0036]

[0037] where n is the number of nodes, A i is the i-th row of the adjacency matrix A corresponding to the input graph structure;

[0038] By performing a weighted sum of the loss functions corresponding to each model, the joint loss function L is obtained total :

[0039] minL total = α1L1 + α2L2 + α3L3

[0040] Among them, the loss functions of the models corresponding to the inheritance relationship G1, the association relationship G2, and the dependency relationship G3 are L1, L2, and L3 respectively, and the corresponding weights are the hyperparameters α1, α2, and α3. The magnitude relationship of the weights should satisfy α1 > α2 > α3

[0041] In step (3), the embedding matrices of the node features obtained by each model are weighted and summed to obtain the final feature representation Z of the node final , that is, the final feature representation of each class, and the calculation method is as follows

[0042] Z final = α1Z1 + α2Z2 + α3Z3

[0043] Among them, the feature embedding matrices generated by the models corresponding to the inheritance relationship G1, the association relationship G2, and the dependency relationship G3 are Z1, Z2, and Z3 respectively. The values of the three weights α1, α2, and α3 are the same as those in the joint loss function L total in the above

[0044] In step (4), the clustering algorithm used is the mean-shift algorithm. Based on the feature representations Z of all classes final cluster the classes in the application program, and finally obtain a series of cluster structures, where each cluster structure corresponds to a candidate microservice

[0045] Compared with the prior art, the present invention has the following beneficial effects

[0046] 1. The present invention comprehensively considers and combines various attribute information of the application program, ensuring the comprehensiveness of the analysis and modeling process and the reliability of the obtained results

[0047] 2. The present invention uses a graph attention network as the layer structure of the network model, so that when aggregating node information, different weights can be assigned to each neighbor node according to the importance of the node

[0048] 3. The present invention uses the mean-shift algorithm for clustering operation. This algorithm does not require specifying the number of target clusters in advance and is not affected by outliers, thus further reducing manual intervention and having strong flexibility and robustness Description of the Drawings

[0049] Figure 1Flowchart of a microservice extraction method based on program static attributes and graph neural network according to the present invention;

[0050] Figure 2 It is an example diagram of three types of inter-class static relationships in the embodiments of the present invention. Detailed implementation manners

[0051] The present invention will be further described in detail below with reference to the drawings and embodiments. It should be noted that the following embodiments are intended to facilitate the understanding of the present invention, but do not limit it in any way.

[0052] As Figure 1 shown, a microservice extraction method based on program static attributes and graph neural network sequentially includes four stages: monolithic application analysis and modeling, graph encoder model construction, training the model and obtaining feature embeddings, and obtaining candidate microservices by clustering.

[0053] (1) Monolithic application analysis and modeling:

[0054] Some static-level information of the application program is obtained by performing static analysis on the target monolithic application, mainly including the static relationships between classes and the static attributes of classes.

[0055] The static relationships between classes mainly include three types: inheritance relationship, association relationship, and dependency relationship. The inheritance relationship means that a class inherits all the functions of another class and can implement its own unique functions, which is identified by the extends keyword in the program. The association relationship means that an object of another class is included in the fields of a class. The dependency relationship means that an object of another class is constructed and used in the method of a class, and the object can be a parameter, variable, or return value of the method. Figure 2 Specific examples of these three relationships are given in

[0056] In this embodiment, these three static relationships are extracted by analyzing the abstract syntax tree of the class source code, and the abstract syntax tree corresponding to the java program can be obtained through some related tools. Based on the analysis results, graph structures G1, G2, and G3 of these three relationships are further constructed. The nodes in the graph represent the classes of the application program, and the directed edges represent the corresponding static relationships between classes.

[0057] The static attributes of classes include three parts, and the feature representation of classes is obtained by combining the attributes of the three parts. The specific process is as follows:

[0058] (1-1) The entry method is usually the method in the program used to process external requests. All the entry methods in the application can be determined through the corresponding annotations in the program. The process of obtaining the execution trace of each entry method is as follows: First, based on the static analysis of the application, the call relationships between various methods in the application are obtained, and a method-level call relationship graph is constructed based on this; subsequently, starting from the current method, a depth-first traversal of the graph is performed, and the corresponding traversal path is the execution trace sequence corresponding to the current method.

[0059] According to the execution trace corresponding to each entry method, the corresponding relationship between the class and the program entry is obtained, and the structural feature X1 of the class is obtained; if the i-th class appears in the execution trace corresponding to the j-th entry method, then X1(i, j) = 1, otherwise X1(i, j) = 0;

[0060] (1-2) Extract the text information (including class names, field names, method names, variable names, etc.) contained in the abstract syntax tree corresponding to the class source code and form a word sequence, and perform further preprocessing on the word sequence. The specific process is as follows: First, each word in the sequence is further split into multiple words according to whitespace and punctuation marks, and each word is further checked and possibly split according to the commonly used Camel-Case naming rule in java programs; subsequently, the common English stop words contained in the sequence are removed, so as to filter out some words with little meaning; finally, each word in the sequence is replaced with its corresponding root form.

[0061] After the preprocessing is completed, the tf-idf model is used to convert the word sequence corresponding to each class into a vector representation, and the semantic feature X2 of the class is obtained. The formula is as follows:

[0062]

[0063] Among them, count(i, j) is the number of times the j-th word in the dictionary appears in the word sequence of the i-th class, and the dictionary corresponding to the model is obtained by merging all word sequences and removing duplicates. count(i, *) is the length of the word sequence of the i-th class, N(j) is the number of word sequences containing the j-th word in the dictionary, and N is the total number of word sequences (the number of classes).

[0064] (1-3) The entity classes in the application are usually placed in a specific path (such as the entity folder). All the entity classes in the application are determined based on the structure of the application. By checking whether there is a static relationship between the class and the entity class, the corresponding relationship between the class and the data entity is determined, and the data dependency feature X3 of the class is obtained; if there is one or more static relationships from the i-th class to the j-th entity class, then X3(i, j) = 1, otherwise X3(i, j) = 0; if the i-th class and the j-th entity class are the same class, it is stipulated that X3(i, j) = 1.

[0065] (1 - 4) Concatenate the above three groups of feature matrices \(X_1\), \(X_2\), and \(X_3\) to obtain the comprehensive feature representation of the class \(X=(X_1, X_2, X_3)\).

[0066] (2) Construction of the graph encoder model:

[0067] Construct graph encoder models based on the graph attention network (GAT) with the same structure for the three static relationships respectively. Using the class feature matrix \(X\) and the corresponding static relationship graph \(G\) as the input of the model, the model structure includes two layers of graph encoders and two layers of graph decoders. The encoder is used to map the input features to a low-dimensional feature space and obtain the feature embedding representation of the nodes, and the decoder is used to reconstruct the encoder output features as the original input features as much as possible. The output of the second layer of the graph encoder is the node feature embedding representation \(Z\), and the output of the second layer of the graph decoder is the reconstructed node attributes

[0068] The output of the model at each layer is \(h'=[h_1', h_2', \ldots, h_n']\), where \(n\) is the number of nodes, and the feature embedding \(h_i'\) of the \(i\)-th node is calculated using the following formula: n ', where \(n\) is the number of nodes, and the feature embedding \(h_i'\) of the \(i\)-th node is i calculated using the following formula:

[0069]

[0070] where \(K\) is the number of attention structures used, \(W_k\) k is the parameter matrix of the \(k\)-th attention, represents the score of node \(j\) for node \(i\) under the \(k\)-th attention structure, \(N_i\) i represents the set of neighbor nodes of the \(i\)-th node, \(h_j\) j is the feature vector corresponding to the \(j\)-th node in the current layer input, and \(\sigma\) represents the activation function. The attention score is calculated as follows:

[0071]

[0072] where \(a\) k is the parameter vector, LeakyRelu is an activation function, and \(\|\) represents the concatenation operation.

[0073] Taking the reconstruction error as the loss function \(L\) of the model, which includes two parts: attribute reconstruction error and structure reconstruction error, and is defined as follows:

[0074]

[0075] where \(n\) is the number of nodes, \(A_i\) i is the \(i\)-th row of the adjacency matrix \(A\) corresponding to the input graph structure.

[0076] Joint loss function L total It is obtained by weighting the loss functions of each model, and the optimization objective is to minimize the loss function, which is specifically defined as:

[0077] minL total = α1L1 + α2L2 + α3L3

[0078] where L1, L2, and L3 are the loss functions of the models corresponding to the inheritance relationship, association relationship, and dependency relationship respectively. The three weights α1, α2, and α3 reflect the importance degrees of the three static relationships. In principle, it should satisfy α1 > α2 > α3.

[0079] (3) Train the models and obtain feature embeddings:

[0080] Based on the obtained feature matrix X of the class and the three static relationship graphs G1, G2, and G3 above, use the joint loss function to jointly train the three models. After the training is completed, weight and aggregate the feature embedding matrices generated by each model to obtain the final feature representation Z of each class final :

[0081] Z final = α1Z1 + α2Z2 + α3Z3

[0082] where Z1, Z2, and Z3 are the feature embeddings generated by the models corresponding to the inheritance relationship, association relationship, and dependency relationship respectively. The values of α1, α2, and α3 are the same as the corresponding values in the joint loss function L total in the corresponding values.

[0083] By considering the importance degrees of the three relationships and weighting and aggregating the feature embeddings of each model, the final feature representation obtained for each class can comprehensively reflect the structural associations between classes.

[0084] (4) Use clustering to obtain candidate microservices:

[0085] In this embodiment, the mean-shift algorithm is used for clustering operations. The mean-shift algorithm is a density-based non-parametric clustering algorithm. Its algorithm idea is to assume that the data sets of different cluster classes conform to different probability density distributions, find the fastest direction in which the density of any sample point increases, and the area with high sample density corresponds to the center of the cluster class. These sample points will eventually converge at the local density maximum, and the sample points that converge to the same local maximum are considered to be members of the same cluster class. Since it does not require setting the number of clusters, requires fewer parameters and the results are relatively stable, it has good flexibility and practicality.

[0086] For all the feature representations Z of the classes finalInput into the mean-shift algorithm and execute the algorithm. The algorithm finally outputs a set of clusters, and each cluster can be regarded as a candidate microservice.

[0087] The above-described embodiments have detailed the technical solutions and beneficial effects of the present invention. It should be understood that the above are only specific embodiments of the present invention and are not used to limit the present invention. Any modifications, supplements, and equivalent replacements made within the scope of the principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A microservice extraction method based on program static attributes and graph neural networks, characterized in that, Including the following steps: (1) Perform static analysis on the target monomer application to obtain the static properties of the application, including three static relationships between classes and the feature representation of each class; the three static relationships between classes include inheritance relationship, association relationship, and dependency relationship; (2) For each static relationship, construct a graph encoder model based on the graph attention network respectively, use the reconstruction error as the loss function of each model, and obtain the joint loss function through weighted aggregation; specifically as follows: Each static relationship corresponds to a graph encoder model with the same structure. The graph encoder model based on the graph attention network used is described as follows: The input data of the model is the feature matrix X of the class and the static relationship graph G corresponding to the model; the structure of the model consists of two layers of graph encoders and two layers of graph decoders, where the output of each layer is h' = [h1 ' , h2 ' , …, h n ' , n is the number of nodes, and the calculation method of the feature vector h i ' corresponding to the i-th node is as follows: Among them, K is the number of attentions used in the multi-head attention mechanism, and W k is the weight matrix of the k-th attention, represents the attention score of node j to node i under the k-th attention, and N i represents the set of neighbor nodes corresponding to the i-th node, and h j is the input of the current layer h = [h1, h2,..., h n , and is the feature vector corresponding to the j-th node, and σ represents the activation function; The output of the last-layer graph encoder corresponds to the feature embedding representation Z of the nodes, and the output of the last-layer graph decoder corresponds to the reconstructed node attributes The loss function L of the model is designed based on the reconstruction error, which is specifically composed of two parts: the reconstruction error in terms of attributes and the reconstruction error in terms of the graph structure, and is defined as follows: where n is the number of nodes, and A i is the i-th row of the adjacency matrix A corresponding to the input graph structure; By performing a weighted sum of the loss functions corresponding to each model, the joint loss function L is obtained total : minL total = α1L1 + α2L2 + α3L3 Among them, the loss functions of the models corresponding to the inheritance relationship G1, the association relationship G2, and the dependency relationship G3 are L1, L2, and L3 respectively, and the corresponding weights are hyperparameters α1, α2, and α3. The magnitude relationship of the weights should satisfy α1>α2>α3; (3) Use the obtained program static properties and the joint loss function to jointly train each model. After the training is completed, weightedly aggregate the feature embedding representations generated by each model to obtain the final feature representation of each class; the calculation method is as follows: Z final = α1Z1 + α2Z2 + α3Z3 Among them, the feature embedding matrices generated by the models corresponding to the inheritance relationship G1, the association relationship G2, and the dependency relationship G3 are Z1, Z2, and Z3 respectively, and the values of the three weights α1, α2, and α3 are the same as those in the joint loss function L total ; (4) Based on the feature representation of each class, use the clustering algorithm to cluster each class in the monomer application to obtain a series of candidate microservices.

2. The microservice extraction method based on program static attributes and graph neural network according to claim 1, wherein In step (1), the inheritance relationship means that a class inherits all the functions of another class and implements its own unique functions; the association relationship means that an object of another class is included in the fields of a class; the dependency relationship means that an object of another class is constructed and used in the method of a class, and the object is a parameter, variable, or return value of the method.

3. The microservice extraction method based on program static attributes and graph neural network according to claim 1, characterized in that In step (1), extract the three static relationships based on the abstract syntax tree corresponding to the source code, and further obtain the graph representations G1, G2, and G3 of the three static relationships; among them, the nodes of the graph represent the classes in the application program, and the directed edges represent the corresponding static relationships between classes.

4. The microservice extraction method based on program static attributes and graph neural network according to claim 1, characterized in that, In step (1), the process of obtaining the feature representation of each class is specifically as follows: (1-1) Find all the entry methods in the application program, and obtain the correspondence between the class and the program entry according to the execution trace corresponding to each entry method to obtain the structural feature X1 of the class; (1-2) Extract the text information contained in the abstract syntax tree corresponding to the class source code and form a word sequence; then perform further preprocessing on the word sequence, including three steps: word segmentation, stop word removal, and stemming; finally, use the tf-idf model to map the word sequence corresponding to each class into a vector representation to obtain the semantic feature X2 of the class; (1-3) Find all the entity classes in the application program, and check whether there is a static relationship between each class and each entity class in turn to determine the correspondence between the class and the data entity, and obtain the data dependency feature X3 of the class; (1-4) Concatenate the above three groups of feature matrices X1, X2, and X3 to obtain the complete feature representation X=(X1, X2, X3) of the class.

5. The microservice extraction method based on program static attributes and graph neural network according to claim 4, characterized in that, In step (1-2), use the tf-idf model to map the word sequence corresponding to each class into a vector representation to obtain the semantic feature X2 of the class. The formula is as follows: Among them, count(i, j) is the number of times the j-th word in the dictionary appears in the word sequence of the i-th class, and the dictionary corresponding to the model is obtained by merging all word sequences and removing duplicates; count(i, *) is the length of the word sequence of the i-th class, N(j) is the number of word sequences containing the j-th word in the dictionary, and N is the total number of word sequences, that is, the number of classes.

6. The microservice extraction method based on program static attributes and graph neural network according to claim 4, characterized in that In step (1-3), if there is one or more static relationships from the i-th class to the j-th entity class, then X3(i, j) = 1; otherwise, X3(i, j) = 0. If the i-th class and the j-th entity class are the same class, it is stipulated that X3(i, j) = 1.

7. The microservice extraction method based on program static attributes and graph neural network according to claim 1, characterized in that In step (2), the attention score is calculated as follows: Among them, a k is a weight vector, LeakyRelu is an activation function, and || represents a concatenation operation.

8. The microservice extraction method based on program static attributes and graph neural network according to claim 1, characterized in that In step (4), the clustering algorithm used is the mean-shift algorithm, based on the feature representations Z of all classes final Cluster the classes in the application program, and finally obtain a series of cluster structures, where each cluster structure corresponds to a candidate microservice respectively.

Images