WO2020063252A1

WO2020063252A1 - Method and device for isolating multiple version dependency

Info

Publication number: WO2020063252A1
Application number: PCT/CN2019/103533
Authority: WO
Inventors: 韩晓飞
Original assignee: 京东数字科技控股有限公司
Priority date: 2018-09-29
Filing date: 2019-08-30
Publication date: 2020-04-02
Also published as: CN110968340A

Abstract

The present invention relates to the technical field of computers, and disclosed thereby are a method and device for isolating multiple version dependency. A specific embodiment of the method comprises: adding an annotation in a method to be isolated; placing a dependency package that must be referenced in the method to be isolated into a reference directory file, the annotation corresponding one-to-one to a reference directory; determining the reference directory file in which the dependency package is placed according to the annotation when executing the method to be isolated; loading the dependency package in the reference directory file by using a custom class loader. The specific embodiment is capable of solving problems such as the degree of coupling being too high which occurs when carrying out dependency isolation by using spring boot, thereby achieving the the technical effect of multiple dependent versions coexisting without distinguishing item type and guaranteeing that each version dependency normally provides functions, while a run dependent version may be switched in real time to prevent a system not using an upgrade function from hijacking an upgrade.

Description

Method and device for implementing multi-version dependency isolation

Technical field

The present invention relates to the field of computer technology, and in particular, to a method and device for implementing multi-version dependency isolation.

Background technique

In large and complex business systems, in order to improve the conciseness, generality, and reuse of the code, the common functional parts are packaged into jar packages for reference by systems with the same business functions. This can effectively avoid repeated development and reduce R & D investment. This is called third-party dependency. Another type of dependency With the promotion of microservices and SOA, each system is cut from multiple dimensions such as functions, responsibilities, business attributes, and domain models. A complete functional closed loop requires multiple systems to cooperate to complete. The system needs to expose its own API jar as its own entry point for external output functions, so as to complete a complete function, which is an internal dependency. Both internal and external dependencies require version maintenance of the referenced jars, and usually spring isolation is used for dependency isolation.

In the process of implementing the present invention, the inventors found that at least the following problems exist in the prior art:

1. Dependency isolation using spring boot must require that the project is a spring boot project and must be compiled with the spring boot compilation plugin to take effect.

2.Spring itself is a third-party dependency, and it has many indirect dependencies that are not conducive to the upgrade and maintenance of later business systems, and the coupling is too tight.

3. For each update of internal dependencies, all the relying parties need to be notified. Even if the party does not use the function of this upgrade, it needs to synchronize the upgrade.

4. Dependence on external (third party) cannot change its internal indirect dependency and the stripping or neglect of the upgrade function, and it is difficult to guarantee the normal function of the previous system.

Summary of the Invention

In view of this, the embodiments of the present invention provide a method and device for implementing multi-version dependency isolation, which can solve the problem that the project appearing in the process of using dependency isolation for spring boot must be a spring boot project, and a spring plugin must be used to compile the plug-in and coupling. The problem is too high.

To achieve the above object, according to an aspect of the embodiment of the present invention, a method for implementing multi-version dependency isolation is provided, which includes: adding a comment to a method to be isolated; and placing a dependency package to be referenced in the method to be isolated to In the reference directory file; the annotation corresponds to the reference directory one by one; when the method to be isolated is executed, the reference directory file in which the dependent package is placed is determined according to the annotation; and a custom class loader is used to load the reference directory file Describes the dependencies in a directory file.

According to another aspect of the embodiments of the present invention, a method for implementing multi-version dependency isolation is provided, which includes: using a custom class loader to load a dependency package to obtain an object instance of the dependency package; starting a container and initializing the container. The function processor registers the dependent package object instance into the functional processor; when executing the method to be isolated, if a reference needs to be referenced, the dependent package object instance is removed from the functional processor and executed.

According to still another aspect of the embodiments of the present invention, a device for implementing multi-version dependency isolation is provided, including: an annotation module for adding annotations to a method to be isolated; and a placing module for: isolating the method to be isolated The dependent packages that need to be referenced are placed in the reference directory file; the annotations correspond to the reference directories one by one; an execution module is configured to: when executing the method to be isolated, determine the placement of the dependent packages according to the annotations A reference directory file; a loading module, configured to: use a custom class loader to load a dependent package in the reference directory file.

According to still another aspect of the embodiments of the present invention, a device for implementing multi-version dependency isolation is provided, including: a loading module, configured to: use a custom class loader to load a dependent package to obtain an object instance of the dependent package; a registration module For: starting a container and initializing a function processor in the container, registering the dependent package object instance in the function processor; a reference module, for: when executing a method to be isolated, if a dependency needs to be referenced, Then take out and execute the dependent package object instance from the function processor.

According to still another aspect of the embodiments of the present invention, there is provided an electronic device including: one or more processors; a storage device for storing one or more programs, and when the one or more programs are used by the one Or multiple processors, so that the one or more processors implement the method for implementing multi-version dependency isolation as proposed in the embodiment of the present invention.

According to still another aspect of the embodiments of the present invention, there is provided a computer-readable medium on which a computer program is stored, and when the program is executed by a processor, the method for implementing multi-version dependency isolation as proposed in the embodiment of the present invention is implemented.

An embodiment of the above invention has the following advantages or beneficial effects: Because the technical means of adding annotations are used, the projects that can be solved in the process of using spring boot for dependency isolation must be spring boot projects, and spring plugins must be used to compile plugins And the degree of coupling is too high, which achieves the technical effect of relying on coexistence of multiple versions without distinguishing project types and ensuring that the versions rely on normal provision of functions. At the same time, the running dependent version can be switched in real time to avoid system abduction without the upgrade function. upgrade.

Further effects of the above-mentioned non-conventional alternative manners will be described below in conjunction with specific embodiments.

BRIEF DESCRIPTION OF THE DRAWINGS

The drawings are for better understanding of the present invention, and do not constitute an improper limitation on the present invention. among them:

1 is a schematic diagram of a main process of a method for implementing multi-version dependency isolation according to an embodiment of the present invention;

2 is a schematic diagram of main modules of an apparatus for implementing multi-version dependent isolation according to an embodiment of the present invention;

3 is a schematic diagram of a real-time isolation model according to an embodiment of the present invention;

4 is a schematic diagram of a module isolation model according to an embodiment of the present invention;

5 is a schematic diagram of a real-time isolation processing process according to an embodiment of the present invention;

6 is a schematic diagram of a module isolation processing process according to an embodiment of the present invention;

7 is a schematic diagram of a telnet command processing model according to an embodiment of the present invention;

FIG. 8 is a schematic diagram of combining and packaging multiple web modules into a dependent plug-in according to an embodiment of the present invention; FIG.

FIG. 9 is a system architecture diagram according to an embodiment of the present invention;

10 is a schematic diagram of a service deployment workflow according to an embodiment of the present invention;

11 is an exemplary system architecture diagram to which embodiments of the present invention can be applied;

FIG. 12 is a schematic structural diagram of a computer system suitable for implementing a terminal device or a server according to an embodiment of the present invention.

detailed description

The following describes exemplary embodiments of the present invention with reference to the accompanying drawings, which include various details of the embodiments of the present invention to facilitate understanding, and they should be considered as merely exemplary. Accordingly, those of ordinary skill in the art should recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of the invention. Also, for clarity and conciseness, descriptions of well-known functions and structures are omitted in the following description.

Glossary of technical terms

Maven: is a software project management and understanding tool. Based on the concept of the Project Object Model (POM), Maven can manage project construction, reporting, and documentation from a central information. Is an open source component of the Apache community.

Parental delegation: Refers to the Java class loading model. The higher the class loader is, the earlier the class loader loads the classes under its loading path.

In the prior art, whether it is an internal dependency or an external dependency, it is necessary to perform version maintenance on the referenced jar. Each update for internal dependencies needs to be notified to all relying parties. Even if the party does not use the function of this upgrade, it needs to synchronize the upgrade. This is usually subject to compilation rules. For external (third-party) dependencies, you cannot change its internal indirect dependencies and the stripping or neglect of the upgrade function. If the business system is a large system, it is difficult to guarantee if the high (low) version is ignored at this time. The previous function is normal.

Maven-based multi-version dependency management using spring boot in the prior art:

1. Introduce version management tools and declare all dependencies in the POM. 2. Determine whether the current reference is declared in version dependency management, and if it exists, load the declared version. 3. If 2 is not true, calculate the dependency path to find the version of the shortest path coexisting in the dependency tree. 4. If 3 does not have the shortest path, then load according to the declaration of the dependency. 5. Perform compilation and loading. 6. Repeat 2-5.

