Method and device for merging and deploying micro-services of Internet of Things platform, and medium

Through Maven engineering management and class loader technology, code conflicts and configuration management problems in the microservice merging process in the IoT platform are solved, automated dependency analysis and merging are realized, development complexity and cost are reduced, and a single set of code is supported. Multi-service deployment.

CN119002942APending Publication Date: 2024-11-22INSPUR GENERSOFT CO LTD
View PDF 0 Cites 2 Cited by

Patent Information

Application Number
CN202411145390.1
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2024-08-20
Publication Date
2024-11-22

AI Technical Summary

Technical Problem

In the IoT platform, when hardware resources are limited or the number of devices is not large, the microservice merging process is complicated, especially in terms of code reconstruction and configuration management, and developers need to maintain multiple sets of code to support the parallel operation of new and old architectures, and increase the number of new and old architectures. Loading.

Method used

Using the Maven engineering management method, analyze the relationship model of microservices, build dependency graphs, detect and integrate public dependencies, merge configuration information, load class files through class loaders, build monolithic applications, and adjust the merge granularity according to load conditions, triggering Split the strategy to optimize performance.

Benefits of technology

It realizes automatic analysis of microservice dependencies, merging code, optimizing configuration, and generating a low-cost and easy-to-maintain IoT platform, reducing the burden on developers and supporting the multi-service deployment of a single set of code.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN119002942A_ABST
    Figure CN119002942A_ABST
Patent Text Reader

Abstract

The invention discloses an Internet of Things platform micro-service merging deployment method and device and a medium, and the method comprises the steps: determining a micro-service managed by Maven engineering, analyzing a file using the micro-service to recognize a relationship mode of the micro-service, the category of the relationship mode comprising a parent-child relationship and a dependency relationship; determining a node class and an edge class, determining a data structure according to the node class and the edge class, and performing relation description on the micro-service according to the data structure; traversing the file to determine a dependency item, determining a node object and an edge object corresponding to the dependency item, adding the node object to the corresponding first set, and adding the edge object to the corresponding second set; and determining a dependency graph according to the data structure, adding the first set and the second set into the dependency graph to construct a dependency network, and performing detection in the construction process of the dependency network. According to the method, micro-service dependence can be automatically analyzed, codes are combined, configuration is optimized, and the Internet of Things platform which can be freely assembled and is easy to maintain and operate is generated.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present application relates to the field of Internet of Things technology, and in particular to a method, device and medium for merging and deploying microservices on an Internet of Things platform. Background Art

[0002] In the development of IoT platforms, the adoption of microservice architecture has greatly improved its flexibility and scalability, enabling it to efficiently support the access of massive devices. However, in specific scenarios, such as when hardware resources are limited or the number of connected devices is small, enterprises may consider optimizing the architecture to reduce costs and simplify management. This usually means merging multiple originally scattered microservices into fewer microservices, or even in extreme cases integrating all microservices into a single monolithic application. This transformation process is complex and challenging, especially in terms of code refactoring and configuration management. Since multiple service instances may have shared the same class or configuration, the potential conflict between different service contexts after the merger becomes a prominent issue. In addition, in order to support the parallel operation or gradual migration of the old and new architectures, developers often have to maintain multiple sets of IoT platform code at the same time, which undoubtedly increases their burden. Summary of the invention

[0003] In order to solve the above problems, the present application proposes a method for merging and deploying microservices of an Internet of Things platform, including: determining a microservice managed by a Maven project, parsing a file using the microservice to identify a relationship pattern of the microservice, wherein the categories of the relationship pattern include parent-child relationships and dependency relationships; determining a node class and an edge class, determining a data structure based on the node class and the edge class, and describing the relationship of the microservice based on the data structure; traversing the file to determine dependencies, and determining node objects and edge objects corresponding to the dependencies, adding the node object to a corresponding first set, and adding the edge object to a corresponding second set; determining a dependency graph based on the data structure, adding the first set and the second set to the dependency graph to construct a dependency network, and performing detection during the construction of the dependency network.

[0004] In one example, the method further includes: traversing the dependency graph to determine common dependencies of the microservices, and integrating the common dependencies into a predetermined common base.

[0005] In one example, the method further includes: determining multiple configuration information of the microservice, and determining duplicate configuration items in the multiple configuration information; merging the duplicate configuration items, and determining conflict reminder information, and sending the conflict reminder information to a user.

