CN107908402A - The hot restorative procedure of Java server-sides and system - Google Patents
The hot restorative procedure of Java server-sides and system Download PDFInfo
- Publication number
- CN107908402A CN107908402A CN201711014055.8A CN201711014055A CN107908402A CN 107908402 A CN107908402 A CN 107908402A CN 201711014055 A CN201711014055 A CN 201711014055A CN 107908402 A CN107908402 A CN 107908402A
- Authority
- CN
- China
- Prior art keywords
- java
- code
- repair
- javascript
- specific
- 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 128
- 230000008439 repair process Effects 0.000 claims abstract description 255
- 230000008569 process Effects 0.000 claims abstract description 63
- 230000002159 abnormal effect Effects 0.000 claims abstract description 11
- 238000012545 processing Methods 0.000 claims description 28
- 238000006243 chemical reaction Methods 0.000 claims description 27
- 238000004458 analytical method Methods 0.000 claims description 7
- 238000007726 management method Methods 0.000 description 31
- 238000011084 recovery Methods 0.000 description 16
- 230000006870 function Effects 0.000 description 14
- 238000005516 engineering process Methods 0.000 description 13
- 238000012360 testing method Methods 0.000 description 12
- 230000007547 defect Effects 0.000 description 9
- 230000007246 mechanism Effects 0.000 description 9
- 238000012423 maintenance Methods 0.000 description 7
- 238000004891 communication Methods 0.000 description 6
- 238000010586 diagram Methods 0.000 description 6
- 238000011161 development Methods 0.000 description 5
- 230000009545 invasion Effects 0.000 description 4
- 238000012544 monitoring process Methods 0.000 description 4
- 238000007781 pre-processing Methods 0.000 description 4
- 238000012795 verification Methods 0.000 description 4
- 230000005856 abnormality Effects 0.000 description 3
- 238000004422 calculation algorithm Methods 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000003068 static effect Effects 0.000 description 3
- 230000001360 synchronised effect Effects 0.000 description 3
- 230000001960 triggered effect Effects 0.000 description 3
- 230000008901 benefit Effects 0.000 description 2
- 238000004590 computer program Methods 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 238000004806 packaging method and process Methods 0.000 description 2
- 238000005067 remediation Methods 0.000 description 2
- 238000013024 troubleshooting Methods 0.000 description 2
- 235000006719 Cassia obtusifolia Nutrition 0.000 description 1
- 235000014552 Cassia tora Nutrition 0.000 description 1
- 244000201986 Cassia tora Species 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 230000008676 import Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000011056 performance test Methods 0.000 description 1
- 238000012805 post-processing Methods 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
- 230000001052 transient effect Effects 0.000 description 1
- 238000012384 transportation and delivery Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
- Information Transfer Between Computers (AREA)
Abstract
This application discloses a kind of hot restorative procedure of Java server-sides, including：In java applet operational process, determine whether that repairing code using JavaScript replaces specific Java code operation according to operational decisions；If so, then enter in next step；In java applet operational process, repair code using the JavaScript generated to the specific Java code and replace the specific Java code operation.The specific Java code, is the abnormal J ava codes corresponding Java code of traffic segment to be replaced that either java applet is included included in java applet.The technical solution that the application provides, the online hot repair that make use of JavaScript realizes to java applet as the characteristic of dynamic script language is answered, JVM currently running to java applet be not invasive, so as to solve the problem of JVM currently running to server-side in existing hot-fixing is invasive big, and rehabilitation cost is high.
Description
The present application claims priority of chinese patent application having application number 201710696733.7 entitled "Java server thermal repair method and system" filed by chinese patent office on 15/08/2017, which is incorporated herein by reference in its entirety.
Technical Field
The application relates to the field of internet, in particular to a Java server side thermal restoration method. The application also relates to a Java server side thermal repair device, a Java server side thermal repair system and electronic equipment for realizing the Java server side thermal repair method.
Background
Java has been widely used in the internet industry as a programming language suitable for the development of network applications. Along with the fact that internet services are richer and richer, the service volume is larger and larger, the requirements for repairing problems occurring at a network server side are higher and higher, for example, the shorter the requirement for solving time for repairing an emergency problem is, the better the requirement for influencing the user is, the smaller the requirement is, the better the requirements are. In general enterprise internet applications, the Java server often solves the emergency problem only through a series of processes of problem location, solution determination, testing and reissuing, and the constraint of the processes causes the time consumption of emergency issue to be very long, and sometimes, reissue is performed only for modifying a line of codes and at a great cost.
The existing hot repair technology of the Java server can reduce problem repair cost, wherein hot repair refers to repair of software bugs under the condition that a user does not sense in operation, and is a mode for quickly repairing the defects of product software versions at low cost. The existing Java server side hot repair method generally carries out hot repair on problems through dynamic mount of Java, and specifically comprises the following scheme: using the attribute API exposed by the running JVM (the attribute API is part of the Java official tool and is generally packaged into a special file), allowing a second Java process to communicate with the JVM; defining a second parameter by using a Java agent (namely Java agent) to receive an instance of Instrumentation, and then redefining the class to be repaired by using the API of the Instrumentation so as to repair the problem without restarting the application.
The existing Java server side hot repair technology has the following problems: the hot repair technology needs to additionally create a Java process to communicate with the currently running JVM, and is high in invasion and repair cost for the currently running JVM.
Disclosure of Invention
The application provides a Java server side hot repair method, which aims to solve the problems of high invasion and high repair cost of the currently running JVM of a server side in the existing hot repair technology.
The application provides a Java server side hot repair method, which comprises the following steps:
in the running process of the Java program, determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to a running decision; if yes, entering the next step;
and in the running process of the Java program, replacing the specific Java code with the JavaScript repair code generated for the specific Java code to run.
Preferably, the specific Java code is an abnormal Java code included in the Java program or a Java code corresponding to a service segment to be replaced included in the Java program.
Preferably, the abnormal Java code includes at least any one of the following exceptions:
code exception scenarios;
a logical error scenario;
algorithmic error scenarios.
Preferably, the JavaScript recovery code is a Nashorn-based JavaScript code; the Nashorn is a lightweight JavaScript running environment based on Java native JVM.
Preferably, the determining whether to use the JavaScript repair code to replace the specific Java code to run according to the running decision is that the JavaScript repair code in this step is obtained by any one of the following manners:
writing JavaScript repair codes aiming at the specific Java codes by using a JavaScript language;
and generating Java repair codes aiming at the specific Java codes, and then automatically converting the Java repair codes into the JavaScript repair codes.
Preferably, the automatically converting the Java repair code into the JavaScript repair code includes: performing the following conversion by code analysis of the Java repair code:
automatically converting the Java type dependence into JavaScript type dependence;
automatically converting the Java strong type into a JavaScript weak type;
and automatically binding the Spring context to the context of the JavaScript runtime.
Preferably, before the step of automatically converting the Java repair code into the JavaScript repair code, the method includes:
generating Java repair codes for replacing specific Java codes needing to be replaced, wherein the specific Java codes are contained in a Java program;
and issuing a conversion command, and triggering the step of automatically converting the Java repair code into a JavaScript repair code.
Preferably, in the running process of the Java program, the JavaScript recovery code generated for the specific Java code is used to replace the specific Java code to run, and the JavaScript recovery code in this step is obtained by any one of the following manners:
in the running process of the Java program, acquiring the JavaScript repair code from the local cache space of the Java program during service processing;
and in the running process of the Java program, requesting to issue the JavaScript repair code when performing service processing.
Preferably, the obtaining the JavaScript repair code from the local cache space of the Java program further includes any one of the following manners:
the JavaScript repair codes are synchronized to the Java program by accessing a Jar packet and cached in a local cache space of the Java program; the access Jar package is integrated in the Java program;
and synchronizing the JavaScript repair code to the Java program through configuration, and caching the JavaScript repair code in a local cache space of the Java program.
Preferably, the operation decision is obtained by any one of the following methods:
in the running process of the Java program, the running decision is obtained from the local cache space of the Java program when the business processing is carried out;
and in the running process of the Java program, requesting to issue the running decision when performing service processing.
Preferably, the obtaining the operation decision from the local cache space of the Java program further includes any one of the following manners:
synchronizing the operation decision to the Java program by accessing the Jar packet timing, and caching the operation decision in a local cache space of the Java program; the access Jar package is integrated in the Java program;
and synchronizing the running decision to the Java program through configuration, and caching the running decision in a local cache space of the Java program.
Preferably, the operation decision includes receiving an external manual decision made according to the operation or deployment condition of the Java program.
The application provides a hot repair system of Java server, includes: a management module and a repair module; wherein,
the management module is used for issuing an operation decision and an operation code to the repair module; the run code contains corresponding JavaScript fix code for replacing specific Java code; the operation decision comprises relevant information whether to replace the specific Java code with a JavaScript repair code generated for the specific Java code to operate in operation; the specific Java code is an abnormal Java code contained in the Java program or a Java code corresponding to a service segment to be replaced contained in the Java program;
and the repairing module is used for replacing the specific Java code with the JavaScript repairing code generated for the specific Java code to run according to the running decision in the running process of the Java service system.
Preferably, the system comprises a code conversion module, which is used for automatically converting the Java repair code into a corresponding JavaScript repair code and providing the JavaScript repair code to the management module; the JavaScript repair code is provided for the repair module to use through the management module; the Java repair code is Java code generated for the specific Java code.
Preferably, the system comprises a configuration module for providing a configuration mechanism to a management module, the management module triggers the code conversion module to convert the Java repair code into a corresponding JavaScript repair code through the configuration mechanism, and the management module synchronizes the operation decision and the JavaScript repair code to the repair module through the configuration mechanism.
Preferably, a code repository module is included for storing the Java repair code for use by the code conversion module.
Preferably, the Java application management system comprises a decision module for generating the operation decision, including receiving an external manual decision made according to the operation or deployment condition of the Java application, where the operation decision is issued to the repair module by the management module for use.
Preferably, the JavaScript recovery code recovery system comprises an access module for providing a communication service, and the management module synchronizes the operation decision and the JavaScript recovery code to the recovery module at regular time through the access module.
Preferably, the Java service system comprises a cache module, configured to cache the operation decision and the JavaScript repair code in a local cache space of the Java service system.
This application provides a Java server side thermal remediation device simultaneously, includes:
the management unit is used for determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to the running decision in the running process of the Java program; if yes, entering the next step;
and the repairing unit is used for replacing the specific Java code with the JavaScript repairing code generated for the specific Java code to run in the running process of the Java program.
This application provides an electronic equipment simultaneously, includes:
a memory, and a processor;
the memory is to store computer-executable instructions, and the processor is to execute the computer-executable instructions to:
in the running process of the Java program, determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to a running decision; if yes, entering the next step;
and in the running process of the Java program, replacing the specific Java code with the JavaScript repair code generated for the specific Java code to run. Compared with the prior art, the method has the following advantages:
the application provides a Java server side thermal repair method, a Java server side thermal repair device and electronic equipment; according to the method, the device and the electronic equipment, whether the JavaScript repair codes are used for replacing the specific Java codes to operate or not is determined according to the operation decision in the operation process of the Java program; and if so, replacing the specific Java code with a JavaScript repair code generated for the specific Java code in the running process of the Java program to run.
According to the technical scheme, the online hot repair of the Java program is realized by utilizing the characteristic that JavaScript is used as a dynamic scripting language and a JavaScript engine provided by JDK, and the JavaScript is compiled into Java bytecode and executed in JVM, so that when the JavaScript code is used for replacing a corresponding Java code to run, another process is not needed to be started for communicating with the JVM, and the currently running JVM of the Java program is not invasive, so that the problems that the currently running JVM of a server side is large in invasion and the repair cost is high in the existing hot repair technology are solved.
Drawings
FIG. 1 is a flowchart of a Java server hot repair method;
FIG. 2 is a diagram of a Java server hot repair system;
FIG. 3 is a diagram of a Java server thermal repair apparatus;
FIG. 4 is a schematic diagram of an electronic device for implementing a Java server hot repair method.
Detailed Description
In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present application. This application is capable of implementation in many different ways than those herein set forth and of similar import by those skilled in the art without departing from the spirit of this application and is therefore not limited to the specific implementations disclosed below.
The application provides a Java server side hot repair method. The application also provides a hot repair system of the Java server side. The application also relates to a Java server side thermal restoration device and electronic equipment for realizing the Java server side thermal restoration method. Details are described in the following examples one by one.
An embodiment of the application provides a hot repair method for a Java server.
A Java server thermal repair method according to an embodiment of the present application is described below with reference to fig. 1.
Fig. 1 is a schematic processing flow diagram of a Java server hot repair method according to an embodiment of the present application.
Java is a mainstream network programming language in the internet industry, and is widely used for developing internet application products. In practical application, as a complex software product, although the Java server product is released and deployed on the network after detailed test verification of each product stage, bug is still hard to avoid, so that general internet applications can release new versions in sequence to solve the problem. In the continuous delivery stage, the Java server product can conveniently redeploy a new version, but once the formal internet is on line, the redeployment process is complex in most cases and is not allowed to stop. Along with the increase of the service volume, the problem repair cost of the Java server side is higher and higher, the problem of the server side is quickly repaired at low cost by adopting a thermal repair technology under the condition that a user does not perceive the problem, and good benefits can be brought to enterprises.
According to the hot repair system of the Java server side, JavaScript and Java are mutually called by means of an embedded JavaScript engine Nashorn of Java provided by JDK8, JavaScript codes are called in the running process to repair bugs in Java services, so that a Java process and a JVM do not need to be additionally started for communication, and therefore, no invasion is caused to a native JVM in which the Java services run.
The Java server is an application program which is developed by using Java language and corresponding framework and provides service for the client, and comprises the steps of providing resources for the client, saving client data and the like. In practical application, a server in the field of web internet is realized by using Java technology, and is a Java web server, and according to practical situations, a servlet can be directly used for developing a server application program or a framework, for example: spring frames, etc.
The JavaScript is an transliterated script language, is a dynamic type, weak type, prototype-based language and is internally provided with a support type. Its interpreter is called the JavaScript engine.
The jdk (Java Development kit), which is a software Development kit in Java language, includes various basic components, such as compiler Java, and compiles Java source programs into bytecode and packaging tool jar. JDK has different types of versions (Edition) corresponding to different usage scenarios, for example, Standard version J2SE (Standard Edition) or Java SE, Enterprise version J2EE (Enterprise Edition) or Java EE, (Micro Edition) J2ME or Java ME for mobile devices and embedded device Java applications, and Java programs can be compiled through JDK. Of course, running a Java program ensures that the corresponding JRE (i.e., Java runtime environment) is installed. JDK evolved to now come in multiple versions (versions), binding the Rhino-based JavaScript engine from JDK6, allowing JavaScript code to be embedded in Java up to JDK8, providing a higher performance embedded JavaScript engine Nashorn, which strengthens the support for JavaScript and Java calls to each other.
The jvm (Java Virtual machine), i.e. Java Virtual machine, is an imaginary computer implemented by simulating various computer functions on an actual computer, and provides platform independence of Java language. The JVM has its own sophisticated hardware architecture, such as processor, stack, registers, etc., and has a corresponding instruction system, which mainly interprets its own instruction set (i.e., bytecode) and maps to the native CPU's instruction set or operating system's system calls. Therefore, the Java language compiler only needs to generate the bytecode running on the JVM for the Java source code, and the JVM interprets the bytecode into machine instruction execution on a specific platform (e.g. Windows, Linux) when executing the bytecode, so that information related to the specific platform is shielded, and the property that the Java language runs on a plurality of platforms without modification is realized.
The invasiveness refers to the influence range or dependency, and in the present application, the absence of invasiveness to the native JVM means that communication with the JVM is not required, so that the JVM in the current running environment of the Java program is not influenced and is not dependent on the currently running JVM.
Because the JDK8 platform strongly supports the Nashorn, the service end hot repair technology realized based on the Nashorn can solve the emergency problem repair without reissuing the emergency problem repair technology. The characteristics that Nashorn compiles JavaScript into Java byte codes by using language characteristics based on JSR292 so as to allow JavaScript codes to be embedded in Java, and the Nashorn allows Java classes to be called in the JavaScript, accesses classes and creates instances, can inherit the classes and call static methods of the classes provide a mechanism for running by using the JavaScript codes to replace corresponding Java codes, and can use a Nashorn JavaScript engine in a Java program in a programming mode. For example, Nashorn supports Java code to directly call a JavaScript function defined in a script file, may take a Java object as a parameter of the function and receive returned data in a Java method that calls the function; but also to pass any Java object without losing type information on the JavaScript side; the script itself is executed in the JVM virtual machine, so that the powerful functions of the Java API and external libraries of the Nashorn engine can be fully utilized.
The embodiment of the Java server hot repair system provided by the present application is described by taking a Bug appearing in a certain service in a Java service system (i.e. a Java program) as an example. It should be noted that local hot upgrade of the Java program, such as upgrade of a certain program segment, can also be implemented by using the Jav server hot repair system provided by the present application.
Step S101, in the running process of the Java program, determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to a running decision; if yes, the next step is carried out.
In the running process of the Java program described in this embodiment, the scenery spot scene of the Java program is a Java application program running on a certain server, which actually refers to a process generated in the running process of the application program.
The hot repair means that the program is repaired when the program is not stopped, and the actually repaired code is not static Java program code but code on which a process generated by the Java program is based during operation.
The operation decision is to analyze the influence degree and determine the current network repair decision according to the faults exposed in the monitoring and operation and maintenance processes of the current network operation condition of the Java server and the defects in the actively discovered Java program, wherein the current network repair decision comprises the repair time, repair means and other repair related information of the faults or the defects. In practical application, problem grades are divided according to factors such as the severity and the influence range of found faults or defects, for example, a fatal problem that a fault or a service cannot be used is caused, and emergency repair is needed; the problem that part of users can use the service after needing multiple attempts is serious; causing the rate at which individual users access high speed traffic to drop while busy is a general problem. And determining further repair time and repair means according to the problem level, wherein the information is contained in the operation decision, such as whether the operation with the problem can be continued until the repair is carried out in the next new version, whether the on-line emergency repair is required under the condition of not interrupting the service, whether the on-line repair is required when the service is idle, and the like. If the online hot repair is determined to be needed, modifying the corresponding service Java code offline to obtain a Java repair code (also called a patch code), converting the Java repair code into a corresponding JavaScript repair code, and when a specific Java code corresponding to the fault or defect is executed in the running process in the designated Java program in the running decision, replacing the running of the specific Java code with the corresponding JavaScript repair code.
When a certain service of an online running Java service system has Bug repair needs, locating a problem and determining a repair scheme, obtaining a Java repair code by modifying a specific Java code corresponding to the service needing repair, automatically converting the Java repair code into the corresponding JavaScript repair code by configuration triggering, making an operation decision to specify the JavaScript repair code corresponding to the service to be operated, regularly refreshing the JavaScript repair code and operation decision information to a local cache space of an online running Java program, and when a service request initiated by a user reaches a corresponding service module in the Java program for processing, replacing the originally deployed specific Java code by the JavaScript repair code for operation according to the operation decision by the Java program, thereby completing the service Bug repair. Therefore, since the JavaScript is a dynamic script, redeployment is not needed, the application is not needed to be restarted, the abnormal recovery is completed in the running process of the Java program, the continuous service use of the user is not influenced in the abnormal recovery process, the recovery cost is reduced, good user experience is provided, and the problem caused by long time consumption of redeployment and restarting of the application is avoided.
In addition, the JavaScript recovery code in this application is a generalized recovery, and besides being applied to the scenario that Bug needs to be recovered in the Java service system, the JavaScript recovery code in this application may also be applied to a service replacement scenario when a certain service in the Java service system is replaced with a new service, that is, in an old service replacement scenario, by using the method provided in this application, in the running process of the Java program, according to a running decision, a specific Java code for the old service to be replaced is replaced with a corresponding JavaScript new service code to run, and these JavaScript new service codes are also referred to as JavaScript recovery codes. For example, an old service processing flow needs to be adjusted to a new service unreasonably, and when the Java code of the new service is executed online after development and testing are completed, hot replacement of the old service can be achieved by the method provided by the present application without redeploying and restarting the application.
Therefore, the specific Java code in this step is an abnormal Java code included in the Java program or a Java code corresponding to a service segment to be replaced included in the Java program; wherein the abnormal Java code at least comprises any one of the following exceptions:
code exception scenarios;
a logical error scenario;
algorithmic error scenarios.
The code exception scene refers to defects existing in written source codes, and is not exposed in unit testing, integration testing, function testing and verification of each stage of pre-opening due to the fact that testing means cannot be fully covered and the like, so that existing networks are left, for example, character string typing errors and if statements omit the then branch.
The logic error means that the result of the program operation is inconsistent with the expected assumption, the program with the logic error can normally operate, and the system does not give prompt information and is difficult to find. The actual situation of the existing network is often much more complex than the test environment, and such defects are triggered in some processes. For example, a logical operator in a control program flow branch uses an error, and may fail to trigger in a test case and miss an existing net.
The algorithm errors mean that some algorithms used in program execution have defects, and the defects are not triggered in pressure and performance tests and are omitted to the existing network.
Examples are as follows: special processing of the server is performed by checking the X-Priority header in the HTTP request, assuming that there is a running Java application. This check is implemented using the following tool classes:
an "X-precision" spelling error that results in a failure to pass header verification may be discovered while an application is running, where the header is generated by another application without spelling errors. In the case of not allowing shutdown and restart, the redeployment process may be difficult, and the problem can be solved by adopting the method provided by the application.
In the embodiment provided by the application, the Java service system determines to run a JavaScript repair code to replace a specific Java code to run according to the running decision in the running process, wherein the JavaScript repair code is a JavaScript code based on Nashorn; the Nashorn is a lightweight JavaScript running environment based on Java native JVM. The Nashorn can compile JavaScript into Java byte codes and transmit the Java byte codes to the JVM, and the performance is high. In practical application, the JavaScript recovery code can be obtained by any one of the following manners:
writing JavaScript repair codes aiming at the specific Java codes by using a JavaScript language;
and secondly, generating a Java repair code aiming at the specific Java code, and then automatically converting the Java repair code into the JavaScript repair code. Under the condition that programming language capability allows, namely under the condition that a programming language threshold is not considered, JavaScript codes for repairing the Bug can be written directly by using a JavaScript language aiming at the Bug exposed in the Java service system, and the Bug is not automatically converted into the JavaScript codes by using the Java codes; of course, after the problem in the Java service system is located, the problem may be repaired by modifying the Java code originally including the problem, and the Java repair code obtained after modification is automatically converted into a corresponding JavaScript repair code.
In this embodiment, a second implementation is adopted to automatically convert a Java repair code into the JavaScript repair code, and an automatic code conversion tool or an automatic conversion function module needs to be developed for processing, where the second implementation includes: performing the following conversion by code analysis of the Java repair code: automatically converting the Java type dependence into JavaScript type dependence; automatically converting the Java strong type into a JavaScript weak type; and automatically binding the Spring context to the context of the JavaScript runtime.
The Java type dependency refers to a dependency of one Java class on another Java class, for example, there is a method called takemoney (Bank) in the Employee class, and if the method uses the Bank class in its parameters, it can be said that the Employee class depends on the Bank class, and if the Bank class changes, the Employee class will be affected. The dependency relationship needs to be analyzed in the conversion from the Java code to the JavaScript code, and the original dependency relationship needs to be maintained in the converted JavaScript code.
The JavaScript type dependency refers to the dependency between JavaScript classes and the dependency between JavaScript code and Java code intermodulation time and Java classes. The JavaScript language did not support defining classes in the early days, but object-oriented programming could be implemented by simulating classes by some methods, e.g. simulating a class with constructors, prototype methods, etc., and the ECMAScript6 specification of the JavaScript language started to introduce classes, providing a simpler and clearer syntax for creating objects and handling inheritance. When the Java code is converted into the JavaScript code, the implementation of the class and the conversion of the dependency relationship need to be noticed, and it should be noted that the ecmascript5.1 specification supported by Nashorn does not introduce the class yet, and needs to simulate the class.
The Java strong type means that the Java language is a strong type language, variable types in Java are various, such as int char floor Boolean string, and the like, corresponding type declarations are required when declaring variables, different types are generally converted in an opaque and implicit manner, and different types are required to be converted forcibly when being converted mutually. For example, a String is required, which must be declared using String and cannot be declared with others such as int, without implicit conversion between each other.
The weak JavaScript type means that the type is not forcibly limited in the JavaScript language, and when a variable is assigned, the type can be automatically judged and implicit conversion is carried out. For example, declare any variable to be var, but not mandatory.
Context is an ordered sequence of attributes that define the context for objects residing within the environment, and for processes, context is the environment in which the process executes. The Spring context means that when the application is started, the Spring framework reads a configuration file to load the context into the memory and provide the runtime environment of the memory, and the context information includes services, such as e-mail, check and scheduling functions and the like. The Spring framework is a container framework which uses basic JavaBean to replace EJB (Enterprise Java Bean, JavaEE server-end component model), provides more Enterprise application functions and solves the complexity of Enterprise software application development. The JavaScript runtime context refers to an environment of the JavaScript code during execution. The Spring framework reads the configuration file of the application to load the context into the memory when the application is started, so that partial information of the current environment of the Java program operation is formed, the context of the operation is required to be analyzed when the Java code is converted into the JavaScript code, and the context is corresponding to the context environment of the JavaScript instead of the Java operation.
Specific examples are as follows:
converting Boolean objects of the Java codes into JavaScript Boolean values;
the method comprises the steps that all java.lang.number packaging objects are converted into java script numbers, including java Byte \ Short \ Integer and \ Long \ Float \ Double, and java.math.BigInteger and java.math.Bigdouble;
converting the Character and String objects of java into JavaScript Character strings;
converting the empty value of java into the empty value of JavaScript;
obtaining spring context through Java code, executing call or application or bind method in JavaScript to bind runtime context, wherein spring context can be obtained in runtime, and obtaining context through monitor when container is started.
In practical application, before the step of automatically converting the Java repair code into the JavaScript repair code is executed, the method includes:
generating Java repair codes for replacing specific Java codes needing to be replaced, wherein the specific Java codes are contained in a Java program;
and issuing a conversion command, and triggering the step of automatically converting the Java repair code into a JavaScript repair code. And obtaining the JavaScript repair code for replacing the specific Java code to run through the processing.
And S102, in the running process of the Java program, replacing the specific Java code with the JavaScript repair code generated for the specific Java code to run.
After the Java repair code used for repairing the Bug is converted into the JavaScript repair code based on Nashorn, if the processing decision of the Bug is that the JavaScript repair code is used for replacing a corresponding specific Java code to run in the running process of the Java service system to perform corresponding service processing, the JavaScript repair code in the step is obtained by adopting any one of the following modes after preprocessing is performed on the service request in the running process of the Java service system and when the service processing is performed:
the first method is as follows: in the running process of the Java program, acquiring the JavaScript repair code from the local cache space of the Java program during service processing;
the second method comprises the following steps: and in the running process of the Java program, requesting to issue the JavaScript repair code when performing service processing.
In the embodiment, the first mode is adopted for processing, so that the time cost of system operation is saved, and the processing efficiency is improved. The JavaScript repair codes cached by the Java service system in the local cache space of the Java service system are the JavaScript repair codes which are regularly synchronized and cached to the local of the Java program by accessing a Jar packet.
The access Jar package is integrated in the Java program and is some classes in a Java service system, and the Jar package in this embodiment provides communication services for transmitting JavaScript codes and running decision information.
In addition, the JavaScript recovery code cached by the Java service system in the local cache space thereof may also be synchronized to the Java program by configuration, and cached in the local cache space of the Java program.
The local cache space is a local storage space for the application program to run, and a general memory or a solid state disk or a mechanical hard disk can be used. In this embodiment, the local cache space is a part of space that is partitioned from a memory of a JVM where a Java program runs, and is specifically placed in a heap area of the JVM, and data is placed in a local cache of an application, so that access efficiency can be improved and network consumption can be reduced.
In the embodiment of the application, the operation decision of the Java service system comprises receiving an external manual decision made according to the operation or deployment condition of the Java program. After an operation decision is made, automatically converting the Java repair code modified aiming at the Bug into a JavaScript repair code through configuration triggering, and the operation decision can be regularly refreshed to a local cache space of a Java service system as the JavaScript repair code which is used for repairing a service or replacing a service and is operated by replacing a specific Java code, and the method comprises any one of the following modes:
the first method is as follows: synchronizing the operation decision to the Java program by accessing the Jar packet timing, and caching the operation decision in a local cache space of the Java program; the access Jar package is integrated in the Java program;
the second method comprises the following steps: and synchronizing the running decision to the Java program through configuration, and caching the running decision in a local cache space of the Java program. Specifically, in the embodiment, the first mode is adopted to reduce interaction between the Java service system and other programs or device modules during operation, and improve processing efficiency.
The external manual decision is a processing decision made according to manual operation, the manual operation refers to operation controlled by personnel, and when the stage of complete self-operation, maintenance and self-repair of the system is not reached, the fault discovery, positioning and solving generally require personnel intervention.
Specific examples are as follows:
the operation and maintenance personnel find that the memory occupation is slowly increased when the user uses a certain online function through JDK performance monitoring, but the problem does not occur in the test environment, and the operation and maintenance personnel find that the problem is not exposed in the test environment due to different online environments and test environment data sources when accessing a url corresponding to a certain section of Java code through analysis, but an object is not used any more but is still quoted to cause abnormality under certain conditions in online processing; after the problem influence degree and the repair scheme are confirmed, the emergency repair is determined to be needed, firstly, a corresponding service Java code is modified, the Java repair code is triggered to be converted into a JavaScript repair code through script configuration, and an operation decision that the JavaScript repair code is used for replacing an originally deployed specific Java code corresponding to the service to operate and the JavaScript repair code generated through conversion are regularly refreshed to a Java service system and cached in a local cache space, for example, the JavaScript repair code is refreshed once every 1 hour, and the operation efficiency can be improved through the regular refreshing; certainly, for very urgent situations, the operation decision and the JavaScript repair code can also be manually issued; after receiving a user service request, the Java service system firstly performs some pre-processing on the request, such as analysis and verification of a request message, and then transfers to service processing after the pre-processing is completed, in the service processing process, firstly, an operation decision is requested, a repair module reads the operation decision information executed this time from a local cache space, a code operated in the next step is judged according to the operation decision, and if the code is a JavaScript repair code, a corresponding JavaScript script is read and executed from the local cache space; and when the problem caused by the exception is not serious enough to require hot repair, and the decision information is that the originally deployed Java code is continuously executed, the original Java code is continuously run.
In addition, the Java service system may further obtain the operation decision by: and in the running process of the Java program, requesting to issue the running decision when performing service processing.
Due to the powerful support of Nashorn on a Java8 platform and the service end hot repair technology realized based on Nashorn, the emergency problem repair can be solved without release, and the problem of short-time performance reduction of an application program possibly occurring in the existing class hot replacement repair technology can be solved.
Based on the embodiment of the method for hot repair of the Java server, the application further provides an embodiment of a system for hot repair of the Java server. The system embodiment is based on the method embodiment, so that the description is relatively simple, and the relevant portions refer to the corresponding description of the method embodiment.
Fig. 2 illustrates an embodiment of a Java server hot repair system provided in the present application, including: a management module 201 and a repair module 202. When the Bug occurs to a certain section of running Java code or a certain service contained in the Java service system, for example, code Bug, logic error, algorithm error and the like are found, after operation and maintenance personnel find service failures through Java service monitoring alarm analysis, service routine troubleshooting, user complaint feedback service exception and the like, problems are located through a series of means and need to perform on-line emergency repair under the condition of not interrupting the service when the problems are found, and the Bug repair is completed under the condition of not restarting and not redeploying through the cooperative processing of the repair module and the management module.
The management module 201 is configured to issue an operation decision and an operation code to the repair module; the run code contains corresponding JavaScript fix code for replacing specific Java code; the operation decision comprises relevant information whether to replace the specific Java code with a JavaScript repair code generated for the specific Java code to operate in operation; the specific Java code is an abnormal Java code contained in the Java program or a Java code corresponding to a service segment to be replaced contained in the Java program.
And the repair module 202 is configured to, in the running process of the Java service system, replace the specific Java code with the JavaScript repair code generated for the specific Java code according to the running decision.
In this embodiment, the repairing module 202 determines whether to run the JavaScript repairing code according to the running decision in the running process of the Java service system; the operation decision comprises information for determining whether a JavaScript repair code is used for replacing a corresponding specific Java code to operate, and if so, the Java service system operates the JavaScript repair code; if not, the specific Java code originally deployed is kept running.
Optionally, the Java server hot repair system includes a code conversion module 203, configured to automatically convert Java repair codes into corresponding JavaScript repair codes and provide the corresponding JavaScript repair codes to the management module; the JavaScript repair code is provided for the repair module to use through the management module; the Java repair code is Java code generated for the specific Java code.
The specific method for implementing automatic code conversion has been described in detail in the Java server hot repair method provided in the present application, and is not described herein again.
It should be noted that, when an existing service function already deployed in the Java service running module needs to be replaced by a new service function, a Java service replacement code corresponding to the new service function may also be automatically converted into a JavaScript new service code by the code conversion module, and the JavaScript new service code is also collectively referred to as a JavaScript repair code, so that the method is applied to a scenario of performing hot replacement on a service.
Optionally, the Java server hot repair system includes a configuration module 204, configured to provide a configuration mechanism to a management module, where the management module triggers the code conversion module to convert the Java repair code into a corresponding JavaScript repair code through the configuration mechanism, and the management module synchronizes the operation decision and the JavaScript repair code to the repair module through the configuration mechanism.
Specifically, in the embodiment provided by the present application, the management module is a Java-based script management background, the code conversion module actually completes a code conversion function by a JavaScript factory, and the actual implementation further includes: a configuration module to provide a configuration channel; transmitting a conversion command to a JavaScript factory through the configuration channel, and converting the Java repair code to generate the JavaScript repair code after the JavaScript factory receives the conversion command; in addition, the operation decision is sent to the Java service system through the configuration channel.
Optionally, the Java server side hot repair system includes a code repository module 205, configured to store the Java repair code for the Java repair code to be provided to the code conversion module for use.
In practical application, the Java server further includes a code warehouse for storing codes of Java application products, after the problem of the Java service is found, the problem is located and modified by development or maintenance personnel of the Java application product, and the generated corresponding Java code for repairing the Java service having the abnormality is stored in the code warehouse. In addition, if the deployed Java service in operation needs to be replaced, the corresponding Java service code in the code repository is also updated to the Java code corresponding to the new service for replacing the service to be replaced. In general, the code repository is further configured to store Java code corresponding to the Java service system.
Optionally, the Java server thermal repair system includes a decision module 206, configured to generate the operation decision, including receiving an external manual decision made according to the operation or deployment condition of the Java program, where the operation decision is issued to the repair module through the management module for use.
The operation decision and the manual operation are described in detail in the embodiment of the Java server hot repair method provided by the present application, and are not described herein again.
Specifically, after service faults are found by Java service monitoring alarm analysis, service routine troubleshooting, user complaint feedback service abnormality and the like, problems are located through a series of means and when problems are found to require on-line emergency repair without interrupting the service, an emergency repair scheme is formulated, corresponding service Java codes are modified to obtain Java repair codes (patch codes), the Java repair codes are automatically converted by the management module in a configuration mode to generate corresponding JavaScript repair codes, and the service codes are designated by the decision module to start the JavaScript repair codes.
Optionally, the Java server side hot repair system includes an access module 207 configured to provide a communication service, and the management module synchronizes the operation decision and the JavaScript repair code to the repair module at regular time through the access module.
In the embodiment provided by the application, the management module outputs a near-end access Jar package for integrating the Java service system into the local, and the near-end access Jar package is used for providing communication services between the Java service system and the management module. The decision module receives an operation decision generated by an operation and maintenance or a developer according to an external decision of a problem repair scheme, and issues the operation decision to the repair module through the management module and the near-end access Jar packet; and the JavaScript repair codes generated by the conversion are also issued to the repair module through the near-end access Jar packet after the conversion is finished.
Optionally, the Java server hot repair system includes a caching module 208, configured to cache the operation decision and the JavaScript repair code in a local caching space of a Java service system.
Specifically, in the embodiment provided by the present application, the Java service system accesses a service by integrating a near-end access Jar packet provided by the access module, and obtains a Javascript repair code for service repair through a far-end service of the management module, and caches the Javascript repair code at the near end of the Java service system, and obtains the operation decision through the far-end service, and caches the operation decision at the near end of the Java service system. In the service operation process, after a service request reaches a Java service system and is subjected to a series of pre-processing, when the service processing is carried out, an operation decision is requested to determine whether a JavaScript repair code is currently operated, the cached operation decision is obtained from a local cache of the Java service system, if so, the JavaScript repair code corresponding to the service is obtained from a local cache space to operate, and the repair of the bug of the system is completed; if not, the originally deployed specific Java code is still operated, and finally, the service output is completed through post-processing.
In addition, the Java service system may further adopt the following operation mechanism: in the running process, requesting the JavaScript repair code to the management module when processing the service according to the service request; or, in the operation process, when the service is processed according to the service request, an operation decision is requested to the management module, and the mechanisms of real-time request and real-time issue are also within the protection scope of the present application.
Corresponding to the embodiment of the Java server side thermal repair method provided by the application, the application also provides a Java server side thermal repair device. Referring to fig. 3, a schematic diagram of an embodiment of a Java server thermal repair apparatus provided in the present application is shown. Since the device embodiment is basically similar to the method embodiment, the description is relatively simple, and the relevant portions only need to refer to the corresponding description of the method embodiment. The device embodiments described below are merely illustrative.
The application provides a Java server side thermal remediation device includes:
the management unit 301 is configured to determine whether to use a JavaScript repair code to replace a specific Java code to run according to a running decision in the running process of the Java program; if yes, the next step is carried out.
And a repairing unit 302, configured to replace the specific Java code with a JavaScript repairing code generated for the specific Java code during the running process of the Java program.
The embodiment of the electronic equipment provided by the application is as follows:
corresponding to the embodiment of the Java server side thermal restoration method provided by the application, the application also provides electronic equipment for realizing the Java server side thermal restoration method.
Referring to fig. 4, a schematic diagram of an electronic device for implementing a Java server hot repair method according to the present application is shown. Since the embodiment of the electronic device is basically similar to the embodiment of the method, the description is relatively simple, and the relevant portions only need to refer to the corresponding description of the embodiment of the method. The electronic device embodiments described below are merely illustrative.
The application provides an electronic device, including:
a memory 401, and a processor 402;
the memory 401 is configured to store computer-executable instructions, and the processor 402 is configured to execute the computer-executable instructions to:
in the running process of the Java program, determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to a running decision; if yes, entering the next step;
and in the running process of the Java program, replacing the specific Java code with the JavaScript repair code generated for the specific Java code to run.
In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.
1. Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include non-transitory computer readable media (transient media), such as modulated data signals and carrier waves.
2. As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application 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.
Although the present application has been described with reference to the preferred embodiments, it is not intended to limit the present application, and those skilled in the art can make variations and modifications without departing from the spirit and scope of the present application, therefore, the scope of the present application should be determined by the claims that follow.
Claims (10)
1. A Java server side hot repair method is characterized by comprising the following steps:
in the running process of the Java program, determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to a running decision; if yes, entering the next step;
and in the running process of the Java program, replacing the specific Java code with the JavaScript repair code generated for the specific Java code to run.
2. The Java server thermal repair method according to claim 1, wherein the specific Java code is an abnormal Java code included in a Java program or a Java code corresponding to a service segment to be replaced included in the Java program.
3. The Java server side hot repair method according to claim 1, wherein the JavaScript repair code is a Nashorn-based JavaScript code; the Nashorn is a lightweight JavaScript running environment based on Java native JVM.
4. The method for hot repair of a Java server according to claim 1, wherein the JavaScript repair code in this step is determined to be executed by replacing a specific Java code with a JavaScript repair code according to the execution decision, and is obtained by any one of the following methods:
writing JavaScript repair codes aiming at the specific Java codes by using a JavaScript language;
and generating Java repair codes aiming at the specific Java codes, and then automatically converting the Java repair codes into the JavaScript repair codes.
5. The Java server side hot repair method according to claim 4, wherein the automatically converting the Java repair code into the JavaScript repair code comprises: performing the following conversion by code analysis of the Java repair code:
automatically converting the Java type dependence into JavaScript type dependence;
automatically converting the Java strong type into a JavaScript weak type;
and automatically binding the Spring context to the context of the JavaScript runtime.
6. The Java server side hot repair method according to claim 4, wherein before the step of automatically converting the Java repair code into the JavaScript repair code, the method comprises:
generating Java repair codes for replacing specific Java codes needing to be replaced, wherein the specific Java codes are contained in a Java program;
and issuing a conversion command, and triggering the step of automatically converting the Java repair code into a JavaScript repair code.
7. The Java server side hot repair method according to claim 1, wherein the operation decision is obtained by any one of the following methods:
in the running process of the Java program, the running decision is obtained from the local cache space of the Java program when the business processing is carried out;
and in the running process of the Java program, requesting to issue the running decision when performing service processing.
8. A Java server side hot repair system is characterized by comprising: a management module and a repair module; wherein,
the management module is used for issuing an operation decision and an operation code to the repair module; the run code contains corresponding JavaScript fix code for replacing specific Java code; the operation decision comprises relevant information whether to replace the specific Java code with a JavaScript repair code generated for the specific Java code to operate in operation; the specific Java code is an abnormal Java code contained in the Java program or a Java code corresponding to a service segment to be replaced contained in the Java program;
and the repairing module is used for replacing the specific Java code with the JavaScript repairing code generated for the specific Java code to run according to the running decision in the running process of the Java service system.
9. A Java server side hot repair device is characterized by comprising:
the management unit is used for determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to the running decision in the running process of the Java program; if yes, entering the next step;
and the repairing unit is used for replacing the specific Java code with the JavaScript repairing code generated for the specific Java code to run in the running process of the Java program.
10. An electronic device, comprising:
a memory, and a processor;
the memory is to store computer-executable instructions, and the processor is to execute the computer-executable instructions to:
in the running process of the Java program, determining whether to use a JavaScript repair code to replace a specific Java code to run or not according to a running decision; if yes, entering the next step;
and in the running process of the Java program, replacing the specific Java code with the JavaScript repair code generated for the specific Java code to run.
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN2017106967337 | 2017-08-15 | ||
| CN201710696733 | 2017-08-15 |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN107908402A true CN107908402A (en) | 2018-04-13 |
Family
ID=61841744
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201711014055.8A Pending CN107908402A (en) | 2017-08-15 | 2017-10-26 | The hot restorative procedure of Java server-sides and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107908402A (en) |
Cited By (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108647028A (en) * | 2018-05-09 | 2018-10-12 | 广州腾讯科技有限公司 | Application information processing method and device |
| CN108762787A (en) * | 2018-05-31 | 2018-11-06 | 康键信息技术（深圳）有限公司 | Software repair, device, computer equipment and storage medium |
| CN109684847A (en) * | 2018-09-07 | 2019-04-26 | 平安科技（深圳）有限公司 | Self-repairing method, device, equipment and the storage medium of script loophole |
| CN109726052A (en) * | 2018-12-29 | 2019-05-07 | 北京金山安全软件有限公司 | Method and device for realizing server thermal repair and electronic equipment |
| CN110308922A (en) * | 2019-06-27 | 2019-10-08 | 百度在线网络技术（北京）有限公司 | Data transmission method, device, equipment and storage medium |
| CN111506904A (en) * | 2020-04-21 | 2020-08-07 | 北京同邦卓益科技有限公司 | Method and device for online vulnerability repair |
| CN111580813A (en) * | 2020-03-25 | 2020-08-25 | 博雅信安科技(北京)有限公司 | Automatic management method for Java class hot update |
| CN111708282A (en) * | 2020-04-30 | 2020-09-25 | 浙江口碑网络技术有限公司 | Simulation test scheduling method, simulation test system, simulation test device and electronic equipment |
| CN112579094A (en) * | 2020-12-15 | 2021-03-30 | 上海赛可出行科技服务有限公司 | Lightweight thermal restoration method based on template code matching |
| WO2021169127A1 (en) * | 2020-02-26 | 2021-09-02 | 平安科技（深圳）有限公司 | Virtual machine upgrade method, apparatus and device, and storage medium |
| CN113760339A (en) * | 2020-07-01 | 2021-12-07 | 北京沃东天骏信息技术有限公司 | Vulnerability repair method and device |
| CN115617379A (en) * | 2022-12-19 | 2023-01-17 | 成都数默科技有限公司 | Java application vulnerability repairing method based on Java agent hot update |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102945156A (en) * | 2012-10-23 | 2013-02-27 | 深圳市融创天下科技股份有限公司 | Data caching method and device based on Java object |
| CN105354045A (en) * | 2014-08-21 | 2016-02-24 | 中兴通讯股份有限公司 | Patch making method and apparatus and patch activation method and apparatus |
| US20160216962A1 (en) * | 2015-01-22 | 2016-07-28 | Futurewei Technologies, Inc. | Systems and methods to update source code files |
-
2017
- 2017-10-26 CN CN201711014055.8A patent/CN107908402A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102945156A (en) * | 2012-10-23 | 2013-02-27 | 深圳市融创天下科技股份有限公司 | Data caching method and device based on Java object |
| CN105354045A (en) * | 2014-08-21 | 2016-02-24 | 中兴通讯股份有限公司 | Patch making method and apparatus and patch activation method and apparatus |
| US20160216962A1 (en) * | 2015-01-22 | 2016-07-28 | Futurewei Technologies, Inc. | Systems and methods to update source code files |
Non-Patent Citations (2)
| Title |
|---|
| APACHECN_飞龙: "Java 8 Nashorn教程", 《HTTPS://WWW.JIANSHU.COM/P/467AAF5254F8》 * |
| FIRE_NIAO: "App的热更新JSPatch的使用", 《HTTPS://BLOG.CSDN.NET/FIRE_NIAO/ARTICLE/DETAILS/52354907》 * |
Cited By (18)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108647028A (en) * | 2018-05-09 | 2018-10-12 | 广州腾讯科技有限公司 | Application information processing method and device |
| CN108647028B (en) * | 2018-05-09 | 2024-02-09 | 广州腾讯科技有限公司 | Application information processing method and device |
| CN108762787A (en) * | 2018-05-31 | 2018-11-06 | 康键信息技术（深圳）有限公司 | Software repair, device, computer equipment and storage medium |
| CN108762787B (en) * | 2018-05-31 | 2024-04-05 | 康键信息技术（深圳）有限公司 | Software repairing method, device, computer equipment and storage medium |
| CN109684847A (en) * | 2018-09-07 | 2019-04-26 | 平安科技（深圳）有限公司 | Self-repairing method, device, equipment and the storage medium of script loophole |
| CN109726052A (en) * | 2018-12-29 | 2019-05-07 | 北京金山安全软件有限公司 | Method and device for realizing server thermal repair and electronic equipment |
| CN110308922A (en) * | 2019-06-27 | 2019-10-08 | 百度在线网络技术（北京）有限公司 | Data transmission method, device, equipment and storage medium |
| WO2021169127A1 (en) * | 2020-02-26 | 2021-09-02 | 平安科技（深圳）有限公司 | Virtual machine upgrade method, apparatus and device, and storage medium |
| CN111580813A (en) * | 2020-03-25 | 2020-08-25 | 博雅信安科技(北京)有限公司 | Automatic management method for Java class hot update |
| CN111580813B (en) * | 2020-03-25 | 2022-09-02 | 博雅信安科技(北京)有限公司 | Automatic management method for Java class hot update |
| CN111506904A (en) * | 2020-04-21 | 2020-08-07 | 北京同邦卓益科技有限公司 | Method and device for online vulnerability repair |
| CN111506904B (en) * | 2020-04-21 | 2024-01-12 | 北京同邦卓益科技有限公司 | Method and device for online bug repair |
| CN111708282A (en) * | 2020-04-30 | 2020-09-25 | 浙江口碑网络技术有限公司 | Simulation test scheduling method, simulation test system, simulation test device and electronic equipment |
| CN111708282B (en) * | 2020-04-30 | 2023-08-18 | 浙江口碑网络技术有限公司 | Simulation test scheduling method, simulation test system, simulation test device and electronic equipment |
| CN113760339A (en) * | 2020-07-01 | 2021-12-07 | 北京沃东天骏信息技术有限公司 | Vulnerability repair method and device |
| CN112579094A (en) * | 2020-12-15 | 2021-03-30 | 上海赛可出行科技服务有限公司 | Lightweight thermal restoration method based on template code matching |
| CN112579094B (en) * | 2020-12-15 | 2024-05-14 | 上海赛可出行科技服务有限公司 | Lightweight thermal restoration method based on template code matching |
| CN115617379A (en) * | 2022-12-19 | 2023-01-17 | 成都数默科技有限公司 | Java application vulnerability repairing method based on Java agent hot update |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107908402A (en) | The hot restorative procedure of Java server-sides and system | |
| US9703677B2 (en) | Code coverage plugin | |
| CN110321275B (en) | Program monitoring method, device, computing equipment and storage medium | |
| US7908590B1 (en) | System and method for automatically creating test cases through a remote client | |
| US20130167123A1 (en) | Application debugging | |
| US7900198B2 (en) | Method and system for parameter profile compiling | |
| Gupta | On-line software version change | |
| US20100011243A1 (en) | Methods, systems and media for software self-healing | |
| CN109491695A (en) | A kind of increment updating method of integrated Android application | |
| CN105183457B (en) | Method and device for monitoring interface life cycle callback | |
| CN112882925A (en) | Diagnostic workflow for production commissioning | |
| CN110941528A (en) | Log buried point setting method, device and system based on fault | |
| US20170249235A1 (en) | Systems and methods for automatically parallelizing sequential code | |
| US20040054991A1 (en) | Debugging tool and method for tracking code execution paths | |
| CN109032631A (en) | Application program service packs acquisition methods, device, computer equipment and storage medium | |
| US20190149571A1 (en) | Method and device for repairing page vulnerability | |
| JP2010134643A (en) | Test case selection method and selection system | |
| KR20150130298A (en) | Operating system support for contracts | |
| CN111880804A (en) | Application program code processing method and device | |
| US20180011778A1 (en) | Static code testing of active code | |
| US9841960B2 (en) | Dynamic provision of debuggable program code | |
| CN109947407B (en) | Data acquisition method and device | |
| Wood et al. | Triton: a domain specific language for cyber-physical systems | |
| US11429379B2 (en) | Software checkpoint-restoration between distinctly compiled executables | |
| EP2721494B1 (en) | System and method to in-line script dependencies |
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 | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20180413 |