Using spring boot for dependency isolation must require that the project is a spring boot project and must be compiled with the spring boot compilation plugin to take effect. Just separating conflicting dependencies into different file directories guarantees that there are no dependency conflicts. It does not substantially resolve dependency conflicts and allows conflicting dependencies to provide functions at the same time. Spring itself is a third-party dependency, and it has many indirect dependencies that are not conducive to the upgrade and maintenance of later business systems, and the coupling is too tight.

FIG. 1 is a schematic diagram of a main process of a method for implementing multi-version dependency isolation according to an embodiment of the present invention. As shown in FIG. 1, an embodiment of the present invention provides a method for implementing multi-version dependency isolation, including:

Step S101. Add a comment to the method to be isolated;

Step S102. Place the dependent packages that need to be referenced in the method to be isolated into a reference directory file; the annotations correspond to the reference directories one by one;

Step S103. When the method to be isolated is executed, determine a reference directory file placed by the dependent package according to the annotation;

Step S104. Use a custom class loader to load the dependent packages in the reference directory file.

Because the technical means of adding annotations can be used to solve the problems that occur in the process of using spring boot for dependency isolation, the project must be a spring boot project, the plugin must be compiled using spring boot, and the degree of coupling is too high, thereby achieving no distinction between project types. Realize the coexistence of multiple versions and ensure that each version depends on the normal provision of functions. At the same time, it can switch the running dependent version in real time to avoid the technical effects of upgrading the system without using the upgrade function.

In the embodiment of the present invention, after the placing the dependent package to be referenced in the method to be isolated into a reference directory file, the method further includes: receiving a telnet command; and performing at least one of the following dependent packages on the dependent package according to the telnet command. Operations: select, traverse, add, delete, move to the backup area. Opening a telnet port for monitoring and plugging in dependencies can enable users to perform dependency isolation related operations through telnet commands, which has greater maneuverability.

In the embodiment of the present invention, before executing the method to be isolated, the method further includes: monitoring a service request, and determining a redirect address according to the service request; and determining the method to be isolated according to a domain name of the redirect address. . Multiple web modules can be implemented as a dependency plug-in, and cross-server calls are turned into internal calls for calls between internal systems.

An embodiment of the present invention provides a method for implementing multi-version dependency isolation, which includes: using a custom class loader to load a dependency package to obtain an object instance of the dependency package; starting a container and initializing a function processor in the container, and The dependent package object instance is registered in the function processor; when the method to be isolated is executed, if the dependency needs to be referenced, the dependent package object instance is taken from the function processor and executed. The embodiments of the present invention can solve the problem that the project that appears in the process of dependency isolation using spring boot must be a spring boot project, spring plugin must be used to compile plugins, and the degree of coupling is too high, so as to achieve the distinction of project types and achieve multi-version coexistence. It also guarantees that each version depends on the normal provision of functions, and at the same time, it can switch the running dependent version in real time to the technical effect, and avoid the abduction and upgrade of the system that does not use the upgrade function.

In the embodiment of the present invention, after registering the dependent package object instance in the function processor, the method further includes: receiving a telnet command; and performing at least one of the following operations on the dependent package object instance according to the telnet command: Select, traverse, add, delete, move to the backup area. Users can use the telnet command to perform dependent isolation related operations, which has greater maneuverability.

In the embodiment of the present invention, before executing the method to be isolated, the method further includes: monitoring a service request, determining a redirection address according to the service request, and determining the method to be isolated according to a domain name of the redirection address. Multiple web modules can be implemented as a dependency plug-in, and cross-server calls are turned into internal calls for calls between internal systems.

FIG. 2 is a schematic diagram of main modules of an apparatus for implementing multi-version dependent isolation according to an embodiment of the present invention. As shown in FIG. 2, an embodiment of the present invention provides a device 200 for implementing multi-version dependency isolation, including:

Annotation module 201, configured to: add annotations to the method to be isolated;

A placing module 202 is configured to: place the dependent packages to be referenced in the method to be isolated into a reference directory file; the annotations correspond to the reference directory one by one;

An execution module 203 is configured to: when executing the method to be isolated, determine a reference directory file placed by the dependent package according to the annotation;

A loading module 204 is configured to load a dependent package in the reference directory file by using a custom class loader.

