CN114116069A - Method, system and storage medium for uninterrupted operation of JAVA system - Google Patents
Method, system and storage medium for uninterrupted operation of JAVA system Download PDFInfo
- Publication number
- CN114116069A CN114116069A CN202111485743.9A CN202111485743A CN114116069A CN 114116069 A CN114116069 A CN 114116069A CN 202111485743 A CN202111485743 A CN 202111485743A CN 114116069 A CN114116069 A CN 114116069A
- Authority
- CN
- China
- Prior art keywords
- plug
- system integration
- main program
- integration structure
- ins
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 55
- 230000010354 integration Effects 0.000 claims abstract description 60
- 238000004891 communication Methods 0.000 claims abstract description 46
- 235000010627 Phaseolus vulgaris Nutrition 0.000 claims abstract description 35
- 244000046052 Phaseolus vulgaris Species 0.000 claims abstract description 35
- 238000009877 rendering Methods 0.000 claims abstract description 9
- 230000008569 process Effects 0.000 claims description 13
- 238000004590 computer program Methods 0.000 claims description 11
- 238000002955 isolation Methods 0.000 claims description 8
- 238000010586 diagram Methods 0.000 description 13
- 230000006870 function Effects 0.000 description 12
- 238000007726 management method Methods 0.000 description 12
- 238000012423 maintenance Methods 0.000 description 5
- 238000012986 modification Methods 0.000 description 5
- 230000004048 modification Effects 0.000 description 5
- 238000012545 processing Methods 0.000 description 5
- 238000011161 development Methods 0.000 description 4
- 238000004519 manufacturing process Methods 0.000 description 3
- 238000012544 monitoring process Methods 0.000 description 2
- 230000004044 response Effects 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 230000006378 damage Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000001939 inductive effect Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000012856 packing Methods 0.000 description 1
- 230000010076 replication Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
- G06F9/44526—Plug-ins; Add-ons
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/315—Object-oriented languages
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computing Systems (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The invention relates to a method, a system and a storage medium for uninterrupted operation of a JAVA system, wherein the system integration structure is used for isolating different bean containers based on a system integration structure; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides communication interfaces for different plug-ins, and the system integration structure provides communication interfaces for the plug-ins and the main container; when updating the plug-in, the following steps are performed: stopping the plug-in to be updated; starting a new plug-in: scanning and associating bean containers, and checking associated authorities to a main program safety frame; linking IO between the new plug-in and the main program to corresponding jar files, configuring communication interfaces between the new plug-in and other plug-ins, and configuring communication interfaces between the new plug-in and the main container; and adding the template engine in the new plug-in to the rendering list of the main program, completing starting and further completing updating.
Description
Technical Field
The invention relates to the JAVA field, in particular to a method, a system and a storage medium for uninterrupted operation of a JAVA system.
Background
In the current technical environment, all systems, especially B/S structural systems, need to be updated during upgrade, and specific operations need operation and maintenance personnel to perform operation procedures such as "packing, uploading, shutdown, backup, updating, logging, and restarting service", and if the system belongs to a cluster environment, the operation procedures need to be repeated for many times, and inevitable errors occur in the above operations. At the same time, some tiny bugs or functional restrictions only require several minutes to upgrade the modified code, but upgrade deployments may take several hours. Before updating in a cluster environment, load balancing engine routing configuration needs to be continuously switched to ensure that services in updating are unavailable, and meanwhile, the request pressure of other environments can be increased in the updating process.
The current technical environment is to manage beans of the JAVA system more conveniently, most of systems on the market use a Spring frame as a system basic frame to finish work, and single-instance characteristic implementation logic of Spring automatically initializes all Bean objects when a program is started, so that all modules cannot be flexibly loaded and unloaded, and even if midway loading can be finished, the single-instance characteristic of Spring cannot be used.
With the development of the internet, more and more systems are developed by java, in order to improve the robustness and effectiveness of system operation, a large-scale system cuts a plurality of modules of the system by using a scheduling bus mode, packages independent services, and replaces only part of modules to ensure the accessibility of the system when the system needs to be upgraded or has problems, but the hardware cost and the operation and maintenance cost of the system are greatly increased.
The invention aims to design a method, a system and a storage medium for uninterrupted operation of a JAVA system aiming at the problems in the prior art.
Disclosure of Invention
In view of the problems in the prior art, the present invention provides a method, a system, and a storage medium for uninterrupted operation of a JAVA system, which can effectively solve the problems in the prior art.
The technical scheme of the invention is as follows:
a method for uninterrupted operation of JAVA system,
based on a system integration structure, the system integration structure isolates different bean containers; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides communication interfaces for different plug-ins, and the system integration structure provides communication interfaces for the plug-ins and the main container;
the method comprises the following steps:
scanning a deployment environment, and registering a current environment to an equipment management center;
when updating the plug-in, the following steps are performed:
stopping the plug-in to be updated: canceling the association between the bean container and the main program; releasing the link between IO between the plug-in and the main program and the corresponding jar file, disconnecting the communication interface between the plug-in to be updated and other plug-ins, and disconnecting the communication interface between the plug-in to be updated and the main container; deleting the template engine to be updated from the rendering list of the main program, and stopping the process;
starting a new plug-in: scanning and associating bean containers, and checking associated authorities to a main program safety frame; linking IO between the new plug-in and the main program to corresponding jar files, configuring communication interfaces between the new plug-in and other plug-ins, and configuring communication interfaces between the new plug-in and the main container; and adding the template engine in the new plug-in to the rendering list of the main program, completing starting and further completing updating.
Further, the system integration structure isolating different bean containers comprises:
creating a ROOTApplicationContext as a root node of container management;
and creating PluginAplicationContext plug-in module container management, and setting parent as ROOT node to realize the isolation between bean containers.
Further, the IO between the system integration structure isolation plug-in and the main program includes:
when the container is loaded, an independent ClassLoader object is created, and IO between the plug-in and the main program is isolated.
Further, the breaking the link between the IO between the plug-in and the main program and the corresponding jar file includes:
destroying the ClassLoader, and releasing the link between the IO and the corresponding jar file;
the linking of the IO between the plug-in and the main program to the corresponding jar file comprises:
the IOs are linked to the corresponding jar files through ClassLoaders.
Further, the system integration architecture providing a communication interface between different plug-ins comprises:
establishing an ApplicationContext object in the plug-in, connecting ClassLoader of the ApplicationContext object to a jar file in the plug-in, and using an @ Caller object and an @ Suplier object as interfaces for communication between the plug-ins.
Further, the system integration architecture providing a communication interface between the plug-in and the master container comprises:
the method comprises the steps of setting an ApplicationContext object of a plug-in as a child object of the PluginApplicationcontext, and calling a bean in a multi-layer parent object to realize the purpose of providing a communication interface between the plug-in and a main container.
Further, the plug-in is provided with a status flag.
Furthermore, the plug-in is provided with a monitor, and the system integration structure monitors the plug-in to acquire the life cycle of the plug-in.
Further providing a JAVA system uninterrupted operation system, based on a system integration structure, wherein the system integration structure isolates different bean containers; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides a communication interface between different plug-ins, and the system integration structure provides a communication interface between the plug-ins and the main container.
There is further provided a computer readable storage medium storing a computer program which, when executed by a processor, implements a method of uninterrupted operation of a JAVA system.
Accordingly, the present invention provides the following effects and/or advantages:
the system comprises a system integration structure, a system storage device and a system management device, wherein the system integration structure is used for isolating different bean containers; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides communication interfaces between different plug-ins, and the system integration structure provides communication interfaces between the plug-ins and the main container, so that the plug-ins can be quickly and conveniently updated when the plug-ins are updated, the time consumption of the whole process is greatly shortened, and the continuous operation of the JAVA system is realized.
According to the invention, because the plug-in structure divides the program into a plurality of modules on the physical layer, the starting speed of the main program is naturally improved, and simultaneously, each plug-in module only needs to be loaded with an independent jar file during starting, the time from the first loading of the plug-in to the completion of the starting is not more than 100MS, the starting time of the plug-in is not more than 10MS, the plug-in updating time system needs to be stopped, unloaded, loaded with a new plug-in and started with the plug-in, the total time is not more than 100MS, and the problem of the imperceptible hot upgrading deployment of the production environment is really solved.
In the cluster environment, new nodes are added only by deploying the main program, and after the system is started, the background selects the plug-in into the response node, and the plug-in engine automatically pulls the corresponding plug-in package from the database to complete the plug-in function deployment of the new nodes.
The invention is compatible with cluster environment and Spring, and ensures that all the functions of Spring can be effectively used. The operating system environment is transparent, the upgrading process does not need manual remote control, and the upgrading can be realized by separating operation and maintenance personnel. The problem of complex management of multi-container management deployment is solved, and all the containers are delivered to a plug-in engine for automatic deployment, updating and unloading. When the plug-in modules are used in the development process, each plug-in is independently developed, packaged and deployed, code writers only need to read interface documents in the development process to complete specific implementation, and do not need to scatter efforts to read main program source codes and source codes of other plug-ins, so that the definition and the safety of the functional modules are greatly improved.
It is to be understood that both the foregoing general description and the following detailed description of the present invention are exemplary and explanatory and are intended to provide further explanation of the invention as claimed.
Drawings
FIG. 1 is a schematic structural diagram of the present invention.
Fig. 2 is a schematic diagram of a system integration structure.
FIG. 3 is a schematic diagram of the topology of the plug-in container and the master container.
FIG. 4 is a plug-in publishing interface.
Fig. 5 shows the situation of automatically registering nodes after the system is started.
FIG. 6 is a diagram of device resource information after system startup.
FIG. 7 is a plug-in rollback interface.
Detailed Description
To facilitate understanding of those skilled in the art, the structure of the present invention will now be described in further detail by way of examples in conjunction with the accompanying drawings: it should be understood that the steps mentioned in this embodiment, except for the sequence specifically mentioned, can be performed simultaneously or partially simultaneously according to the actual requirement,
with reference to figure 1 of the drawings,
a method for uninterrupted operation of JAVA system,
based on a system integration structure, the system integration structure isolates different bean containers; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides communication interfaces between different plug-ins, the system integration structure provides communication interfaces between the plug-ins and the main container, and the plug-ins are provided with the monitor.
The system integration structure specifically comprises:
referring to fig. 2, a ROOT application context is automatically created as a ROOT node for container management when a Spring frame is started, a plug application context plug-in module container management is automatically created after the Spring frame is started, and a parent is set as a ROOT node, so as to implement isolation between bean containers. Each ClassLoader object will have a parent attribute inside it that points to its parent loader.
In the embodiment, a comprehensive planning and configuration model of modern java-based enterprise application programs on any deployment platform is provided through a Spring framework. The Spring Framework is an application program Framework of an open source Java/Java EE full-function stack (full-stack) and is created for solving the development complexity of enterprise application programs. The application context is used as a root node of container management in the Spring frame, and can be used for acquiring various bean components in the container, registering monitoring events, loading resource files and other functions. And then further establishing PluginApplicationContext plug-in module container management, realizing the state marking of the plug-ins and realizing the statement of bean containers, for example, if java classes annotated with @ controller, @ Service, @ replication, @ Component and the like are scanned, the beans are easily brought into Spring container management.
Then, when the container of the system integration structure is loaded, the system integration structure automatically creates an independent ClassLoader object for/realizing IO between the isolation plug-in and the main program.
In this embodiment, the ClassLoader is used for loading a Class, and is responsible for converting a byte code form of the Class into a Class object in a memory form. The byte codes of Class can be from Class in jar package. Each Class object has a Class loader field inside to identify which Class loader it is loaded by.
And finally, the system integration structure independently creates an ApplicationContext object for each plug-in, connects the ClassLoader of the environment object to a plug-in jar file, and sets a communication interface between the plug-ins through a corresponding communication protocol. For example, the inside of the plug-in engine uses the @ Caller object and the @ Supplier object as interfaces for providing communication between the plug-ins according to the communication protocol. The ApplicationContext object of each plug-in is a child object of the PluginApplicationcontext, and can call the beans in the multi-layer parent object at will to realize the communication between the plug-ins and the main container.
Through the special composition of the system integration structure, the isolation between different bean containers is realized, the IO between the plug-in and the main program is isolated, the communication interface is provided between different plug-ins, and the communication interface is provided between the plug-in and the main container.
The following is a description of the control performed by the present application according to the above system integration structure, so as to implement the method for uninterrupted operation of the JAVA system.
The method comprises the following steps:
s0, the main program is started, and the main program automatically loads the plug-in engine.
S1, scanning the deployment environment and registering the current environment to the equipment management center. The plug-in engine scans the deployment environment, registers the current environment to the equipment management center, and the mechanism is IP, port and equipment number, supports cluster deployment in the same equipment, and supports multi-equipment and multi-environment deployment.
And S2, checking the plug-in state in the current service through the plug-in engine, and performing corresponding operation on the plug-in according to the state. The operations include at least a startup plug-in, an uninstallation plug-in, and a deployment plug-in. The plugin is provided with a status flag, for example, in the present embodiment, the @ Controller is used as one of the flags, and is used for loading a specific class inside the plugin into an MVC frame of a main program as a user side request entry, further scanning the annotations such as @ RequestMapping in the @ Controller class as a direct request address of the url, and simultaneously marking the address in the main program to be accessible to the user after the plugin is successfully started.
Through the step S2, the system integration structure is started, and the normal plug-in which needs to be started is started at the same time.
S3, when the plug-in is updated, the following steps are executed:
s3.1, stopping the plug-in to be updated, comprising the following steps:
s3.1.1, canceling the association between the bean container and the main program; the method specifically comprises the steps of logging out the association of all @ Controller type bean containers in a plug-in a main program, removing a template rendering list, triggering an event, and carrying out isolation backup on an uninstalled plug-in. Because the bean containers are isolated from each other, the association between the bean container and the main program is cancelled only by checking the associated bean containers in the Classloader through the plug-in manager and releasing one by one.
S3.1.2, releasing the link between IO between the plug-in and the main program and the corresponding jar file; the link between the IO between the disconnection plug-in and the main program and the corresponding jar file is specifically to destroy the ClassLoader and release the link between the IO and the corresponding jar file. By destroying the ClassLoader, the corresponding Class can be unloaded, and after the destruction, all instances of the Class are already destroyed by the GC, that is, any instance of the Class does not exist in the JVM. At this point, the ClassLoader loading the class has already been GC; class objects of the class are not referenced anywhere. The lifecycle of the class is also ended when the class object of the class is no longer referenced. Because IO between the plug-in and the main program is isolated from each other, the plug-in manager sends an event notification to the OKFramework for executing user-defined release processing, and then the Classloader destroys and releases the associated IO.
S3.1.3, disconnecting the communication interface between the plug-in to be updated and other plug-ins, and disconnecting the communication interface between the plug-in to be updated and the main container; after the plugin is logged off, all plugin functions in all systems are immediately offline, but other plugin and main program functions are not affected.
S3.1.4, deleting the template engine to be updated from the rendering list of the main program, and stopping the process; and updating the plug-in state change of each device by the OKFramework.
We stop the plug-in to be updated, via step S3.1. And then, starting the new plug-in, thereby replacing the plug-in to be updated and realizing updating.
S3.2, starting a new plug-in, wherein the method for starting the new plug-in is similar to the method for stopping the plug-in to be updated, and the method comprises the following steps:
s3.2.1, scanning and associating bean containers, and checking the associated authority to the main program security framework; the plug-in scans the bean container of the @ Controller type and checks the associated authority to the main program security frame. At this point, the initial start of the new plug-in is successful.
S3.2.2, linking the IO between the new plug-in and the main program to the corresponding jar file; specifically, the IO is linked to the corresponding jar file through the ClassLoader.
S3.2.3, configuring the communication interface between the new plug-in and other plug-ins, and configuring the communication interface between the new plug-in and the main container;
s3.2.4, adding the template engine inside the new plug-in to the rendering list of the main program, adding the template engine inside the successfully started plug-in to the spring MVC template rendering list of the main program, finishing the start of the plug-in at the moment, and triggering an event after the start of the plug-in is finished. Thereby completing the update.
The update/upgrade operation of the plug-in is achieved by step S3.2.
And S3.3, reserving the plug-in to be updated in the database, and calling the plug-in to be updated through the database when the plug-in is backed off. And each time the plug-in is updated/upgraded, the plug-in of the old version can be kept in the database, so that the rollback of the historical plug-in is facilitated.
S4, monitoring the plug-in through the system integration structure to obtain the life cycle of the plug-in. Different plug-in deployments can be performed in the plug-in management background aiming at specific containers so as to match plug-ins with different service pressures according to the performance of the containers. Each plug-in may be viewed in the background for specific information such as name, presentation, version number, author, presence of page components, release date, start time, etc.
Repeating the step S3, that is, after the plug-in is deployed to the specific container, the plug-in engine asynchronously starts the plug-in, completes the loading operation of the plug-in, and triggers the corresponding event to notify the main program and the plug-in itself.
Experimental data
By the method for uninterrupted operation of the JAVA system based on the system integration structure provided by this embodiment, an instantiation operation is performed on a bean container, as shown in fig. 4, to obtain a plurality of new versions of plug-ins. When a new plug-in is deployed, only the plug-in package file needs to be dragged into the upper right corner area of the 'figure 4', the management background can automatically finish the uploading operation of the plug-in, and then the plug-in file is binary loaded into the database; when the plug-in is issued according to the nodes, the plug-in engine can automatically restore the plug-in files from the database to the hard disk directory, and the function of automatically loading multiple nodes is realized. The cluster deployment is completed through one-key uploading operation, the process of relying on manual operation of operation and maintenance personnel is thoroughly eliminated, and all processes do not influence the operation of a main program and other modules.
And then, automatically registering and registering current system information with the equipment management center, and only completing system deployment and starting when nodes are added, without cluster configuration work.
And adding a new node in the cluster environment only needs to deploy a main program, and after the system is started, the background selects a plug-in into the response node, and the plug-in engine automatically pulls a corresponding plug-in package from the database to complete the plug-in function deployment of the new node.
The first loading and starting completion time of the plug-ins is not more than 100MS, the starting time of the plug-ins is not more than 10MS, the plug-in updating time system is subject to stopping, unloading, new plug-in loading and plug-in starting, and the total time length is not more than 100 MS. The problem of non-inductive hot upgrade deployment of a production environment is really solved.
Referring to fig. 6, fig. 6 is a resource information diagram of the device after the system is started, and the method or the system provided by the present invention is implemented to monitor the running state of the device.
If the program bug is found in the running process, the program bug can be directly returned in the historical version, as shown in fig. 7, the function that all containers automatically return to the specific version is completed in one key, the cost and risk of system maintenance are greatly reduced, and all operations are not stopped in the whole process.
Example two
A JAVA system uninterrupted operation system is based on a system integration structure, wherein the system integration structure isolates different bean containers; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides a communication interface between different plug-ins, and the system integration structure provides a communication interface between the plug-ins and the main container.
EXAMPLE III
A computer readable storage medium storing a computer program which, when executed by a processor, implements a method of uninterrupted operation of a JAVA system.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
It should be noted that in the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The invention may be implemented by means of hardware comprising several distinct elements, and by means of a suitably programmed computer. In the unit claims enumerating several means, several of these means may be embodied by one and the same item of hardware. The usage of the words first, second and third, etcetera do not indicate any ordering. These words may be interpreted as names.
While preferred embodiments of the present invention have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including preferred embodiments and all such alterations and modifications as fall within the scope of the invention.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is also intended to include such modifications and variations.
In the description of the present invention, it is to be understood that the terms "first", "second" and the like are used for descriptive purposes only and are not to be construed as indicating or implying relative importance or implying any number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature. In the description of the present invention, "a plurality" means two or more unless specifically defined otherwise.
In the present invention, unless otherwise expressly stated or limited, the terms "mounted," "connected," "secured," and the like are to be construed broadly and can, for example, be fixedly connected, detachably connected, or integrally formed; can be mechanically or electrically connected; either directly or indirectly through intervening media, either internally or in any other relationship. The specific meanings of the above terms in the present invention can be understood by those skilled in the art according to specific situations.
In the present invention, unless otherwise expressly stated or limited, the first feature "on" or "under" the second feature may be directly contacting the first and second features or indirectly contacting the first and second features through an intermediate. Also, a first feature "on," "over," and "above" a second feature may be directly or diagonally above the second feature, or may simply indicate that the first feature is at a higher level than the second feature. A first feature being "under," "below," and "beneath" a second feature may be directly under or obliquely under the first feature, or may simply mean that the first feature is at a lesser elevation than the second feature.
In the description herein, references to the description of the term "one embodiment," "some embodiments," "an example," "a specific example," or "some examples," etc., mean that a particular feature, structure, material, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the invention. In this specification, the schematic representations of the terms used above should not be understood to necessarily refer to the same embodiment or example. Furthermore, the particular features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples. Furthermore, various embodiments or examples and features of different embodiments or examples described in this specification can be combined and combined by one skilled in the art without contradiction.
Claims (10)
1. A JAVA system uninterrupted operation method is characterized in that:
based on a system integration structure, the system integration structure isolates different bean containers; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides communication interfaces for different plug-ins, and the system integration structure provides communication interfaces for the plug-ins and the main container;
the method comprises the following steps:
scanning a deployment environment, and registering a current environment to an equipment management center;
when updating the plug-in, the following steps are performed:
stopping the plug-in to be updated: canceling the association between the bean container and the main program; releasing the link between IO between the plug-in and the main program and the corresponding jar file, disconnecting the communication interface between the plug-in to be updated and other plug-ins, and disconnecting the communication interface between the plug-in to be updated and the main container;
deleting the template engine to be updated from the rendering list of the main program, and stopping the process;
starting a new plug-in: scanning and associating bean containers, and checking associated authorities to a main program safety frame;
linking IO between the new plug-in and the main program to corresponding jar files, configuring communication interfaces between the new plug-in and other plug-ins, and configuring communication interfaces between the new plug-in and the main container; and adding the template engine in the new plug-in to the rendering list of the main program, completing starting and further completing updating.
2. A method according to claim 1, wherein the method comprises the following steps: the system integration structure for isolating different bean containers comprises the following steps:
creating a ROOTApplicationContext as a root node of container management;
and creating PluginAplicationContext plug-in module container management, and setting parent as ROOT node to realize the isolation between bean containers.
3. A method according to claim 1, wherein the method comprises the following steps: the IO between the system integration structure isolation plug-in and the main program comprises:
when the container is loaded, an independent ClassLoader object is created, and IO between the plug-in and the main program is isolated.
4. A method according to claim 3, wherein the method comprises: the link between the IO between the disconnection plug-in and the main program and the corresponding jar file comprises the following steps:
destroying the ClassLoader, and releasing the link between the IO and the corresponding jar file;
the linking of the IO between the plug-in and the main program to the corresponding jar file comprises:
the IOs are linked to the corresponding jar files through ClassLoaders.
5. A method according to claim 1, wherein the method comprises the following steps: the system integration architecture providing a communication interface between different plug-ins includes:
establishing an ApplicationContext object in the plug-in, connecting a ClassLoader of the ApplicationContext object to a jar file in the plug-in, and setting a communication interface between the plug-ins through a corresponding communication protocol.
6. A method according to claim 1, wherein the method comprises the following steps: the system integration architecture providing a communication interface between the plug-in and the main container comprises:
the method comprises the steps of setting an ApplicationContext object of a plug-in as a child object of the PluginApplicationcontext, and calling a bean in a multi-layer parent object to realize the purpose of providing a communication interface between the plug-in and a main container.
7. A method according to claim 1, wherein the method comprises the following steps: the plug-in is provided with a status flag.
8. A method according to claim 1, wherein the method comprises the following steps: the plug-in is provided with a monitor, and the system integration structure monitors the plug-in to acquire the life cycle of the plug-in.
9. A JAVA system uninterrupted operation system is characterized in that: based on a system integration structure, the system integration structure isolates different bean containers; the system integration structure isolates IO between the plug-in and the main program; the system integration structure provides a communication interface between different plug-ins, and the system integration structure provides a communication interface between the plug-ins and the main container.
10. A computer readable storage medium storing a computer program, wherein the computer program, when executed by a processor, implements a method of uninterrupted operation of a JAVA system as claimed in any of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111485743.9A CN114116069A (en) | 2021-12-07 | 2021-12-07 | Method, system and storage medium for uninterrupted operation of JAVA system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111485743.9A CN114116069A (en) | 2021-12-07 | 2021-12-07 | Method, system and storage medium for uninterrupted operation of JAVA system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114116069A true CN114116069A (en) | 2022-03-01 |
Family
ID=80367994
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111485743.9A Pending CN114116069A (en) | 2021-12-07 | 2021-12-07 | Method, system and storage medium for uninterrupted operation of JAVA system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114116069A (en) |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20040073782A1 (en) * | 2002-05-02 | 2004-04-15 | Adrian Price | Plug-in configuration manager |
| CN1941131A (en) * | 2005-10-02 | 2007-04-04 | 北京华旗资讯数码科技有限公司 | Portable electronic device with hard disk as storage medium |
| CN102411506A (en) * | 2011-07-07 | 2012-04-11 | 杭州典能科技有限公司 | Java-system business-unit plug-in type managing system and dynamic business-function changing method |
| CN106406929A (en) * | 2016-08-25 | 2017-02-15 | 成都交大光芒科技股份有限公司 | Implementation method of distributed informatization application integration platform application plug-in container |
| CN106681718A (en) * | 2016-12-16 | 2017-05-17 | 武汉中地数码科技有限公司 | Toolkit-based desktop side plugin frame and implementation method thereof |
| CN109597623A (en) * | 2018-12-05 | 2019-04-09 | 上海中商网络股份有限公司 | A kind of plug-in management method, device, equipment and storage medium |
-
2021
- 2021-12-07 CN CN202111485743.9A patent/CN114116069A/en active Pending
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20040073782A1 (en) * | 2002-05-02 | 2004-04-15 | Adrian Price | Plug-in configuration manager |
| CN1941131A (en) * | 2005-10-02 | 2007-04-04 | 北京华旗资讯数码科技有限公司 | Portable electronic device with hard disk as storage medium |
| CN102411506A (en) * | 2011-07-07 | 2012-04-11 | 杭州典能科技有限公司 | Java-system business-unit plug-in type managing system and dynamic business-function changing method |
| CN106406929A (en) * | 2016-08-25 | 2017-02-15 | 成都交大光芒科技股份有限公司 | Implementation method of distributed informatization application integration platform application plug-in container |
| CN106681718A (en) * | 2016-12-16 | 2017-05-17 | 武汉中地数码科技有限公司 | Toolkit-based desktop side plugin frame and implementation method thereof |
| CN109597623A (en) * | 2018-12-05 | 2019-04-09 | 上海中商网络股份有限公司 | A kind of plug-in management method, device, equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107515776B (en) | Method for upgrading service continuously, node to be upgraded and readable storage medium | |
| CN104679534B (en) | System application installation package loading processing method, apparatus and terminal | |
| CN102023881B (en) | Method and device for upgrading software as well as embedded device | |
| US8245216B2 (en) | Patch management system | |
| US6295611B1 (en) | Method and system for software recovery | |
| US9405630B2 (en) | Methods and apparatus to perform site recovery of a virtual data center | |
| CN107844343B (en) | Upgrading system and method for complex server application system | |
| US20040088397A1 (en) | System and method for management of software applications | |
| CN110727547A (en) | System and method for protecting Docker application container | |
| US8924947B2 (en) | Direct deployment of static content | |
| US8612799B2 (en) | Method and apparatus of backing up subversion repository | |
| CN114064213A (en) | Kubernets container environment-based rapid arranging service method and system | |
| US20050108704A1 (en) | Software distribution application supporting verification of external installation programs | |
| CN114528085A (en) | Resource scheduling method, device, computer equipment, storage medium and program product | |
| JP3901060B2 (en) | Application update processing method, update processing system, and update processing program | |
| CN115858086A (en) | Data recovery method, data recovery system, device and storage medium | |
| CN112286543B (en) | Application service deployment method and device | |
| CN114116069A (en) | Method, system and storage medium for uninterrupted operation of JAVA system | |
| US11461083B2 (en) | Configurable interface for customized job deployment | |
| JP2010086110A (en) | System for switching setting information and switching method | |
| US11119822B2 (en) | Linkage of fired jobs with interrelated actions | |
| CN113485759A (en) | Micro-service configuration information management system, method, electronic device and storage medium | |
| CN111158709A (en) | Cluster deployment method, device and equipment and computer readable storage medium | |
| CN112035352A (en) | Rapid automatic compiling and deploying method based on cloud life cycle management | |
| CN113419743B (en) | Comprehensive application script deployment method, device, equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |