CN110716720A - Method and device for realizing application hot deployment - Google Patents

Abstract

The invention discloses a method and device for realizing application hot deployment, and relates to the technical field of computers. A specific implementation of the method includes: using a custom class loader corresponding to the application to load the class file of the application; when the configuration update in the application is monitored in real time, using a new custom class loader Load the class file of the updated application; and make a one-to-one correspondence between the updated application and the new class loader. This embodiment adopts real-time monitoring of the configuration in the application, and uses a new custom class loader to load the updated application; the technical means of one-to-one correspondence between the application and the class loader can facilitate the application in deployment to dynamically modify the file and It takes effect in a timely manner, optimizes the hot deployment architecture process, increases reliability, reduces the dependence on IDE integrated development tools, and dynamically updates classes through non-stop services.

Description

A method and apparatus for implementing application hot deployment

technical field

The present invention relates to the field of computer technologies, and in particular, to a method and apparatus for implementing application hot deployment.

Background technique

In the process of project development, page data or data structure are often changed. In order to display the effect of the change, it is often necessary to restart the application to check the effect of the change. Recompilation is time-consuming and inefficient. Hot deployment is to automatically detect changes in class files and update the behavior of classes at runtime without restarting the Java virtual machine, which can save time for application development and release. The current loading mechanism of classloaders is parental delegation. You can use the Open Service Gateway Initiative (OSGI) to realize hot replacement of modules, as well as hot deployment based on HotSwap technology.

In the process of realizing the present invention, the inventor found that there are at least the following problems in the prior art:

1. The loading order of the parent-delegated loading mechanism is difficult to change, making it difficult for custom classloaders to preemptively load classes that need to be monitored for changes.

2. In the OSGI architecture, if there is a calling relationship between modules, the application will have a short-term functional shock due to the coupling.

3. HotSwap has a strong integration dependency on IDE, and is limited to working on method bodies. It can neither add methods or fields, nor modify anything other than method bodies.

4.HotSwap works at the virtual machine level and depends on the inner workings of the virtual machine JVM. Java compilers often create synthetic methods or fields, even if you only modify a method body (for example, when adding a class literal or an anonymous class or an inner class, etc.). Running in debug mode often slows down the application or introduces other problems.

SUMMARY OF THE INVENTION

In view of this, the embodiments of the present invention provide a method and apparatus for implementing hot deployment of applications, which can facilitate the application in deployment to dynamically modify files and take effect in time, optimize the architecture process of hot deployment, increase reliability, and reduce the complexity of IDE integrated development tools. rely.

In order to achieve the above object, according to an aspect of the embodiments of the present invention, a method for implementing hot deployment of an application is provided, including: loading a class file of the application by using a custom class loader corresponding to the application one-to-one; After the configuration in the application is updated, a new custom class loader is used to load the class file of the updated application; and the updated application is in a one-to-one correspondence with the new class loader.

Optionally, when the configuration in the application is updated, use a new custom class loader to load the updated application, including: monitoring the compiled class file in the application, when the compiled class file is updated, all Describe the compiled class file as the class file of the original class; read the class file of the original class, use the first enhancement component to modify the type of the original class to an interface; generate the first derived class, copy all the class files of the original class Method logic, make the first derived class implement the interface to complete the transformation of the original class into an interface; set a second derived class, the second derived class can implement the interface; read the class file of the original class to the second derived class For derived classes, use the second enhanced component to change the class name of the original class, and use the third enhanced component to change the parent class of the original class; instantiate the behavior of the second derived class.

Optionally, the behavior of the second derived class includes: dynamically creating an object after acquiring the class through a custom class loader; or modifying Class.forName() and ClassLoader.findClass(), using the modified Class.forName () and ClassLoader.findClass(), which implements the behavior of instantiating the second derived class.

Optionally, the reading the class file of the original class includes: reading the class file of the original class from the workspace; wherein the configuration file in the workspace includes the path of the class file of the original class.

Optionally, the method further includes: before loading the application, a method of setting a premain in the class file of the application; setting a manifest file, where the manifest file sets the Premain-Class attribute to the class full of a class Name; this class has the method of the premain; generate a jar package containing the manifest file; add the -javaagent parameter and the jar package to the parameters of the application, execute the method of premain, and pre-parse when executing the method of premain required class.

Optionally, the method further includes: reading a class file; modifying the class file according to the updated configuration, and modifying the class name of the class file to generate the first derived class.

Optionally, the method further includes: using the interface of ClassFileTransformer to replace the original class file with the modified class file to prevent the original class file from being loaded.

In order to achieve the above object, according to an aspect of the embodiments of the present invention, there is provided a device for implementing hot deployment of applications, including: a loading module, an updating module, and a corresponding module; the loading module is used for: using a unique corresponding to the application. The custom class loader loads the class file of the application; the update module is used for: after the configuration in the application is updated, use the new custom class loader to load the class file of the updated application; the The corresponding module is used for one-to-one correspondence between the updated application and the new class loader.

Optionally, the update module is used for: monitoring the compiled class file in the application, when the compiled class file is updated, the compiled class file is the class file of the original class; class file, use the first enhanced component to modify the type of the original class into an interface; generate the first derived class, copy all the method logic in the class file of the original class, and make the first derived class implement the interface, so as to complete the transformation of the original class become an interface; set a second derived class that can implement the interface; read the class file of the original class to the second derived class, use the second enhanced component to change the class name of the original class, and use the third Enhanced component changes the parent class of the original class; instantiates the behavior of the second derived class.

Optionally, the update module is also used to: dynamically create an object after acquiring a class through a custom class loader; or modify Class.forName() and ClassLoader.findClass(), and use the modified Class.forName() and ClassLoader.findClass(), which implements the behavior of instantiating the second derived class.

Optionally, the update module is further configured to: read the class file of the original class from the workspace; wherein the configuration file in the workspace includes the path of the class file of the original class.

Optionally, the loading module is further used for: setting a premain method in the class file of the application before loading the application; setting a manifest file, where the manifest file sets the Premain-Class attribute to a class The full name of the class; this class has the method of the premain; generate a jar package containing the manifest file; add the -javaagent parameter and the jar package to the parameters of the application, execute the method of premain, and pre-parse before executing the premain The class required for the method.

Optionally, the updating module is further configured to: read the class file; modify the class file according to the updated configuration, and modify the class name of the class file to generate the first derived class.

Optionally, the update module is further configured to: replace the original class file with the modified class file by using the interface of ClassFileTransformer, so as to prevent the original class file from being loaded.

To achieve the above object, according to an aspect of the embodiments of the present invention, an electronic device is provided, including: one or more processors; a storage device for storing one or more programs, when the one or more programs Executed by the one or more processors, so that the one or more processors implement the method for implementing application hot deployment as provided by the embodiments of the present invention.

In order to achieve the above object, according to an aspect of the embodiments of the present invention, a computer-readable medium is provided, on which a computer program is stored, and when the program is executed by a processor, the implementation of hot deployment of applications as provided by the embodiments of the present invention is realized. Methods.

An embodiment of the above invention has the following advantages or beneficial effects: adopting the configuration monitored in the application in real time, using a new custom class loader to load the updated application; applying technical means corresponding to the class loader one-to-one , which can facilitate the application in deployment to dynamically modify files and take effect in time, optimize the hot deployment architecture process, increase reliability, reduce the dependence on IDE integrated development tools, and keep services to dynamically update classes.

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

Description of drawings

The accompanying drawings are used for better understanding of the present invention and do not constitute an improper limitation of the present invention. in:

1 is a schematic diagram of a parent delegation loading mechanism in the prior art;

Fig. 2 is the schematic flow chart of the HotSwap hot deployment method of the prior art;

3 is a schematic diagram of a main process of a method for implementing application hot deployment according to an embodiment of the present invention;

4 is a schematic diagram of main modules of an apparatus for implementing application hot deployment according to an embodiment of the present invention;

FIG. 5 is an architectural diagram of hot deployment according to an embodiment of the present invention;

6 is a schematic diagram of an abstraction layer according to an embodiment of the present invention;

7 is a flow chart that is triggered in a core service when a configuration is changed according to an embodiment of the present invention;

FIG. 8 is a work flow diagram of an enhancement component according to an embodiment of the present invention;

FIG. 9 is a work flow diagram of an enhancement component according to an embodiment of the present invention;

10 is a schematic diagram of an archive file according to an embodiment of the present invention;

FIG. 11 is an exemplary system architecture diagram to which an embodiment of the present invention may 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 ways

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

Technical solutions of the prior art:

FIG. 1 is a schematic diagram of a parent delegation loading mechanism in the prior art. As shown in Figure 1, the current loading mechanism is called parental delegation. When the system uses a classloader to load a class, it will first ask whether the parent class of the current classloader has the ability to load, and if the parent class cannot implement the loading operation, the task will be delegated. to the classloader to load. The advantage of this top-down loading method is that each classloader performs its own loading tasks and does not load classes repeatedly. However, this method makes it very difficult to change the loading order, and it becomes a difficult problem for the custom classloader to preemptively load the classes that need to be monitored for changes.

OSGI module, the key concept of OSGI is to apply module (bundle), for each bundle has its own class loader, when the bundle needs to be updated, replace the bundle and its class loader together to realize the module hot replacement. Although the emergence of the OSGI architecture makes it possible to restart modules, if there is a calling relationship between modules, such an operation will still cause a short-term functional shock to the application.

FIG. 2 is a schematic flowchart of a HotSwap hot deployment method in the prior art. As shown in Figure 2, the HotSwap and Instrumentation techniques are synthesized into the Debugger API, which allows the debugger to update the bytecode of a class with the same class ID. This means that all objects can reference an updated class and execute the new code when their methods are called, which avoids reloading the container whenever the class's bytecode is modified. this requirement. HotSwap has a strong dependence on IDE integration, and HotSwap is limited to working on method bodies. It can neither add methods or fields, nor modify anything other than method bodies. At the same time, HotSwap works at the virtual machine level and depends on the inner workings of the JVM. Java compilers often create synthetic methods or fields when only modifying a method body (eg, when adding a class literal, anonymous and inner classes, etc.). Running in debug mode often slows down the application or introduces other problems

3 is a schematic diagram of a main process of a method for implementing application hot deployment according to an embodiment of the present invention; as shown in FIG. 3 , an embodiment of the present invention provides a method for implementing application hot deployment, including:

Step S301. Use a custom class loader corresponding to the application to load the class file of the application;

Step S302. When the configuration in the application is updated, use a new custom class loader to load the class file of the updated application;

Step S303. One-to-one correspondence between the updated application and the new class loader.

The configuration in the application is monitored in real time, and a new custom class loader is used to load the updated application; the technical means of one-to-one correspondence between the application and the class loader can facilitate the application in deployment to dynamically modify the file and take effect in time, Optimize the hot deployment architecture process, increase reliability, reduce the dependence on IDE integrated development tools, and dynamically update classes with non-stop services.

In the embodiment of the present invention, after the configuration in the application is updated, using a new custom class loader to load the updated application includes: monitoring the compiled class file in the application, and when the compiled class file is updated , the compiled class file is the class file of the original class; read the class file of the original class, and use the first enhanced component to modify the type of the original class into an interface; generate the first derived class, copy the class file of the original class All method logic of the first derived class to implement the interface to complete the transformation of the original class into an interface; set the second derived class, which can implement the interface; read the class file of the original class to For the second derived class, use the second enhanced component to change the class name of the original class, and use the third enhanced component to change the parent class of the original class; instantiate the behavior of the second derived class. Instrumentation of the Java SDK is avoided, except in a few places where compatibility is required.

In the embodiment of the present invention, the behavior of the second derived class includes: dynamically creating an object after acquiring the class through a custom class loader; or modifying Class.forName() and ClassLoader.findClass(), and using the modified Class .forName() and ClassLoader.findClass(), which implement the behavior of instantiating the second derived class. The results of the Reflection API (application programming interface), which correctly include the added/removed members of these results. Class.forName() uses the forName method of the java.lang.Class package. It returns a class through the full name of the class. The full name refers to the package name plus the class name, which is loaded by the JVM. In this way, you can get this class, and you can manipulate this class through reflection, such as getting properties, getting methods, etc. ClassLoader: Custom class loader. The findClass() method means: when the current loader loads the class, find the corresponding class adjustment. JVM is the abbreviation of Java Virtual Machine (Java Virtual Machine). JVM is a specification for computing devices. It is a fictional computer that is realized by simulating various computer functions on an actual computer.

In this embodiment of the present invention, the reading of the class file of the original class includes: reading the class file of the original class from the workspace; wherein the configuration file in the workspace includes the path of the class file of the original class. The paths include absolute paths, relative paths, and paths with placeholder "*". Leaving as many complete method calls as possible means that A minimizes the performance overhead and makes it lightweight.

In the embodiment of the present invention, the method further includes: before loading the application, a method of setting a premain in the class file of the application; setting a manifest file, where the manifest file sets the Premain-Class attribute to a class The full name of the class; this class has the method of the premain; generates a jar package containing the manifest file; adds the -javaagent parameter and the jar package to the parameters of the application, executes the method of premain, and pre-parses the method of executing premain The class required for the method. Changes to code annotations are visible to the application. .MANIFEST.MF file: Stores the label information of the Jar file, it contains the content description of the jar file, and provides application information to the JVM at runtime. Most jar files contain a default generated manifest file, execute the JAR command or It can be generated using the zip tool. The "Main-Class" property of this file specifies the main class of the program. -javaagent is introduced from JDK (JDK is a software development kit for Java language) 1.5 and later, and cannot be used before 1.5, it can also be called java agent. The agent is an interceptor before the main main method, that is, before the main method is executed, the code of the agent is executed. In java5 (version) and java6 (version), only the premain method needs to be implemented. The method name "premain" is the method name agreed by the JDK.

In the embodiment of the present invention, the method further includes: reading a class file; modifying the class file according to the updated configuration, and modifying the class name of the class file to generate a first derived class. Utilize the interface of ClassFileTransformer to replace the original class file with the modified class file to prevent the original class file from being loaded. ClassFileTransformer is the interface, the agent (agent) provides the implementation of this interface in order to transform the class file, the transformation happens before the JVM defines the class. The above English terms are all common knowledge in the field.

To achieve the above object, according to an aspect of the embodiments of the present invention, an apparatus 400 for implementing hot deployment of applications is provided, including: a loading module 401, an updating module 402, and a corresponding module 403; the loading module 401 is used for: utilizing The custom class loader corresponding to the application loads the class file of the application; the update module 402 is used for: when the configuration in the application is updated, use the new custom class loader to load the updated The class file of the application; the corresponding module 403 is used for one-to-one correspondence between the updated application and the new class loader. The configuration in the application is monitored in real time, and a new custom class loader is used to load the updated application; the technical means of one-to-one correspondence between the application and the class loader can facilitate the application in deployment to dynamically modify the file and take effect in time, Optimize the hot deployment architecture process, increase reliability, reduce the dependence on IDE integrated development tools, and dynamically update classes with non-stop services.