In the embodiment of the present invention, the placing module 202 is further configured to: receive a telnet command; and perform at least one of the following operations on the dependent package according to the telnet command: selecting, traversing, adding, deleting, and moving to a backup area.

In the embodiment of the present invention, the execution module 204 is further configured to monitor a service request, determine a redirection address according to the service request, and determine the method to be isolated based on a domain name of the redirection address.

An embodiment of the present invention provides a device for implementing multi-version dependency isolation, including: a loading module for loading a dependent package using a custom class loader to obtain an object instance of the dependent package; and a registration module for: starting a container And initialize the function processor in the container, and register the dependent package object instance in the function processor; the reference module is used to: when executing the method to be isolated, if the dependency needs to be referenced, the function is processed from the function The processor fetches and executes the dependent package object instance.

In the embodiment of the present invention, the registration module is further configured to: receive a telnet command; perform at least one of the following operations on the dependent package object instance according to the telne command: select, traverse, add, delete, move to a backup area .

In the embodiment of the present invention, the reference module is further configured to: monitor a service request, determine a redirection address according to the service request, and determine the method to be isolated according to a domain name of the redirection address.

The device of the present invention provides two isolation schemes through a custom class loader: real-time isolation and module isolation for different business scenario requirements.

FIG. 3 is a schematic diagram of a real-time isolation model according to an embodiment of the present invention. As shown in FIG. 3, a tool kit is provided for real-time isolation of the device. The user needs to add a @isolation annotation to the method to be isolated and refer to the method by a third party Dependency packages are placed in the src / resources / isolation directory file, and URLClassLoader in the toolkit will load reference dependencies from this directory during execution.

FIG. 4 is a schematic diagram of a module isolation model according to an embodiment of the present invention; as shown in FIG. 4, a module plug-in is provided for the module isolation of the device, and the plug-in module is separately packaged into modules requiring special processing through Fat, Plugin and Facade A jar package, the original business system only needs to reference the jar. During execution, the Plugin module needs to start the container Fat. Fat will initialize the built-in function processors and register them in the container. The Facade module will register business service instances in each function processor. When referencing directly from

The module fetches the object instance.

FIG. 5 is a schematic diagram of a real-time isolation processing process according to an embodiment of the present invention; as shown in FIG. 5, a Java class is loaded by an instance of java.lang.ClassLoader. However, the class loader itself is a class so the Bootstrap class loader acts as the bootstrap class loader and is the parent of all other ClassLoader instances. It is the first loader to be executed. It mainly loads jars in the $ JAVA_HOME / jre / lib directory. Then there are Extension ClassLoader and SystemClassLoader. Since java is a parent-delegated loading mode, the subclass loader will only be called if the appealing class loader cannot load. Due to the exclusive annotation parser, the class instance after the assignment is refactored in the environment where multiple versions rely on coexistence. In most cases, jars that require special processing are placed in a fixed custom directory. The system's own class loader usually cannot load and will directly call the custom class loader to load.

6 is a schematic diagram of a module isolation process according to an embodiment of the present invention; PluginManagerService is used to coordinate plug-in management in a multi-module coexistence scenario, FacadeManagerService is used to manage instance management of business service references, ClassloaderService is used to instantiate dependent objects, and PluginDeployService is used For the plug-in release, FacadeDeployService is used to release the RegistryService for service registration. Each plug-in is a business module to maintain a dependency list. InjectionService is used to inject reference instances into the service. TelnetServerService is used to implement telnet commands and receive operation instructions.

FIG. 7 is a schematic diagram of a telnet command processing model according to an embodiment of the present invention; as shown in FIG. 7, the present invention implements a JVM-based socket and an IO package to implement a telnet command for a runtime dependent plug-in. When Fat completes the initialization of the built-in telnet processor in 1, a telnet port will be opened for monitoring and plugging the container and the plug-in in the container. The container of this device is implemented based on the java SET set. After the user successfully handshake through the telnet command, the user can send the show / stop–fat–name_version.jar / start–fat–name_version.jar command to implement the instruction operation on the container. When the Fat module receives instructions, it will choose to traverse, add, and delete (move to the backup area) services according to different instructions.