[0006] In one example, the method further includes: determining a preset service simulation function, and communicating according to the service simulation function.

[0007] In one example, the method further includes: determining a class loader corresponding to the microservice, determining a corresponding class path through the class loader; and loading a class file of the microservice according to the class path.

[0008] In one example, the method further includes: determining a common base through the class loader, the common base including shared dependencies; determining the dependency relationship corresponding to the microservice, and starting the microservice through the class loader.

[0009] In one example, the method further includes: determining a merged single application, determining a load condition of the single application, and changing the merging granularity according to the load condition.

[0010] In one example, the method further includes: determining the operating environment of the monolithic application to determine key indicators based on the operating environment, wherein the operating environment includes CPU usage, memory occupancy, and network bandwidth; comparing the key indicators with a preset threshold, and if the key indicators exceed the threshold, triggering a splitting strategy to split the microservices in the monolithic application.

[0011] On the other hand, the present application also proposes a merged deployment device for microservices of an Internet of Things platform, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the merged deployment device for microservices of an Internet of Things platform can execute: determining a microservice managed using a Maven project, parsing a file using the microservice to identify a relationship pattern of the microservice, wherein the categories of the relationship pattern include parent-child relationships and dependency relationships; determining a node class and an edge class, determining a data structure based on the node class and the edge class, and describing the relationship of the microservice based on the data structure; traversing the file to determine dependencies, and determining the node objects and edge objects corresponding to the dependencies, adding the node objects to the corresponding first set, and adding the edge objects to the corresponding second set; determining a dependency graph based on the data structure, adding the first set and the second set to the dependency graph to construct a dependency network, and performing detection during the construction of the dependency network.

[0012] On the other hand, the present application also proposes a non-volatile computer storage medium storing computer executable instructions, wherein the computer executable instructions are configured to: determine a microservice managed using a Maven project, parse a file using the microservice to identify a relationship pattern of the microservice, wherein the categories of the relationship pattern include parent-child relationships and dependency relationships; determine a node class and an edge class, determine a data structure based on the node class and the edge class, and describe the relationship of the microservice based on the data structure; traverse the file to determine dependencies, and determine the node objects and edge objects corresponding to the dependencies, add the node objects to the corresponding first set, and add the edge objects to the corresponding second set; determine a dependency graph based on the data structure, add the first set and the second set to the dependency graph to construct a dependency network, and perform detection during the construction of the dependency network.

[0013] This application uses the Internet of Things platform developed with microservice technology to solve the problem of insufficient operating resources when deployed in a resource-constrained operating environment of an IoT mobile device, and to achieve the problem of merging microservices on the IoT platform through code reconstruction and configuration management. This application can automatically analyze microservice dependencies, merge codes, optimize configurations, and generate an IoT platform that can be freely assembled, low-cost, and easy to maintain and operate, without requiring program developers to extensively modify the original platform code. And based on , developers only need to maintain a set of codes to implement an IoT platform that supports microservices and an IoT platform that supports assembly, merging and deployment. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0015] Figure 1 A schematic diagram of a process for merging and deploying microservices on an Internet of Things platform according to an embodiment of the present application;

[0016] Figure 2 This is a schematic diagram of a combined deployment device for microservices on an Internet of Things platform in an embodiment of the present application. DETAILED DESCRIPTION

[0017] In order to make the purpose, technical solution and advantages of the present application clearer, the technical solution of the present application will be clearly and completely described below in combination with the specific embodiments of the present application and the corresponding drawings. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present application.

[0018] The technical solutions provided by various embodiments of the present application are described in detail below in conjunction with the accompanying drawings.

[0019] like Figure 1 As shown, in order to solve the above problems, an embodiment of the present application provides a method for merging and deploying microservices on an Internet of Things platform, the method comprising:

[0020] S101. Determine a microservice managed by a Maven project, and parse a file using the microservice to identify a relationship pattern of the microservice, where categories of the relationship pattern include a parent-child relationship and a dependency relationship.

[0021] The main process of the service identification and dependency analysis module is to describe the parent-child relationship and dependency relationship of each module by parsing the pom.xml file for microservices managed by Maven projects.