In the embodiment of the present invention, the updating module 402 is used for: monitoring the compiled class file in the application, when the compiled class file is updated, the compiled class file is the class file of the original class; read In the class file of the original class, use the first enhanced component to modify the type of the original class into an interface; generate the first derived class, copy all the method logic in the class file of the original class, and make the first derived class implement the interface to complete Change the original class into an interface; set a second derived class, the second derived class can implement the interface; read the class file of the original class to the second derived class, and use the second enhanced component to change the class name of the original class, Change the parent class of the original class with a third enhancement component; instantiate the behavior of the second derived class. Instrumentation of the Java SDK is avoided, except in a few places where compatibility is required.

In the embodiment of the present invention, the update module 402 is further used to: dynamically create an object after acquiring a class through a custom class loader; or modify Class.forName() and ClassLoader.findClass(), and use the modified Class. forName() and ClassLoader.findClass(), implement the behavior of instantiating the second derived class. Adjusted Reflection API results so that we can correctly include added/removed members in these results.

In this embodiment of the present invention, the updating module 402 is further configured to: read the class file of the original class from the workspace; wherein the configuration file in the workspace includes the path of the class file of the original class. Leaving as many complete method calls as possible means that A minimizes the performance overhead and makes it lightweight.

In this embodiment of the present invention, the loading module 401 is further configured to: set a premain method in the class file of the application before loading the application; set a manifest file, where the manifest file sets the Premain-Class attribute The full name of a class; the class has the premain method; a jar package containing the manifest file is generated; the -javaagent parameter and the jar package are added to the parameters of the application, the premain method is executed, and pre-parsed The class required to execute the premain method. Changes to code annotations are visible to the application.

In this embodiment of the present invention, the updating module 402 is further configured to: read a class file; modify the class file according to the updated configuration, and modify the class name of the class file to generate a first derived class. Utilize the interface of ClassFileTransformer to replace the original class file with the modified class file to prevent the original class file from being loaded.

Hereinafter, "A" is used to refer to the method for implementing application hot deployment of the present invention.

FIG. 5 is an architectural diagram of hot deployment according to an embodiment of the present invention. As shown in Figure 5, if an application supports hot deployment, a separate classloader can be used to load each user-defined application. Then, when a user-defined application changes, first destroy the original application, and then use a new classloader to load the changed application, and all other applications will not be disturbed at all. The core service provides services for all custom class loaders and applications.

The way it works is by monitoring the actual compiled .class files on disk and updating the class whenever a file is updated. Two notable features of the JVM are used: abstract bytecode and classloaders. FIG. 6 is a schematic diagram of an abstraction layer according to an embodiment of the present invention. As shown in FIG. 6 , the class loader allows A to identify the moment when the class is loaded, and then translate the bytecode in real time, so as to be used between the virtual machine and the executable code. create an abstraction layer in between.

FIG. 7 is a flowchart that is triggered in a core service when a configuration is changed, according to an embodiment of the present invention. As shown in FIG. 7, the class file is modified according to the updated configuration, and the updated class file is loaded using a new custom class loader. Monitor the compiled class files in the application, update the compiled class files corresponding to the original files according to the updated original files, and use the new custom class loader to load the updated class files.

FIG. 8 is a flowchart of modifying a bytecode file (ie, a class file or a .class file) according to an embodiment of the present invention. As shown in Figure 8, ClassReader is used to read bytecodes, ClassVisitor modifies the bytecodes according to the updated configuration, and ClassWriter outputs the modified bytecodes. Make some modifications to the class name of the read class file and load it into a first derived class with a brand new name.

FIG. 9 is a work flow diagram of an enhancement component according to an embodiment of the present invention. Combined with Figure 9:

class overloading

1) First turn the original class into an interface

First load the class file of the original class, where the first enhancement component "ClassModifier" is defined, which is used to modify the type of the original class and convert it into an interface. All method logic of the original class will be stripped.

2) The first derived class generated implements this interface, that is, the original class, and after copying all the method logic in the original class, if the class needs to be updated, a new derived class will be generated, which will also implement this interface. The purpose of this is that no matter how it is modified, the derived classes of the same class have a common interface, and the conversion between them becomes opaque to the outside world.