FIG. 8 is a schematic diagram of combining and packaging multiple web modules into dependent plugins according to an embodiment of the present invention; as shown in FIG. 8, multiple web modules are merged and coexist. The device of the present invention implements the integration and packaging of multiple web modules into a dependent plug-in through a built-in web server. When the user specifies that the current module is a web module, the Fat module needs to weave the interceptor APIGetwayFilter to the isolation module when it initializes the ClassLoader, and publish it as a web application after the container initialization is complete. If the business requires that the domain name of each module is different, then it needs to be used with the loader. When the loader listens to the business request, it redirects the request to the isolation module according to the port. All requests are forwarded to the loader, and the loader is configured with a redirection address. The domain name of the address is the domain name of the server where the module is isolated, and different module services are distinguished by ports.

FIG. 9 is a system architecture diagram according to an embodiment of the present invention; as shown in FIG. 9:

Container: Plug-in container, which is responsible for the management of the plug-in package when it is started; the container has the function of managing plug-ins and applications; after the container is successfully started, it will automatically resolve the Plugin and facade dependencies contained in the classpath, complete the isolation load, and start them in order of priority;

Plugin: Built-in plug-in, FatJar that meets the requirements of a specific directory format, can package one or more ordinary Java jars into a standard format FatPlugin; FatPlugin will include a configuration file, usually including plug-in class import and export configuration, Resource import and export configuration, plug-in startup priority, etc .; at runtime, the container will use a separate PluginClassLoader to load the plug-in, and build a class load index table and resource load index table based on the plug-in configuration, so that plug-ins and plug-ins, and between plug-ins and applications Isolated from each other

Facade: An application module is an organizational unit of an engineering application and its dependent packages. It contains all dependencies and configurations required for application startup.

FIG. 10 is a schematic diagram of a service deployment workflow according to an embodiment of the present invention; as shown in FIG. 10, the service deployment workflow is as follows:

1. If it is loading the bytecode generated by reflection, it will directly throw a ClassNotFoundException and terminate the class loading. This device loads only jars in the specified directory.

2. Find the classes that have been loaded:

2.1 If it is not loaded, look for the class in the JDK. This block mainly contains two parts: the first part is the class that ExtClassloader is responsible for loading; the second part is the class provided by JDK but cannot be loaded from ExtClassloader, but it will be run locally They are added to the classpath of the SystemClassloader, and these classes may be put into some three-party toolkits, such as sun.tools.attach.BsdVirtualMachine in tool.jar. This part is also mainly derived from engineering practices to avoid classes being Loaded more than once, which caused an error.

2.2 If 2.1 is not satisfied, delegate to the custom class loader of the present invention to load it.

3. Initialize the container and place a function handler in the SET collection.

4. Instantiate the handler in SET.

5. Inject the referenced object instance into the business service.

6. Repeat 1-5.

An embodiment of the present invention provides an electronic device including: one or more processors; a storage device configured to store one or more programs, and when the one or more programs are executed by the one or more processors , So that the one or more processors implement the method for implementing multi-version dependency isolation provided by the embodiment of the present invention.

An embodiment of the present invention provides a computer-readable medium on which a computer program is stored. When the program is executed by a processor, the method for implementing multi-version dependency isolation provided by the embodiment of the present invention is implemented.

FIG. 11 illustrates an exemplary system architecture 1100 of a method or apparatus for implementing multi-version dependency isolation to which embodiments of the present invention can be applied.

As shown in FIG. 11, the system architecture 1100 may include

terminal devices

1101, 1102, 1103, a network 1104, and a server 1105. The network 1104 is used to provide a medium for a communication link between the

terminal devices

1101, 1102, 1103 and the server 1105. The network 1104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, and so on.

The user can use the

terminal devices

1101, 1102, 1103 to interact with the server 1105 through the network 1104 to receive or send messages and the like. Various communication client applications can be installed on the

terminal devices

1101, 1102, and 1103, such as shopping applications, web browser applications, search applications, instant messaging tools, email clients, social platform software, and the like (only examples).

The

terminal devices

1101, 1102, 1103 may be various electronic devices having a display screen and supporting web browsing, including, but not limited to, smart phones, tablet computers, laptop computers, and desktop computers.

The server 1105 may be a server that provides various services, for example, a background management server that provides support for a shopping website browsed by the user using the

terminal devices

1101, 1102, and 1103 (for example only). The background management server can analyze and process the received product information query request and other data, and feed back the processing results (such as target push information and product information-just examples) to the terminal device.