[0022] S102: Determine a node class and an edge class, and determine a data structure according to the node class and the edge class, so as to describe the relationship of the microservices according to the data structure.

[0023] Use graph structure to describe the relationship between modules and build node and edge data structures. Define a node class, for example, ServiceNode, which contains the identification information of microservices, such as <groupid> 、 <artifactid>and <version>Define edge classes, such as DependencyEdge, to represent the dependency relationship between services, including references to dependent service nodes.

[0024] S103: traverse the file to determine dependencies, and determine node objects and edge objects corresponding to the dependencies, add the node objects to the corresponding first set, and add the edge objects to the corresponding second set.

[0025] Traverse all parsed <dependency>Elements, creating a ServiceNode object for each unique dependency and storing it in a collection, such as a hash table, with <groupid> : <artifactid>As the key. Again, iterate through all <dependency>For each service dependency, create a DependencyEdge object and add it to the collection representing the dependencies.

[0026] S104: Determine a dependency graph according to the data structure, add the first set and the second set to the dependency graph to construct a dependency network, and perform detection during the construction of the dependency network.

[0027] Use graph data structures, such as adjacency lists or adjacency matrices, to represent the entire dependency graph. Add the nodes and edges created in the above process to the graph. Use DFS or BFS algorithms to traverse the graph to identify and build a dependency tree or dependency network for the service. Detect circular dependencies while building the dependency graph and take appropriate measures, such as recording the circular dependencies or excluding them during the build process.

[0028] In one embodiment, the code merging and refactoring module identifies and extracts common dependencies between services based on the service dependency graph and places them in a common base to reduce duplicate dependencies and ensure that the business logic code remains in the business module and is not changed due to the merge.

[0029] In one embodiment, the configuration synchronization and optimization module reads the configurations in the microservices into the merged service, merges duplicate items, and prompts the user to modify conflicting items.

[0030] In one embodiment, the communication adaptation and simulation module provides a service simulation function to support inter-service communication in a single application. After being merged into a single application, inter-service calls need to be resolved in the same process. In order to mask communication differences, the service call logic is replicated and the requests of each service are redirected to the same service.

[0031] In one embodiment, in Java, a multi-ClassLoader isolation module is responsible for loading class files into the JVM. Because the classes loaded by each ClassLoader are isolated, different ClassLoaders can load classes with the same name.

[0032] Create a separate ClassLoader for each microservice to ensure isolation of the service environment and avoid class and configuration conflicts. Specify the class loading path for each custom ClassLoader, including JAR files, directories, or network resources. These paths should point to the class and resource files of the corresponding microservice.

[0033] When the service starts, a custom ClassLoader is used to load the main class and related dependencies of the service. First, the public base is started to load all public dependencies, and then the business modules that are deployed and merged are started one by one according to the dependencies.

[0034] In one embodiment, the performance evaluation and optimization module performs a performance evaluation on the merged single application, and if the load pressure is too large, it is recommended to reduce the granularity of the merger.

[0035] In one embodiment, the runtime environment of the monolithic application is determined, including key indicators such as CPU usage, memory occupancy, and network bandwidth. The key indicators are compared with preset thresholds. If the key indicators exceed the preset thresholds, the splitting strategy is automatically triggered to split some microservices in the monolithic application to reduce system load and optimize performance. During the splitting process, the necessary interfaces and communication protocols are retained to ensure that the split microservices can be seamlessly integrated and continue to provide the original functions.

[0036] like Figure 2 As shown, the embodiment of the present application also provides a combined deployment device for microservices of an Internet of Things platform, including:

[0037] at least one processor; and,

[0038] a memory communicatively connected to at least one processor; wherein,

[0039] The memory stores instructions that can be executed by at least one processor, and the instructions are executed by at least one processor to enable a combined deployment device of an Internet of Things platform microservices to perform:

[0040] Determine a microservice managed by a Maven project, and parse a file using the microservice to identify a relationship pattern of the microservice, where the relationship pattern includes a parent-child relationship and a dependency relationship;

[0041] Determine a node class and an edge class, and determine a data structure according to the node class and the edge class, so as to describe the relationship of the microservices according to the data structure;

[0042] Traversing the file to determine dependencies, and determining node objects and edge objects corresponding to the dependencies, adding the node objects to the corresponding first set, and adding the edge objects to the corresponding second set;