3) Define a second derived class so that the second derived class can implement the same original class (the original class has been converted into an interface at this time). Load the class file of the original class again, two enhanced components are defined here, one is the second enhanced component "EnhancedModifier", the function of this enhanced component is to change the original class name. The third enhanced component "ExtendModifier", the function of this enhanced component is to change the parent class of the original class.

Another function of the custom class loader is to monitor the class files that will change. The class loader will manage a timer and regularly scan these class files for changes.

4) Change the behavior of creating objects

There are two common methods of creating objects in the Java virtual machine, one is static creation, that is, directly new an object, and the other is dynamic creation, which creates objects through reflection.

Since the type of the original class has been changed in the custom loader, it has been changed from a class to an interface, so neither of these two creation methods will work. What we're trying to do is turn the act of instantiating the original class into the act of instantiating a derived class.

For the first method, what needs to be done is to change the static creation to obtain the class (class) through the class loader, and then dynamically create the object. Examples are as follows:

//original logic

People p = new People();

//changed logic

IPeople p=(IPeople)MyClassLoader.getInstance().

or

findClass("com.example.People").newInstance();

Use A to modify the class file, find all the statements of new objects, and replace them with the form of obtaining objects through the form of classloader.

For the second creation method, you need to modify the behavior of Class.forName() and ClassLoader.findClass() so that they load the class through the custom loader.

5) A agent intercepts the behavior of the default loader

A agent can provide space for the user to perform some special actions in a short interval before the application starts after the JVM is started. The implementation of A agent is very easy, as long as a premain method is defined in a class. Then write a manifest file and set the Premain-Class property to define a class name with a premain method. Generate a jar containing this manifest file. Finally, you need to add the -javaagent parameter to the parameters of the execution application and add this jar. At the same time, parameters can be added for A agent. In this way, before executing the application, the logic in the premain method will be executed first, and the classes to be loaded will be pre-parsed.

6) Replace class

Use A agent to replace the original bytecode to prevent the original bytecode from being loaded by the Java virtual machine. You only need to implement an interface of ClassFileTransformer, and use this implementation class to complete the function of class replacement.

FIG. 10 is a schematic diagram of an archive file according to an embodiment of the present invention. As shown in Figure 10:

archive file

To map the archived applications and modules back into the workspace, the user creates an a.xml configuration file in each application and module that tells A where to find the source files. A is integrated with the application server, and when a class or resource is updated, it is read from the workspace instead of the archive.

This approach allows instant updating of not only classes, but any type of resource such as HTML, XML, JSP, CSS, .properties, etc. Maven users don't even need to create an a.xml file, as the Maven plugin will generate it automatically.

Configuration and metadata

Applications today are not just classes and resources, they are also bound together by a lot of configuration and metadata. When configuration changes are made, the changes should be reflected in that running application. However, it is not enough to make changes to the configuration file visible, the specific framework must reload the configuration to reflect the changes in the application.

To support these types of changes in A, an open-source API can be developed that allows our team and third-party contributors to use A's features using framework-specific plugins, propagating changes made in the configuration to in the frame. For example, support for adding beans and dependencies in Spring dynamically and in real time, as well as supporting various changes made in other frameworks, etc.

An embodiment of the present invention provides an electronic device, including: 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 , so that the one or more processors implement the method for implementing application hot deployment as provided by the embodiments of the present invention.

Embodiments of the present invention provide a computer-readable medium on which a computer program is stored, and when the program is executed by a processor, the method for implementing hot deployment of applications provided by the embodiments of the present invention is implemented.

FIG. 11 shows an exemplary system architecture 1100 to which an application hot deployment method or an application hot deployment apparatus may be applied to which embodiments of the present invention may be applied.