It should be noted that the method for implementing multi-version dependency isolation provided by the embodiment of the present invention is generally executed by the server 1105, and accordingly, a device for implementing multi-version dependency isolation is generally provided in the server 1105.

It should be understood that the numbers of terminal devices, networks, and servers in FIG. 11 are merely exemplary. According to implementation needs, there can be any number of terminal devices, networks, and servers.

Reference is now made to FIG. 12, which shows a schematic structural diagram of a computer system 1200 suitable for implementing a terminal device according to an embodiment of the present invention. The terminal device shown in FIG. 12 is only an example, and should not impose any limitation on the functions and scope of use of the embodiments of the present invention.

As shown in FIG. 12, the computer system 1200 includes a central processing unit (CPU) 1201, which can be loaded into a random access memory (RAM) 1203 according to a program stored in a read-only memory (ROM) 1202 or loaded from a storage portion 1208. Instead, perform various appropriate actions and processes. In the RAM 1203, various programs and data required for the operation of the system 1200 are also stored. The CPU 1201, the ROM 1202, and the RAM 1203 are connected to each other through a bus 1204. An input / output (I / O) interface 1205 is also connected to the bus 1204.

The following components are connected to the I / O interface 1205: an input portion 1206 including a keyboard, a mouse, and the like; an output portion 1207 including a cathode ray tube (CRT), a liquid crystal display (LCD), and the speaker; a storage portion 1208 including a hard disk and the like And a communication section 1209 including a network interface card such as a LAN card, a modem, and the like. The communication section 1209 performs communication processing via a network such as the Internet. The driver 1210 is also connected to the I / O interface 1205 as needed. A removable medium 1211, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is installed on the drive 1210 as needed, so that a computer program read therefrom is installed into the storage section 1208 as needed.

In particular, according to the disclosed embodiments of the present invention, the process described above with reference to the flowchart may be implemented as a computer software program. For example, the disclosed embodiments include a computer program product including a computer program carried on a computer-readable medium, the computer program containing program code for performing the method shown in the flowchart. In such an embodiment, the computer program may be downloaded and installed from a network through the communication portion 1209, and / or installed from a removable medium 1211. When the computer program is executed by a central processing unit (CPU) 1201, the above-mentioned functions defined in the system of the present invention are executed.

It should be noted that the computer-readable medium shown in the present invention may be a computer-readable signal medium or a computer-readable storage medium or any combination of the foregoing. The computer-readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections with one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable Programming read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the foregoing. In the present invention, a computer-readable storage medium may be any tangible medium containing or storing a program, and the program may be used by or in combination with an instruction execution system, apparatus, or device. In the present invention, the computer-readable signal medium may include a data signal transmitted in baseband or transmitted as a part of a carrier wave, in which a computer-readable program code is carried. Such a propagated data signal may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. The computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, and the computer-readable medium may send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device . Program code embodied on a computer-readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagram may represent a module, a program segment, or a part of code, which contains one or more of the logic functions used to implement the specified logic. Executable instructions. It should also be noted that in some alternative implementations, the functions noted in the blocks may also occur in a different order than those marked in the drawings. For example, two successively represented boxes may actually be executed substantially in parallel, and they may sometimes be executed in the reverse order, depending on the functions involved. It should also be noted that each block in the block diagram or flowchart, and combinations of blocks in the block diagram or flowchart, can be implemented with a dedicated hardware-based system that performs the specified function or operation, or can be implemented with A combination of dedicated hardware and computer instructions.

The modules described in the embodiments of the present invention may be implemented by software or hardware. The described module may also be provided in the processor, for example, it may be described as: a processor including an annotation module, a placement module, an execution module, and a loading module. Among them, the names of these modules do not in any way constitute a limitation on the module itself. For example, the annotation module can also be described as a "module for adding annotations".

As another aspect, the present invention also provides a computer-readable medium. The computer-readable medium may be included in the device described in the foregoing embodiments, or may exist alone without being assembled into the device. The computer-readable medium carries one or more programs. When the one or more programs are executed by one device, the device includes: adding a comment to the method to be isolated; and quoting the method to be isolated. The dependent package is placed in the reference directory file; the annotation corresponds to the reference directory one by one; when the method to be isolated is executed, the reference directory file placed by the dependent package is determined according to the annotation; and a custom class is used for loading A loader that loads the dependent packages in the reference directory file.