[0043] A dependency graph is determined according to the data structure, the first set and the second set are added to the dependency graph to construct a dependency network, and detection is performed during the construction of the dependency network.

[0044] The embodiment of the present application further provides a non-volatile computer storage medium storing computer executable instructions, wherein the computer executable instructions are configured as follows:

[0045] Determine a microservice managed by a Maven project, and parse a file using the microservice to identify a relationship pattern of the microservice, where the relationship pattern includes a parent-child relationship and a dependency relationship;

[0046] Determine a node class and an edge class, and determine a data structure according to the node class and the edge class, so as to describe the relationship of the microservices according to the data structure;

[0047] Traversing the file to determine dependencies, and determining node objects and edge objects corresponding to the dependencies, adding the node objects to the corresponding first set, and adding the edge objects to the corresponding second set;

[0048] A dependency graph is determined according to the data structure, the first set and the second set are added to the dependency graph to construct a dependency network, and detection is performed during the construction of the dependency network.

[0049] In the 1990s, it was very clear whether the improvement of a technology was a hardware improvement (for example, improvements to the circuit structure of diodes, transistors, switches, etc.) or a software improvement (improvement of the method flow). However, with the development of technology, many improvements in the method flow today can be regarded as direct improvements in the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved method flow into the hardware circuit. Therefore, it cannot be said that the improvement of a method flow cannot be implemented using a hardware entity module. For example, a programmable logic device (PLD) (such as a field programmable gate array (FPGA)) is such an integrated circuit whose logical function is determined by the user's programming of the device. Designers can "integrate" a digital system on a PLD by programming it themselves, without having to ask a chip manufacturer to design and produce a dedicated integrated circuit chip. Moreover, nowadays, instead of manually making integrated circuit chips, this kind of programming is mostly implemented by "logic compiler" software, which is similar to the software compiler used when developing and writing programs. The original code before compilation must also be written in a specific programming language, which is called hardware description language (HDL). There is not only one HDL, but many kinds, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc. The most commonly used ones are VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art should also know that it is only necessary to program the method flow slightly in the above-mentioned hardware description languages ​​and program it into the integrated circuit, and then it is easy to obtain the hardware circuit that implements the logic method flow.

[0050] The controller can be implemented in any appropriate manner, for example, the controller can take the form of a microprocessor or processor and a computer-readable medium storing a computer-readable program code (such as software or firmware) that can be executed by the (micro)processor, a logic gate, a switch, an application-specific integrated circuit (ASIC), a programmable logic controller, and an embedded microcontroller. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicone Labs C8051F320. The memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art also know that in addition to implementing the controller in a purely computer-readable program code manner, the controller can be implemented in the form of a logic gate, a switch, an application-specific integrated circuit, a programmable logic controller, and an embedded microcontroller by logically programming the method steps. Therefore, this controller can be considered as a hardware component, and the devices included therein for implementing various functions can also be regarded as structures within the hardware component. Or even, the devices for implementing various functions can be regarded as both software modules for implementing the method and structures within the hardware component.

[0051] The systems, devices, modules or units described in the above embodiments may be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0052] For the convenience of description, the above device is described in various units according to their functions. Of course, when implementing this specification, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0053] Each embodiment in this application is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the device and medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiments.

[0054] The devices and media provided in the embodiments of the present application correspond one-to-one to the methods. Therefore, the devices and media also have similar beneficial technical effects as the corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

[0055] Those skilled in the art will appreciate that the embodiments of the present application may be provided as methods, systems, or computer program products. Therefore, the present application may adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment in combination with software and hardware. Moreover, the present application may adopt the form of a computer program product implemented in one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) that include computer-usable program code.

[0056] The present application is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0057] These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.

[0058] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing instructions for implementing the process. Figure 1 A process or multiple processes and / or boxes Figure 1 The steps for the functions specified in one or more boxes.

[0059] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0060] The memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. The memory is an example of a computer-readable medium.

[0061] Computer readable media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk read-only memory (CD-ROM), digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include temporary computer readable media (transitory media), such as modulated data signals and carrier waves.

[0062] It should also be noted that the term "includes", "comprising" or any other variation thereof is intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. In the absence of further restrictions, an element defined by the sentence "comprising a ..." does not exclude the existence of other identical elements in the process, method, commodity or device including the element.