As shown in FIG. 11 , the system architecture 1100 may include terminal devices 1101 , 1102 , and 1103 , a network 1104 and a server 1105 . The network 1104 is a medium used to provide 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, among others.

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 may 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, etc. (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, desktop computers, and the like.

The server 1105 may be a server that provides various services, such as a background management server that provides support for shopping websites browsed by the terminal devices 1101 , 1102 , and 1103 (just an example). 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, product information—just an example) to the terminal device.

It should be noted that, the method for implementing hot application deployment provided by the embodiment of the present invention is generally executed by the server 1105 , and accordingly, the apparatus for implementing hot application deployment is generally set in the server 1105 .

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

Referring to FIG. 12 below, it 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 limitations on the functions and scope of use of the embodiments of the present invention.

As shown in FIG. 12, a 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 a program from a storage section 1208 Instead, various appropriate actions and processes are performed. In the RAM 1203, various programs and data necessary 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 bus 1204 .

The following components are connected to the I/O interface 1205: an input section 1206 including a keyboard, a mouse, etc.; an output section 1207 including a cathode ray tube (CRT), a liquid crystal display (LCD), etc., and a speaker, etc.; a storage section 1208 including a hard disk, etc. ; 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. Drivers 1210 are also connected to 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 mounted on the drive 1210 as needed so that a computer program read therefrom is installed into the storage section 1208 as needed.

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

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 above two. The computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus or device, or a combination of any of the above. 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 Programmable read only memory (EPROM or flash memory), fiber optics, portable compact disk read only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing. In the present invention, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In the present invention, however, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code therein. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium that can transmit, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device . Program code embodied on a computer readable medium may be transmitted using any suitable 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 diagrams may represent a module, segment, or portion of code that contains one or more logical functions for implementing the specified functions executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It is also noted that each block of the block diagrams or flowchart illustrations, and combinations of blocks in the block diagrams or flowchart illustrations, can be implemented in special purpose hardware-based systems that perform the specified functions or operations, or can be implemented using A combination of dedicated hardware and computer instructions is implemented.

The modules involved in the embodiments of the present invention may be implemented in a software manner, and may also be implemented in a hardware manner. The described modules can also be provided in the processor, for example, it can be described as: a processor includes a load module and an update module. The names of these modules do not constitute a limitation of the module itself under certain circumstances. For example, a loading module can also be described as "using a custom class loader uniquely corresponding to the application to load the module of the application".

As another aspect, the present invention also provides a computer-readable medium, which may be included in the device described in the above embodiments; or may exist alone without being assembled into the device. The above-mentioned computer-readable medium carries one or more programs, and when the above-mentioned one or more programs are executed by a device, the device includes: Step S301. Use a custom class loader corresponding to an application to load the described class file of the application; Step S302. When the configuration in the application is updated, use a new custom class loader to load the class file of the updated application; combine the updated application with the new class loader One-to-one correspondence.

According to the technical solution of the embodiment of the present invention, the configuration in the application is monitored in real time, and a new custom class loader is used to load the updated application; the technical means of one-to-one correspondence between the application and the class loader can facilitate the deployment The application dynamically modifies the files and takes effect in time, optimizes the hot deployment architecture process, increases reliability, reduces the dependence on IDE integrated development tools, and dynamically updates classes without stopping services.

The above-mentioned specific embodiments 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 modifications, equivalent replacements and improvements made within the spirit and principle of the present invention shall be included within the protection scope of the present invention.

Claims (16)

