CN117971313A - Conversion method, system and storage medium for micro service to monomer service package - Google Patents
Conversion method, system and storage medium for micro service to monomer service package Download PDFInfo
- Publication number
- CN117971313A CN117971313A CN202410134978.0A CN202410134978A CN117971313A CN 117971313 A CN117971313 A CN 117971313A CN 202410134978 A CN202410134978 A CN 202410134978A CN 117971313 A CN117971313 A CN 117971313A
- Authority
- CN
- China
- Prior art keywords
- service
- micro
- item
- monomer
- services
- 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
- 239000000178 monomer Substances 0.000 title claims abstract description 48
- 238000000034 method Methods 0.000 title claims abstract description 38
- 238000006243 chemical reaction Methods 0.000 title claims abstract description 24
- 230000001419 dependent effect Effects 0.000 claims abstract description 15
- 238000004590 computer program Methods 0.000 claims description 10
- 230000008569 process Effects 0.000 claims description 5
- 238000011426 transformation method Methods 0.000 claims 1
- 238000011161 development Methods 0.000 abstract description 7
- 230000009286 beneficial effect Effects 0.000 abstract description 2
- 238000007726 management method Methods 0.000 description 20
- 230000006870 function Effects 0.000 description 11
- 235000010627 Phaseolus vulgaris Nutrition 0.000 description 5
- 244000046052 Phaseolus vulgaris Species 0.000 description 5
- 230000006978 adaptation Effects 0.000 description 4
- 230000009471 action Effects 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- VYPSYNLAJGMNEJ-UHFFFAOYSA-N silicon dioxide Inorganic materials O=[Si]=O VYPSYNLAJGMNEJ-UHFFFAOYSA-N 0.000 description 3
- 235000006719 Cassia obtusifolia Nutrition 0.000 description 2
- 235000014552 Cassia tora Nutrition 0.000 description 2
- 230000005540 biological transmission Effects 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 239000010453 quartz Substances 0.000 description 2
- 244000277285 Cassia obtusifolia Species 0.000 description 1
- 244000201986 Cassia tora Species 0.000 description 1
- 239000003795 chemical substances by application Substances 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000013499 data model Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 239000000463 material Substances 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000012856 packing Methods 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000012827 research and development Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/76—Adapting program code to run in a different environment; Porting
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
- G06F9/449—Object-oriented method invocation or resolution
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The application provides a conversion method from micro service to monomer service package, comprising the following steps: acquiring micro services; adding a reference item corresponding to the micro-service in a dependent file of the monomer item; the reference items include interface references, data access references, configuration references, and public service references; adding data sources corresponding to each micro service in the single item, and establishing a reference relation between each micro service and the corresponding data source; and (5) customizing class names of all the micro services to obtain a monomer service package. According to the application, the source code of the micro service is not required to be changed, the micro service function is synthesized into a single program to be packaged and deployed by adding the reference item and the data source of the micro service, so that the problem that codes developed by a distributed micro service architecture are directly packaged and applied to the single architecture can be solved, different application scenes can be adapted, development manpower is saved, and development cost is reduced. The application also provides a conversion system from the micro service to the monomer service package, a storage medium and electronic equipment, which have the beneficial effects.
Description
Technical Field
The application relates to the technical field of computers, in particular to a method, a system, a storage medium and electronic equipment for converting micro services into monomer service packages.
Background
The micro-service architecture and the single architecture are two different application program architectures, the current mainstream server software development adopts a distributed micro-service architecture, and the distributed micro-service architecture is matched with various middleware for use, has the characteristics of high performance, high availability, high scalability, high expansibility and the like, can cope with high concurrency scenes, but relatively needs a large amount of server resources to deploy distributed programs and middleware, so that the architecture is suitable for clients with large volume, business volume and user volume.
In the fields of industry and Internet of things, some clients with smaller volumes exist, the user volume of the clients is not high, the server resources are limited, and the daily use can be met by only deploying a single service and a small number of necessary middleware. For this scenario, the distributed microservice architecture is no longer applicable, and an additional development of a single architecture system is required.
However, under the condition of similar service requirements, two sets of systems are developed aiming at the scene, so that on one hand, manpower and material resources are consumed, and on the other hand, additional maintenance and management are needed, and the research and development cost is increased intangibly. Therefore, how to apply code developed by a distributed micro-service architecture to a monolithic architecture system is a problem to be solved in the art.
Disclosure of Invention
The application aims to provide a method, a system, a storage medium and electronic equipment for converting micro services into monomer service packages, which can convert the micro services into the monomer services for application.
In order to solve the technical problems, the application provides a method for converting a micro service into a monomer service package, which comprises the following specific technical scheme:
Acquiring micro services;
adding a reference item corresponding to the micro-service in a dependent file of the monomer item; the reference items comprise an interface reference, a data access reference, a configuration reference and a public service reference;
adding data sources corresponding to the micro services in the single item, and establishing a reference relation between the micro services and the corresponding data sources;
and customizing class names of the micro services to obtain the monomer service package.
Optionally, the acquiring the microservice includes:
adding a micro-service to a project management tool, and managing the micro-service by utilizing a project object model in the project management tool; the project management model is used for determining the structure and the attribute corresponding to the micro-service through the configuration file.
Optionally, adding the reference item corresponding to the micro-service in the dependent file of the monomer item includes:
And adding the reference item of each micro service by using the item management tool.
Optionally, the acquiring the microservice includes:
and acquiring the micro-service by using the command line command, and positioning the jar packet address corresponding to the micro-service.
Optionally, after adding the reference item corresponding to the micro service in the dependent file, the method further includes:
And deleting the reference items of useless dependency packages in the dependency files.
Optionally, establishing a reference relationship between each micro service and a corresponding data source includes:
determining a name of the micro service;
And establishing a reference relation between the name and the data source.
Optionally, after obtaining the monomer service package, the method includes:
the monomer service package is applied, and a configuration file is called to detect whether a program middleware exists;
If so, applying the program middleware;
if not, the program middleware is replaced by the local parameters in the monomer service package.
The application also provides a conversion system from micro service to monomer service package, comprising:
the micro-service acquisition module is used for acquiring micro-services;
The reference item configuration module is used for adding the reference item corresponding to the micro-service in the dependent file of the single item; the reference items comprise an interface reference, a data access reference, a configuration reference and a public service reference;
the data source configuration module is used for adding data sources corresponding to the micro services in the single item and establishing a reference relation between the micro services and the corresponding data sources;
and the generation module is used for customizing the class name of each micro service to obtain the single service package.
The application also provides a computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, implements the steps of the conversion method as described above.
The application also provides an electronic device comprising a memory in which a computer program is stored and a processor which when calling the computer program in the memory implements the steps of the conversion method as described above.
The application provides a conversion method from micro service to monomer service package, comprising the following steps: acquiring micro services; adding a reference item corresponding to the micro-service in a dependent file of the monomer item; the reference items comprise an interface reference, a data access reference, a configuration reference and a public service reference; adding data sources corresponding to the micro services in the single item, and establishing a reference relation between the micro services and the corresponding data sources; and customizing class names of the micro services to obtain the monomer service package.
According to the application, the source code of the micro service is not required to be changed, the micro service function is synthesized into a single program to be packaged and deployed by adding the reference item and the data source of the micro service, so that the problem that codes developed by a distributed micro service architecture are directly packaged and applied to the single architecture can be solved, different application scenes can be adapted, two sets of systems are not required to be developed for adaptation, the development labor is saved, and the development cost is reduced.
The application also provides a conversion system from micro service to monomer service package, a storage medium and electronic equipment, which have the beneficial effects and are not repeated here.
Drawings
In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings that are required to be used in the embodiments or the description of the prior art will be briefly described below, and it is obvious that the drawings in the following description are only embodiments of the present application, and that other drawings can be obtained according to the provided drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flow chart of a method for converting micro services into single service packages according to an embodiment of the present application;
fig. 2 is a schematic diagram of a conversion system from micro services to single service packages according to an embodiment of the present application.
Detailed Description
For the purpose of making the objects, technical solutions and advantages of the embodiments of the present application more apparent, the technical solutions of the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application, and it is apparent that the described embodiments are some embodiments of the present application, but not all embodiments of the present application. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to be within the scope of the application.
Referring to fig. 1, fig. 1 is a flowchart of a method for converting a micro service into a monomer service package according to an embodiment of the application, where the method includes:
S101: acquiring micro services;
The single architecture corresponding to the micro service and the single service package belongs to two different software architecture modes. The modules in the micro service are mutually independent, and each module uses different corresponding data models. All modules in the single architecture are coupled, and the code amount is large. Therefore, the micro-service is more flexible and has higher independence, and each module can be independently developed and deployed. In order to directly apply the micro-service and avoid writing corresponding program codes for the functions of the micro-service again, the embodiment of the application aims to convert the micro-service into a single service package, thereby directly applying the single service package, and being suitable for application scenes with smaller running resources.
This step aims at obtaining the micro-services that are required by the user. The method is not limited to how to acquire the micro-service, and a feasible method can directly acquire the micro-service by using the command line instruction and locate the jar packet address corresponding to the micro-service. Each micro-service has a jar package, and the executable file contains the contents such as running program, configuration information and the like
In another way, a project management tool may be utilized, in particular, a micro-service to be converted may be added to the project management tool, and the micro-service may be managed using a project object model in the project management tool. The project management model is used for determining the structure and the attribute corresponding to the micro-service through the configuration file. There is no limitation as to what project management tool is used, for example, maven is a project management tool that contains a project object model (Project Object Model), a set of criteria, a project lifecycle (Project Lifecycle), a dependency management system (DEPENDENCY MANAGEMENT SYSTEM), and logic for running plug-in targets defined in the lifecycle stages.
S102: adding a reference item corresponding to the micro-service in a dependent file of the monomer item;
This step requires the addition of an introduction of the microservice in a monomer item. The monomer item refers to an intermediate file before the generation of the monomer service package. The reference term refers to a dependency between various modules or components in a monolithic architecture, including but not limited to functions, classes, interfaces, and the like. In order to apply a micro-service in a monolithic architecture, this step requires configuration of reference items of the micro-service, including specifically interface references, data access references, configuration references, and common service references, i.e., reference relationships between the micro-service and other micro-services, or existing module components. The following description is made for each reference:
Interface reference: in a monolithic service architecture, different services typically communicate through interfaces. The service provider defines the interface and implements the functionality therein. Other services call the corresponding functions through interface references when they need to use the functions.
Data access reference: in a monolithic service architecture, individual services may involve access and manipulation of data. For example, a service may need to read data from or write data to a database. To achieve these operations, the service needs to reference data access functions provided by other services.
Configuration reference: in a single service architecture, configuration information of each service is generally centrally managed. Other services need to read this configuration information at runtime in order to properly run and invoke the functions of the other services. Such configuration information may be obtained by referencing configuration items.
Public service reference: in a monolithic service architecture, some common services may be shared by multiple other services. For example, common services such as logging, error handling, security authentication, etc. may be referenced and used by a number of other services. These common services are typically provided in the form of libraries or components and are referenced by other services.
If the project management tool is applied in the previous step, maven is taken as an example, when the reference item is added, the reference item can be directly added in the dependency file pon. Dependency file pom.xml is the core configuration file of the Maven project. This file is used to define various properties and configurations of items, including the coordinates of the items (e.g., groupId, artifactId and version), dependencies of the items, plug-ins, and so forth. When maven is applied, a plurality of micro services can be added simultaneously for parallel processing, and one or a plurality of single service packages can be generated correspondingly.
If the project management tool is not applied, the application program code can be directly applied to add the reference item corresponding to the micro-service.
On the basis of the embodiment of the application, as a preferred embodiment, after the reference item corresponding to the micro service is added in the dependent file, the reference item of the useless dependent package in the dependent file can be deleted.
S103: adding data sources corresponding to the micro services in the single item, and establishing a reference relation between the micro services and the corresponding data sources;
The step aims at adding a data source, and it should be noted that each module in the monomer architecture usually refers to one data source, but in order to package the micro service into a monomer service package and ensure the normal operation of the micro service after being converted into the monomer service package, the embodiment needs to add the data source corresponding to each service in a monomer project. That is, the generated monomer service contains at least one data source, and if different micro services use the same database, the different micro services can be simultaneously set up with one data source in a reference relationship.
It should also be noted that in order to solve the problem of multi-data source compatibility in a single project during the execution of this step, various data compatibility measures may be adopted. For example, a unified data exchange format may be defined, ensuring that a unified data exchange format, such as json or XML format, is used between different microservices. Or introducing data transmission middleware such as APACHE KAFKA or Redis and the like to coordinate data transmission among different micro services. An abstract data access layer may also be created for each micro-service, which is responsible for interacting with a particular data source. Those skilled in the art may also adopt other ways to implement the multiple data source compatibility problem in the monomer project, not by way of example.
After the data sources corresponding to the micro services are added, the names of the micro services can be determined first, and then the reference relation between the names and the data sources is established.
S104: and customizing class names of the micro services to obtain the monomer service package.
This step aims at customizing the class name of the micro-service, and in order to avoid confusion of use caused by similar names and even the same micro-service, the class name of the micro-service can be redefined. Specifically, by solving the different microservice class name duplication problem through custom nameGenerator, nameGenerator can automatically generate a name or identifier.
In addition, the bean package required by the control program can be scanned through the ComponentScan component. Bean packages are packages for storing JavaBean. A Java bean is a reusable component written in the Java language for encapsulating multiple objects as a single component. ComponentScan components are used to automatically scan and load the eligible components. Therefore, the bean package with repeated class names can be screened, and nameGenerator renames can be called, so that class name customization of each micro service is realized.
In a Bean package, there are typically included classes with specific functions that have some common properties and methods for interacting and communicating with other components or modules. Unnecessary bean classes can also be excluded by configuration excludeFilters.
According to the embodiment of the application, the source code of the micro service is not required to be changed, the micro service function is synthesized into a single program for packing and deployment by adding the reference item and the data source of the micro service, the problem that codes developed by a distributed micro service architecture are directly packed and applied to the single architecture can be solved, different application scenes can be adapted, two sets of systems are not required to be developed for adaptation, the development labor is saved, and the development cost is reduced.
The following describes a specific application procedure of the monomer service package obtained in the above embodiment:
After the monomer service package is obtained, the monomer service package can be applied. In the application process, a configuration file can be called to detect whether the program middleware exists;
If so, applying the program middleware;
if not, the program middleware is replaced by the local parameters in the monomer service package.
The program middleware is software between the application system and the system software, uses basic services (functions) provided by the system software, and is connected with various parts of the application system or different applications on the network, so that the purposes of resource sharing and function sharing can be achieved. It is not very strictly defined, but the definition of IDC is generally accepted: middleware is a separate system software service by which distributed application software shares resources among different technologies, and is located on top of the client server's operating system, managing computing resources and network communications.
The single service package obtained by the application can be combined with the code architecture such as the public component, the interface agent and the like to realize the compatibility of different middleware environments. The common components may be implemented by common service references in the above embodiments. When the monomer service package obtained by micro service conversion is applied:
If there is no registry, the fixed url call feign interface is used. The Feign interface is a declarative Web Service client. When a registry exists, feign interface obtains url through the registry. If the registry does not exist, the fixed url is obtained from the configuration file for access.
Built-in caches of the monolithic architecture are used without redis.
Without the timing database, mysql in the monomer service package may be used to store data.
Without object storage, local file storage may be used.
Message queues support the modes of Mqtt, kafka, etc., and without flink, internal threads are used to handle real-time computation. Flink is a distributed stream processing framework for stateful computation on unbounded and bounded data streams. After converting the micro-services into the single service package, internal threads may be used instead of flink.
Without xxl-job, the quartz component in the single service package may be used to implement the timing tasks. Xxl-job is a lightweight distributed task scheduling platform. The method is mainly used for processing distributed timing tasks and mainly comprises a dispatching center and an executor. While in the application of the monomer service package, a quartz component may be used, which may be used to perform timing tasks in the java application. It provides a flexible API interface that allows tasks to be easily created, configured, and scheduled.
It can be seen that in the case of the smallest unit, the monomer service package converted by the present application can be run by only one mysql database.
The following describes a conversion system from micro service to single service package provided by an embodiment of the present application, and the conversion system described below and the conversion method from micro service to single service package described above may be referred to correspondingly.
Referring to fig. 2, fig. 2 is a schematic structural diagram of a conversion system from micro service to single service package according to an embodiment of the present application, and the present application further provides a conversion system from micro service to single service package, including:
the micro-service acquisition module is used for acquiring micro-services;
The reference item configuration module is used for adding the reference item corresponding to the micro-service in the dependent file of the single item; the reference items comprise an interface reference, a data access reference, a configuration reference and a public service reference;
the data source configuration module is used for adding data sources corresponding to the micro services in the single item and establishing a reference relation between the micro services and the corresponding data sources;
and the generation module is used for customizing the class name of each micro service to obtain the single service package.
Based on the above embodiments, as a preferred embodiment, the micro service acquisition module includes:
A first acquisition unit configured to add a micro-service to a project management tool, the micro-service being managed using a project object model in the project management tool; the project management model is used for determining the structure and the attribute corresponding to the micro-service through the configuration file.
Based on the above embodiments, as a preferred embodiment, the referencing item configuration module includes:
And the reference item adding unit is used for adding the reference item of each micro service by using the item management tool.
Based on the above embodiments, as a preferred embodiment, the micro service acquisition module includes:
And the second acquisition unit is used for acquiring the micro-service by utilizing the command line command and positioning the jar packet address corresponding to the micro-service.
Based on the above embodiment, as a preferred embodiment, further comprising:
And the reference item management unit is used for deleting the reference items of useless dependency packages in the dependency files.
Based on the above embodiments, as a preferred embodiment, the data source configuration module includes:
A reference relation configuration unit, configured to determine a name of the micro service; and establishing a reference relation between the name and the data source.
Based on the above embodiment, as a preferred embodiment, further comprising:
The application configuration module is used for applying the single service package and calling a configuration file to detect whether a program middleware exists or not; if so, applying the program middleware; if not, the program middleware is replaced by the local parameters in the monomer service package.
The present application also provides a computer-readable storage medium having stored thereon a computer program which, when executed, performs the steps provided by the above-described embodiments. The storage medium may include: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
The application also provides an electronic device, which can comprise a memory and a processor, wherein the memory stores a computer program, and the processor can realize the steps provided by the embodiment when calling the computer program in the memory. Of course the electronic device may also include various network interfaces, power supplies, etc.
In the description, each embodiment is described in a progressive manner, and each embodiment is mainly described by the differences from other embodiments, so that the same similar parts among the embodiments are mutually referred. The system provided by the embodiment is relatively simple to describe as it corresponds to the method provided by the embodiment, and the relevant points are referred to in the description of the method section.
The principles and embodiments of the present application have been described herein with reference to specific examples, the description of which is intended only to facilitate an understanding of the method of the present application and its core ideas. It should be noted that it will be apparent to those skilled in the art that various modifications and adaptations of the application can be made without departing from the principles of the application and these modifications and adaptations are intended to be within the scope of the application as defined in the following claims.
It should also be noted that in this specification, relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
Claims (10)
1. A method for converting a micro service to a single service package, comprising:
Acquiring micro services;
adding a reference item corresponding to the micro-service in a dependent file of the monomer item; the reference items comprise an interface reference, a data access reference, a configuration reference and a public service reference;
adding data sources corresponding to the micro services in the single item, and establishing a reference relation between the micro services and the corresponding data sources;
and customizing class names of the micro services to obtain the monomer service package.
2. The conversion method according to claim 1, wherein the acquiring the microservice comprises:
adding a micro-service to a project management tool, and managing the micro-service by utilizing a project object model in the project management tool; the project management model is used for determining the structure and the attribute corresponding to the micro-service through the configuration file.
3. The conversion method according to claim 2, wherein adding the reference item corresponding to the micro-service in the dependent file of the monomer item comprises:
And adding the reference item of each micro service by using the item management tool.
4. The conversion method according to claim 1, wherein the acquiring the microservice comprises:
and acquiring the micro-service by using the command line command, and positioning the jar packet address corresponding to the micro-service.
5. The conversion method according to claim 1, further comprising, after adding the reference item corresponding to the micro service in the dependent file:
And deleting the reference items of useless dependency packages in the dependency files.
6. The transformation method of claim 1, wherein establishing a reference relationship between each of the micro services and a corresponding data source comprises:
determining a name of the micro service;
And establishing a reference relation between the name and the data source.
7. The conversion process according to any one of claims 1 to 6, wherein after obtaining the monomer service package comprises:
the monomer service package is applied, and a configuration file is called to detect whether a program middleware exists;
If so, applying the program middleware;
if not, the program middleware is replaced by the local parameters in the monomer service package.
8. A micro-service to mono-service package conversion system, comprising:
the micro-service acquisition module is used for acquiring micro-services;
The reference item configuration module is used for adding the reference item corresponding to the micro-service in the dependent file of the single item; the reference items comprise an interface reference, a data access reference, a configuration reference and a public service reference;
the data source configuration module is used for adding data sources corresponding to the micro services in the single item and establishing a reference relation between the micro services and the corresponding data sources;
and the generation module is used for customizing the class name of each micro service to obtain the single service package.
9. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, carries out the steps of the conversion method according to any one of claims 1-7.
10. An electronic device comprising a memory and a processor, the memory having a computer program stored therein, the processor implementing the steps of the conversion method according to any of claims 1-7 when the computer program in the memory is invoked by the processor.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410134978.0A CN117971313A (en) | 2024-01-31 | 2024-01-31 | Conversion method, system and storage medium for micro service to monomer service package |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410134978.0A CN117971313A (en) | 2024-01-31 | 2024-01-31 | Conversion method, system and storage medium for micro service to monomer service package |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117971313A true CN117971313A (en) | 2024-05-03 |
Family
ID=90860699
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410134978.0A Pending CN117971313A (en) | 2024-01-31 | 2024-01-31 | Conversion method, system and storage medium for micro service to monomer service package |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117971313A (en) |
-
2024
- 2024-01-31 CN CN202410134978.0A patent/CN117971313A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8271609B2 (en) | Dynamic service invocation and service adaptation in BPEL SOA process | |
| CN112035228B (en) | Resource scheduling method and device | |
| US10296297B2 (en) | Execution semantics for sub-processes in BPEL | |
| JP2007538313A (en) | System and method for modeling and dynamically deploying services within a distributed networking architecture | |
| US10089084B2 (en) | System and method for reusing JavaScript code available in a SOA middleware environment from a process defined by a process execution language | |
| US10803413B1 (en) | Workflow service with translator | |
| CN105975261B (en) | A kind of runtime system and operation method called towards unified interface | |
| CN113688186B (en) | Intelligent contract execution method, engine and block link point | |
| CN112685020A (en) | Method and device for dynamically creating service interface, electronic equipment and storage medium | |
| US9552239B2 (en) | Using sub-processes across business processes in different composites | |
| Taherkordi et al. | Programming sensor networks using REMORA component model | |
| US10223143B2 (en) | System and method for supporting javascript as an expression language in a process defined by a process execution language for execution in a SOA middleware environment | |
| US10268496B2 (en) | System and method for supporting object notation variables in a process defined by a process execution language for execution in a SOA middleware environment | |
| CN111324395B (en) | Calling method, device and computer readable storage medium | |
| Deng et al. | Evolution in model-driven software product-line architectures | |
| US7584302B1 (en) | Business integration component for containers | |
| CN117971313A (en) | Conversion method, system and storage medium for micro service to monomer service package | |
| US9141383B2 (en) | Subprocess definition and visualization in BPEL | |
| Srinivasmurthy et al. | Web2exchange: A model-based service transformation and integration environment | |
| Nowak et al. | An Overview on Implicit Green Business Process Patterns | |
| US10223142B2 (en) | System and method for supporting javascript activities in a process defined by a process execution language for execution in a SOA middleware environment | |
| US8918451B2 (en) | System and method for providing service component architecture (SCA) data transformation | |
| Braubach et al. | Macro Architecture for Microservices: Improving Internal Quality of Microservice Systems | |
| Liu et al. | Composition of engineering web services with distributed data-flows and computations | |
| Krishnan | An architecture for checkpointing and migration of distributed components on the grid |
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 |