According to the technical solution of the embodiment of the present invention, because the technical means of adding annotations are used, the projects that can be resolved in the process of using spring boot for dependency isolation must be spring boot projects, spring plugins must be compiled, and the degree of coupling is too high. In order to achieve the technical effect of relying on coexistence of multiple versions without distinguishing project types, and ensuring that the versions rely on normal provision of functions, at the same time, the running dependent versions can be switched in real time to avoid the system abduction upgrade without using the upgrade function.

The foregoing specific implementation manners do not constitute a limitation on the protection scope of the present invention. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations, and substitutions may occur depending on design requirements and other factors. Any modification, equivalent replacement and improvement made within the spirit and principle of the present invention shall be included in the protection scope of the present invention.

Claims

A method for implementing multi-version dependency isolation, which is characterized by:

Add annotations to the method to be isolated;

Placing the dependent packages to be referenced in the method to be isolated into a reference directory file; the annotations correspond to the reference directory in a one-to-one manner;

When the method to be isolated is executed, determining a reference directory file where the dependent package is placed according to the annotation;

Use a custom class loader to load the dependent packages in the reference directory file.
The method according to claim 1, wherein after placing the dependent packages to be referenced in the method to be isolated into a reference directory file, the method further comprises:

Receive telnet commands;

Perform at least one of the following operations on the dependent package according to the telnet command: selecting, traversing, adding, deleting, and moving to a backup area.
The method according to claim 1, before executing the method to be isolated, further comprising:

Monitor a service request, and determine a redirection address according to the service request;

Determining the to-be-isolated method to be executed according to a domain name of the redirection address.
A method for implementing multi-version dependency isolation, which is characterized by:

Use the custom class loader to load the dependent package to get the object instance of the dependent package;

Start a container and initialize a function processor in the container, and register the dependent package object instance in the function processor;

When the method to be isolated is executed, if the reference needs to be referenced, the dependent package object instance is taken out from the function processor and executed.
The method according to claim 4, wherein after registering the dependent package object instance in the function processor, the method further comprises:

Receive telnet commands;

Perform at least one of the following operations on the dependent package object instance according to the telnet command: selecting, traversing, adding, deleting, and moving to a backup area.
The method according to claim 4, wherein before executing the method to be isolated, further comprising:

Monitoring a service request, and determining a redirection address according to the service request;

Determining the to-be-isolated method to be executed according to a domain name of the redirection address.
A device for implementing multi-version dependency isolation is characterized in that it includes:

Annotation module, used to: add annotations to the method to be isolated;

A placing module, configured to place the dependent packages to be referenced in the method to be isolated into a reference directory file; the annotations correspond to the reference directory one by one;

An execution module, configured to: when executing the method to be isolated, determine a reference directory file placed by the dependent package according to the annotation;

A loading module, configured to: use a custom class loader to load a dependent package in the reference directory file.
The apparatus according to claim 7, wherein the placing module is further configured to:

Receive telnet commands;

Perform at least one of the following operations on the dependent package according to the telnet command: selecting, traversing, adding, deleting, and moving to a backup area.
The apparatus according to claim 7, wherein the execution module is further configured to:

Monitoring a service request, and determining a redirection address according to the service request;

Determining the to-be-isolated method to be executed according to a domain name of the redirection address.
A device for implementing multi-version dependency isolation is characterized in that it includes:

A loading module for loading a dependent package with a custom class loader to obtain an object instance of the dependent package;

A registration module, configured to start a container and initialize a function processor in the container, and register the dependent package object instance in the function processor;

A reference module is configured to: when executing a method to be isolated, if a reference dependency is required, take out and execute the dependent package object instance from the function processor.
The apparatus according to claim 10, wherein the registration module is further configured to:

Receive telnet commands;

Perform at least one of the following operations on the dependent package object instance according to the telnet command: selecting, traversing, adding, deleting, and moving to a backup area.
The apparatus according to claim 10, wherein the reference module is further configured to:

Monitoring a service request, and determining a redirection address according to the service request;

Determining the to-be-isolated method to be executed according to a domain name of the redirection address.
An electronic device, comprising:

One or more processors;

A storage device for storing one or more programs,

When the one or more programs are executed by the one or more processors, the one or more processors implement the method according to any one of claims 1-6.
A computer-readable medium having a computer program stored thereon, characterized in that when the program is executed by a processor, the method according to any one of claims 1-6 is implemented.