[0063] The above are only embodiments of the present application and are not intended to limit the present application. For those skilled in the art, the present application may have various changes and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included within the scope of the claims of the present application.< / dependency> < / artifactid> < / groupid> < / dependency> < / version> < / artifactid> < / groupid>

Claims

1. A method for merging and deploying microservices on an Internet of Things platform, characterized in that: include: Determine a microservice managed by a Maven project, and parse a file using the microservice to identify a relationship pattern of the microservice, where the relationship pattern includes a parent-child relationship and a dependency relationship; Determine a node class and an edge class, and determine a data structure according to the node class and the edge class, so as to describe the relationship of the microservices according to the data structure; Traversing the file to determine dependencies, and determining node objects and edge objects corresponding to the dependencies, adding the node objects to the corresponding first set, and adding the edge objects to the corresponding second set; A dependency graph is determined according to the data structure, the first set and the second set are added to the dependency graph to construct a dependency network, and detection is performed during the construction of the dependency network.

2. The method according to claim 1, characterized in that The method further comprises: The dependency graph is traversed to determine common dependencies of the microservices, and the common dependencies are integrated into a predetermined common base.

3. The method according to claim 1, characterized in that The method further comprises: Determine multiple configuration information of the microservice, and determine repeated configuration items in the multiple configuration information; The repeated configuration items are merged, conflict reminder information is determined, and the conflict reminder information is sent to the user.

4. The method according to claim 1, characterized in that: The method further comprises: A preset service simulation function is determined, and communication is performed according to the service simulation function.

5. The method according to claim 1, characterized in that The method further comprises: Determine the class loader corresponding to the microservice, and determine the corresponding class path through the class loader; The class file of the microservice is loaded according to the class path.

6. The method according to claim 5, characterized in that The method further comprises: Determining a common base through the class loader, the common base including shared dependencies; Determine the dependency relationship corresponding to the microservice, and start the microservice through the class loader.

7. The method according to claim 1, characterized in that The method further comprises: The merged single application is determined, and the load condition of the single application is determined, and the merging granularity is changed according to the load condition.

8. The method according to claim 7, characterized in that The method further comprises: Determine the operating environment of the single application to determine key indicators according to the operating environment, wherein the operating environment includes CPU usage, memory occupancy, and network bandwidth; The key indicator is compared with a preset threshold value, and if the key indicator exceeds the threshold value, a splitting strategy is triggered to split the microservices in the monolithic application.

9. A device for merging and deploying microservices on an Internet of Things platform, characterized in that: include: at least one processor; as well as, a memory communicatively connected to the at least one processor; wherein, The memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the IoT platform microservices merging deployment device to execute: Determine a microservice managed by a Maven project, and parse a file using the microservice to identify a relationship pattern of the microservice, where the relationship pattern includes a parent-child relationship and a dependency relationship; Determine a node class and an edge class, and determine a data structure according to the node class and the edge class, so as to describe the relationship of the microservices according to the data structure; Traversing the file to determine dependencies, and determining node objects and edge objects corresponding to the dependencies, adding the node objects to the corresponding first set, and adding the edge objects to the corresponding second set; A dependency graph is determined according to the data structure, the first set and the second set are added to the dependency graph to construct a dependency network, and detection is performed during the construction of the dependency network.

10. A non-volatile computer storage medium storing computer executable instructions, characterized in that: The computer executable instructions are configured to: Determine a microservice managed by a Maven project, and parse a file using the microservice to identify a relationship pattern of the microservice, where the relationship pattern includes a parent-child relationship and a dependency relationship; Determine a node class and an edge class, and determine a data structure according to the node class and the edge class, so as to describe the relationship of the microservices according to the data structure; Traversing the file to determine dependencies, and determining node objects and edge objects corresponding to the dependencies, adding the node objects to the corresponding first set, and adding the edge objects to the corresponding second set; A dependency graph is determined according to the data structure, the first set and the second set are added to the dependency graph to construct a dependency network, and detection is performed during the construction of the dependency network.

Citation Information

Cited By

  • Service-oriented distributed resource automatic extraction and packaging method and server

    CN120892082A

  • Service-oriented distributed resource automatic extraction and packaging method and server

    CN120892082B