1. a method for realizing application hot deployment, is characterized in that, comprises: Load the class file of the application by using a custom class loader corresponding to the application one-to-one; After the configuration update in the application is monitored in real time, the new custom class loader is used to load the class file of the updated application; One-to-one correspondence between the updated application and the new class loader. 2. The method according to claim 1, wherein when the configuration in the application is updated, using a new custom class loader to load the updated application, comprising: Monitor the compiled class file in the application, when the compiled class file is updated, the compiled class file is the class file of the original class; Read the class file of the original class, use the first enhanced component to modify the type of the original class to an interface; generate the first derived class, copy all the method logic in the class file of the original class, and make the first derived class implement the interface, to complete turning the original class into an interface; setting a second derived class capable of implementing the interface; Read the class file of the original class to the second derived class, use the second enhanced component to change the class name of the original class, and use the third enhanced component to change the parent class of the original class; The act of instantiating the second derived class. 3. The method according to claim 2, wherein the behavior of instantiating the second derived class comprises: After the class is obtained through the custom class loader, the object is dynamically created; Or modify Class.forName() and ClassLoader.findClass(), and use the modified Class.forName() and ClassLoader.findClass() to realize the behavior of instantiating the second derived class. 4. The method according to claim 2, wherein the reading the class file of the original class comprises: Read the class file of the original class from the workspace; Wherein, the configuration file in the workspace includes the path of the class file of the original class. 5. The method according to claim 1, wherein the method further comprises: Before loading the application, set a premain method in the class file of the application; Set the manifest file, the manifest file sets the Premain-Class attribute to the full class name of a class; this class has the premain method; Generate a jar package containing the manifest file; Add the -javaagent parameter and the jar package to the parameters of the application, execute the premain method, and pre-parse the classes required when executing the premain method. 6. The method according to claim 2, wherein the method further comprises: read class file; The class file is modified according to the updated configuration, and the class name of the class file is modified to generate the first derived class. 7. The method according to claim 6, wherein the method further comprises: Utilize the interface of ClassFileTransformer to replace the original class file with the modified class file to prevent the original class file from being loaded. 8. A device for implementing application hot deployment, comprising: a loading module, an update module, and a corresponding module; The loading module is used for: using a custom class loader uniquely corresponding to the application to load the class file of the application; The updating module is used for: when the configuration in the application is updated, use a new custom class loader to load the class file of the updated application; The corresponding module is used for: one-to-one correspondence between the updated application and the new class loader. 9. The device according to claim 1, wherein the update module is used for: Monitor the compiled class file in the application, when the compiled class file is updated, the compiled class file is the class file of the original class; Read the class file of the original class, use the first enhanced component to modify the type of the original class to an interface; generate the first derived class, copy all the method logic in the class file of the original class, and make the first derived class implement the interface, to complete turning the original class into an interface; setting a second derived class capable of implementing the interface; Read the class file of the original class to the second derived class, use the second enhanced component to change the class name of the original class, and use the third enhanced component to change the parent class of the original class; The act of instantiating the second derived class. 10. The device according to claim 2, wherein the update module is further used for: After the class is obtained through the custom class loader, the object is dynamically created; Or modify Class.forName() and ClassLoader.findClass(), and use the modified Class.forName() and ClassLoader.findClass() to instantiate the behavior of the second derived class. 11. The device according to claim 2, wherein the update module is further used for: Read the class file of the original class from the workspace; Wherein, the configuration file in the workspace includes the path of the class file of the original class. 12. The apparatus according to claim 1, wherein the loading module is further configured to: Before loading the application, set a premain method in the class file of the application; Set the manifest file, the manifest file sets the Premain-Class attribute to the full class name of a class; this class has the premain method; Generate a jar package containing the manifest file; Add the -javaagent parameter and the jar package to the parameters of the application, execute the premain method, and pre-parse the classes required when executing the premain method. 13. The device according to claim 9, wherein the update module is further used for: read class file; The class file is modified according to the updated configuration, and the class name of the class file is modified to generate the first derived class. 14. The device according to claim 13, wherein the update module is further used for: Utilize the interface of ClassFileTransformer to replace the original class file with the modified class file to prevent the original class file from being loaded. 15. An electronic device, comprising: one or more processors; storage means for storing one or more programs, The one or more programs, when executed by the one or more processors, cause the one or more processors to implement the method of any of claims 1-7. 16. A computer-readable medium on which a computer program is stored, characterized in that, when the program is executed by a processor, the method according to any one of claims 1-7 is implemented.

Images