CN114996107A - Log file updating method, device, equipment, medium and product - Google Patents
Log file updating method, device, equipment, medium and product Download PDFInfo
- Publication number
- CN114996107A CN114996107A CN202210601146.6A CN202210601146A CN114996107A CN 114996107 A CN114996107 A CN 114996107A CN 202210601146 A CN202210601146 A CN 202210601146A CN 114996107 A CN114996107 A CN 114996107A
- Authority
- CN
- China
- Prior art keywords
- target
- bytecode
- parameter
- return data
- determining
- 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 193
- 238000012545 processing Methods 0.000 claims abstract description 32
- 238000004590 computer program Methods 0.000 claims description 23
- 230000008569 process Effects 0.000 claims description 13
- 238000012216 screening Methods 0.000 claims description 11
- 238000004891 communication Methods 0.000 description 8
- 241000208340 Araliaceae Species 0.000 description 5
- 235000005035 Panax pseudoginseng ssp. pseudoginseng Nutrition 0.000 description 5
- 235000003140 Panax quinquefolius Nutrition 0.000 description 5
- 238000010586 diagram Methods 0.000 description 5
- 235000008434 ginseng Nutrition 0.000 description 5
- 230000003044 adaptive effect Effects 0.000 description 4
- 230000006870 function Effects 0.000 description 4
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 230000003993 interaction Effects 0.000 description 2
- 238000013024 troubleshooting Methods 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 238000013473 artificial intelligence Methods 0.000 description 1
- 230000006399 behavior Effects 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000001413 cellular effect Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000012217 deletion Methods 0.000 description 1
- 230000037430 deletion Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 239000011521 glass Substances 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 238000010801 machine learning Methods 0.000 description 1
- 238000007726 management method Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 230000001953 sensory effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
- G06F11/3466—Performance evaluation by tracing or monitoring
- G06F11/3476—Data logging
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/10—File systems; File servers
- G06F16/18—File system types
- G06F16/1805—Append-only file systems, e.g. using logs or journals to store data
- G06F16/1815—Journaling file systems
-
- 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
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Data Mining & Analysis (AREA)
- Databases & Information Systems (AREA)
- Computer Security & Cryptography (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The embodiment of the invention relates to the technical field of computers, in particular to a method, a device, equipment, a medium and a product for updating a log file. The method comprises the following steps: acquiring a target class path and a target method path, wherein the target method is a method of an application program included in a target class; loading a target class according to the target class path and the target method path to obtain a first byte code corresponding to a target method; determining target entry and target return data according to the first byte code; adding the target entry and target return data to the first byte code to obtain a target byte code; the application program is subjected to hot updating according to the target byte code to obtain a target log file, and the technical scheme of the invention solves the problem of increased error probability caused by overlong flow and manual addition of the content of the log file, can automatically adapt to processing and reduce the error probability.
Description
Technical Field
The embodiment of the invention relates to the technical field of computers, in particular to a method, a device, equipment, a medium and a product for updating a log file.
Background
When a project enters a testing stage, unexpected problems are found in a large number, the problem troubleshooting efficiency is low due to the fact that some logs are not comprehensive enough, even the project schedule is influenced, and sometimes unexpected problems occur in the production environment, and the problem troubleshooting difficulty is large due to the fact that the logs are not comprehensive enough.
In the prior art, adding content to a log file is to add content to a JAVA file after CFR decompilation, then compile the content by a JAVA compiler, and load classes by an Instrumentation mechanism.
For most common logs, log file updating is performed by a method for adding contents to a log file in the prior art, the flow is too long, and the contents of the log file need to be artificially increased, so that the error probability is increased.
Disclosure of Invention
Embodiments of the present invention provide a method, an apparatus, a device, a medium, and a product for updating a log file, so as to solve the problem of an increased error probability due to an excessively long flow and a manual addition of a content of the log file, and to enable automatic adaptive processing and a reduction in the error probability.
According to an aspect of the present invention, there is provided a log file updating method, including:
acquiring a target class path and a target method path, wherein the target method is a method of an application program included in a target class;
loading a target class according to the target class path and the target method path to obtain a first byte code corresponding to a target method;
determining target entry and target return data according to the first byte code; adding the target entry and target return data to the first byte code to obtain a target byte code;
and carrying out hot updating on the application program according to the target byte code to obtain a target log file.
Further, determining target entry and target return data according to the first bytecode includes:
inputting the first byte code into a first access method to obtain an entry parameter characteristic parameter;
analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method;
and determining target participation and target return data according to the participation type array.
Further, determining target participation and target return data according to the participation type number group comprises:
obtaining a local variable;
determining the parameter input quantity according to the parameter input type array;
and determining target input parameters and target return data according to the input parameters and the local variables.
Further, determining the parameter amount according to the parameter group comprises:
acquiring the number of parameter types in the parameter type array;
and determining the number of parameter types in the parameter input type array as parameter input number.
Further, determining target participation and target return data according to the participation quantity and the local variable, comprising:
acquiring subscripts of the local variables;
screening target input parameters from the local variables according to the subscripts of the local variables and the input parameter quantity;
and determining the last frame of data in the local variables as target return data.
Further, the step of screening out target entries from the local variables according to the subscripts of the local variables and the entry quantities comprises the following steps:
and if the input parameter quantity is N, determining N frame data with subscript 1 to subscript N in the local variables as target input parameters.
Further, adding the target entry and target return data to the first bytecode to obtain a target bytecode, including:
and adding the target entry participation and target return data to the first bytecode through a bytecode processing framework to obtain a target bytecode.
Further, adding the target entry and target return data to the first bytecode to obtain a target bytecode, including:
acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data;
and adding the second byte code and the third byte code into the first byte code to obtain a target byte code.
Further, adding the second bytecode and the third bytecode to the first bytecode to obtain a target bytecode, including:
adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode;
and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode.
Further, adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode, including:
acquiring a target operation type corresponding to the target return data;
and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
Further, the log file updating method is executed by a target JAVA virtual machine, and the target JAVA virtual machine is determined by a target process number.
According to another aspect of the present invention, there is provided a log file updating apparatus including:
the system comprises an acquisition module, a processing module and a processing module, wherein the acquisition module is used for acquiring a target class path and a target method path, and the target method is a method of an application program included in a target class;
the first determining module is used for loading the target class according to the target class path and the target method path to obtain a first bytecode corresponding to the target method;
the second determining module is used for determining target entry and target return data according to the first byte code;
the adding module is used for adding the target entry parameter and the target return data into the first byte code to obtain a target byte code;
and the updating module is used for carrying out hot updating on the application program according to the target byte codes to obtain a target log file.
Further, the second determining module is specifically configured to:
inputting the first byte code into a first access method to obtain an entry parameter characteristic parameter;
analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method;
and determining target participation and target return data according to the participation type array.
Further, the second determining module is specifically configured to:
obtaining a local variable;
determining an input parameter quantity according to the input parameter type array;
and determining target input parameters and target return data according to the input parameters and the local variables.
Further, the second determining module is specifically configured to:
acquiring the number of parameter types in the parameter type array;
and determining the number of parameter types in the parameter input type array as parameter input number.
Further, the second determining module is specifically configured to:
obtaining subscripts of the local variables;
screening target input parameters from the local variables according to the subscripts of the local variables and the input parameter quantity;
and determining the last frame of data in the local variables as target return data.
Further, the second determining module is specifically configured to:
and if the input parameter quantity is N, determining N frame data with subscript 1 to subscript N in the local variables as target input parameters.
Further, the adding module is specifically configured to:
and adding the target entry participation and target return data to the first bytecode through a bytecode processing framework to obtain a target bytecode.
Further, the adding module is specifically configured to:
acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data;
and adding the second bytecode and the third bytecode to the first bytecode to obtain a target bytecode.
Further, the adding module is specifically configured to:
adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode;
and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode.
Further, the adding module is specifically configured to:
acquiring a target operation type corresponding to the target return data;
and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
Further, the log file updating method is executed by a target JAVA virtual machine, and the target JAVA virtual machine is determined by a target process number.
According to another aspect of the present invention, there is provided an electronic apparatus including:
at least one processor; and
a memory communicatively coupled to the at least one processor; wherein,
the memory stores a computer program executable by the at least one processor, the computer program being executable by the at least one processor to enable the at least one processor to perform the log file updating method according to any of the embodiments of the present invention.
According to another aspect of the present invention, there is provided a computer-readable storage medium storing computer instructions for causing a processor to implement the log file updating method according to any one of the embodiments of the present invention when the computer instructions are executed.
According to another aspect of the present invention, there is provided a computer program product, which when executed by a processor implements a log file updating method as in any one of the embodiments of the present invention.
The method comprises the steps of obtaining a target class path and a target method path through a JAVA virtual machine, wherein the target method is a method of an application program included in a target class; loading a target class according to the target class path and the target method path to obtain a first byte code corresponding to a target method; determining target entry and target return data according to the first byte code; adding the target entry and target return data to the first byte code to obtain a target byte code; and carrying out hot updating on the application program according to the target byte code to obtain a target log file, so as to solve the problem of error probability increase caused by overlong flow and manual addition of the content of the log file, and realize automatic adaptive processing and reduce the error probability.
It should be understood that the statements in this section do not necessarily identify key or critical features of the embodiments of the present invention, nor do they necessarily limit the scope of the invention. Other features of the present invention will become apparent from the following description.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings needed to be used in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present invention and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained according to the drawings without inventive efforts.
FIG. 1 is a flow chart of a log file updating method in an embodiment of the present invention;
FIG. 2 is a schematic structural diagram of a log file updating apparatus according to an embodiment of the present invention;
fig. 3 is a schematic structural diagram of an electronic device in an embodiment of the present invention.
Detailed Description
In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in other sequences than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
The technical scheme related to the application acquires, stores and/or processes the data, and the data accord with relevant regulations of national laws and regulations.
Example one
Fig. 1 is a flowchart of a log file updating method according to an embodiment of the present invention, where the present embodiment is applicable to a situation of updating a log file, and the method may be executed by a log file updating apparatus according to an embodiment of the present invention, where the log file updating apparatus may be implemented in a software and/or hardware manner, as shown in fig. 1, the method specifically includes the following steps:
s110, obtaining a target type path and a target method path.
Wherein the target class is a JAVA class, the target method is a method of an application (such as a JAVA application) included in the target class, and the target class includes a plurality of target methods.
The target class path is a path corresponding to a target class, that is, a path address of a storage target class, and the target method path is a path corresponding to a target method, that is, a path address of a storage target method.
Specifically, the manner of obtaining the target class path and the target method path may be: and receiving a target class path and a target method path through a target JAVA interface. The method for obtaining the target class path and the target method path may further include: connecting the running JAVA virtual machine by using a Java Attach API and a target process code, and receiving a target class path and a target method path through the Java Attach API. For example, the JAVA virtual machine may be connected by calling a virtualmachine.
And S120, loading the target class according to the target class path and the target method path to obtain a first bytecode corresponding to the target method.
The bytecode is a binary file containing an execution program and composed of a sequence of code/data pairs, and is an intermediate code. Specifically, the manner of obtaining the first bytecode corresponding to the target method by loading the target class according to the target class path and the target method path may be: after the connection with the JAVA virtual machine is established, the target class is loaded according to the target class path and the target method path to obtain the first bytecode corresponding to the target method, for example, after the JAVA virtual machine is connected, the target class is loaded by calling a virtualmachine-ne.
S130, determining target participation and target return data according to the first byte code.
The target input parameter is an input parameter to be added, and the target return data is return data to be added. Each target method corresponds to a pair of incoming references and return data. For example, the target entry may include: at least one piece of text, or, alternatively, at least one JAVA object. The return data is a text or may be a JAVA object.
Specifically, the method for determining the target entry and the target return data according to the first bytecode may be: inputting the first bytecode into a first access method (the first access method is used for traversing the first bytecode and further obtaining an entry parameter feature parameter), and obtaining an entry parameter feature parameter (wherein the entry parameter feature parameter is a section of bytecode for representing an entry feature); analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method (the parameter-entering type array comprises a plurality of parameter-entering types, for example, group A comprises parameter-entering type 1, parameter-entering type 2 and parameter-entering type 3, and group B comprises parameter-entering type 1, parameter-entering type 3 and parameter-entering type 4); and determining target participation and target return data according to the participation type array. The method for determining the target entry and the target return data according to the first bytecode may further include: inputting the first byte code into a first access method to obtain an entry parameter characteristic parameter; analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method; acquiring local variables (the local variables are local variables stored in a JAVA virtual machine); determining an input parameter quantity according to the input parameter type array; and determining target input parameters and target return data according to the input parameter quantity and the local variables. The method for determining the target entry and the target return data according to the first bytecode may further include: inputting the first byte code into a first access method to obtain an entry parameter characteristic parameter; analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method; obtaining a local variable; acquiring the number of parameter types in the parameter type array; and determining the number of parameter types in the parameter input type array as parameter input number, and determining target parameter input and target return data according to the parameter input number and the local variables. The method for determining the target entry and the target return data according to the first bytecode may further include: inputting the first byte code into a first access method to obtain an entry parameter characteristic parameter; analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method; obtaining a local variable; acquiring the number of parameter types in the parameter type array; determining the number of parameter types in the parameter input type array as parameter input number, and acquiring subscripts of the local variables; screening target input parameters from the local variables according to the subscripts of the local variables and the input parameter quantity; and determining the last frame of data in the local variables as target return data.
And S140, adding the target entry and target return data into the first byte code to obtain a target byte code.
Specifically, the manner of adding the target entry and target return data to the first bytecode to obtain the target bytecode may be: and adding the target entry participation and target return data to the first bytecode through a bytecode processing framework to obtain a target bytecode. Adding the target entry and target return data to the first bytecode, and obtaining the target bytecode may further be: acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data; and adding the second byte code and the third byte code into the first byte code to obtain a target byte code. Adding the target entry and target return data to the first bytecode, and obtaining the target bytecode may further be: acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data; adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode; and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode. Adding the target entry and target return data to the first bytecode, and obtaining the target bytecode may further be: acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data; adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode; acquiring a target operation type (for example, an operation type such as adding, returning, acquiring, and judging) corresponding to the target return data; and adding the third bytecode to the end position of the fourth bytecode according to the target operation type (the manner of adding the third bytecode to the end position of the fourth bytecode according to the target operation type can be that a corresponding relation table of operation types and end positions is established in advance, the corresponding relation table is inquired to obtain the end position of the fourth bytecode corresponding to the target operation type, and the third bytecode is added to the end position of the fourth bytecode), so as to obtain the target bytecode.
S150, carrying out hot updating on the application program according to the target byte codes to obtain a target log file.
Wherein the hot update is capable of not affecting other operations of the JAVA virtual machine during the update. Specifically, the application program is subjected to hot update according to the target bytecode to obtain a target log file, for example, the target log file may be obtained by calling a translation class interface to perform hot update on running JAVA application through Instrumentation.
Optionally, determining target entry and target return data according to the first bytecode includes:
inputting the first byte code into a first access method to obtain an access parameter;
analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method;
and determining target participation and target return data according to the participation type array.
The first access method may be a rewritten visitMethod method, the visitMethod method is a program code executed when accessing the target method, a third parameter of the rewritten visitMethod method is desc, the desc is an entry type of the target method when accessing the target class through a JAVA virtual machine, and an entry type array corresponding to the target method may be resolved by calling a type.
The parameter of the parameter-entering feature is a parameter of the rewritten visitMethod, and may be, for example, a third parameter desc of the rewritten visitMethod.
Specifically, the manner of analyzing the parameter-entering characteristic parameters to obtain the parameter-entering type array corresponding to the target method may be: and analyzing the parameter-entering characteristic parameters through a byte code operation frame to obtain a parameter-entering type array corresponding to the target method. For example, the third parameter desc of the rewritten visitMethod method may be analyzed by the ASM framework to obtain the parameter input type array corresponding to the target method.
Wherein, the parameter type array may contain the same parameter types: for example, the first group of entries may include: the parameter input type array comprises a parameter input type A, a parameter input type B and a parameter input type A, wherein the number of the parameter input types in the parameter input type array is the same as the parameter input quantity.
The ASM framework is a general JAVA bytecode operation and analysis framework. It can be used to modify an existing class file or to dynamically generate a class file.
Specifically, the method for determining the target participation and the target return data according to the participation type array may be: obtaining a local variable; determining the parameter input quantity according to the parameter input type array; and determining target input parameters and target return data according to the input parameters and the local variables. The method for determining the target participation and the target return data according to the participation type array can also comprise the following steps: and acquiring an operand stack in the local variable, and determining target entry parameters and target return data according to the entry parameter number and the operand stack. The method for determining the target participation and the target return data according to the participation type array can also be as follows: acquiring local variables, and acquiring the number of parameter types in the parameter type array; determining the number of parameter types in the parameter input type array as parameter input number; and determining target input parameters and target return data according to the input parameters and the local variables. The method for determining the target participation and the target return data according to the participation type array can also comprise the following steps: obtaining a local variable, and obtaining the number of parameter types in the parameter type array; determining the number of parameter types in the parameter input type array as parameter input number; obtaining subscripts of the local variables; screening target input parameters from the local variables according to the subscripts of the local variables and the input parameter quantity; and determining the last frame of data in the local variables as target return data.
Optionally, determining target participation and target return data according to the participation type number group includes:
obtaining a local variable;
determining an input parameter quantity according to the input parameter type array;
and determining target input parameters and target return data according to the input parameter quantity and the local variables.
The local variables are local variables corresponding to the target JAVA virtual machine, and it should be noted that the principle of an operand stack of the JAVA virtual machine is as follows: when each method in JAVA code is called, a frame is pressed into an execution stack of a thread, the frame comprises a local variable and an operand stack, the operand stack is a stack and comprises a numerical value for operating a byte code instruction, when the method is called, the local variable is pressed into the operand stack, then the operand stack is popped, the numerical value is stored into the local variable, and the operand stack is empty.
Specifically, the method for determining the number of entries according to the number group of the entry types may be: determining the number of the parameter types in the parameter type array as the parameter quantity, for example, if the parameter type array includes: determining the number of the input parameters to be 5 if the number of the input parameters is 5, wherein the input parameters comprise an input parameter type A, an input parameter type B, an input parameter type A and an input parameter type B, and the input parameter type A is 5.
Optionally, determining an input parameter quantity according to the input parameter type array includes:
acquiring the number of parameter types in the parameter type array;
and determining the number of the parameter types in the parameter input type array as the parameter input number.
The parameter entry type array may include the same parameter entry type and different parameter entry types, for example, the parameter entry type array may include: ginseng type A, ginseng type B, ginseng type A, ginseng type B and ginseng type A.
Specifically, the number of parameter entries in the parameter entry array is determined as a parameter entry amount, for example, if the parameter entry array includes: determining the number of the input parameters to be 5 if the number of the input parameters is 5, wherein the input parameters comprise an input parameter type A, an input parameter type B, an input parameter type A and an input parameter type B, and the input parameter type A is 5.
Optionally, determining target entry and target return data according to the entry quantity and the local variable includes:
obtaining subscripts of the local variables;
screening target input parameters from the local variables according to the subscripts of the local variables and the input parameter quantity;
and determining the last frame of data in the local variables as target return data.
The local variable includes multiple frames of data, and for example, if the local variable is: [ this, x, y, x + y ], then this is one frame, x is one frame, y is one frame, and x + y is one frame.
The last frame of data in the local variables is a frame of data with the maximum subscript in the local variables, and for example, if the local variables are: [ this, x, y, x + y ], then x + y is the last frame data.
Specifically, the subscript of the local variable is data that starts from 0, the local variable with the subscript of 0 is an initial character, and the local variable with the subscript of 1 is data that is stored in the local variable after being popped from the operand stack. For example, the local variable may be: [ this, x, y, x + y ], where this is subscript 0, this is the local variable is the initial character, x is subscript 1, y is subscript 2, and x + y is subscript 3.
Specifically, the way of obtaining the subscripts of the local variables is as follows: the subscript of each data in the local variable is obtained, for example, if the local variable is: [ this, x, y, x + y ], then the subscript of this, the subscript of x, the subscript of y, and the subscript of x + y are obtained.
Specifically, the method for screening target entries from the local variables according to the subscripts of the local variables and the entry numbers may be: if the input parameter amount is N, determining N frame data with subscript 1 to subscript N in the local variables as the target input parameter, for example, if the local variables are: [ this, x, y, x + y ], wherein the subscript of this is 0, this is the initial character of the local variable, the subscript of x is 1, the subscript of y is 2, the subscript of x + y is 3, and if the number of entries is 2, x and y are determined as the target entries.
Optionally, the step of screening target entries from the local variables according to the subscripts of the local variables and the entry numbers comprises:
and if the input parameter quantity is N, determining N frame data with subscript 1 to subscript N in the local variables as target input parameters.
Specifically, if the number of entries is N, N frame data from subscript 1 to subscript N in the local variables are determined as target entries, and for example, if the local variables are: [ this, x, y, x + y ], wherein the subscript of this is 0, this is the initial character of the local variable, the subscript of x is 1, the subscript of y is 2, the subscript of x + y is 3, and if the number of entries is 2, x and y are determined as the target entries.
Optionally, adding the target entry and target return data to the first bytecode to obtain a target bytecode, including:
and adding the target entry participation and target return data to the first bytecode through a bytecode processing framework to obtain a target bytecode.
Wherein, the bytecode processing framework can be: an ASM framework. The ASM framework is a JAVA bytecode generation framework and can directly perform addition and deletion operations on the class file.
Specifically, the manner of obtaining the target bytecode by adding the target entry and target return data to the first bytecode through a bytecode processing framework may be: acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data through a bytecode processing framework; and adding the second bytecode and the third bytecode to the first bytecode through a bytecode processing framework to obtain a target bytecode. Adding the target entry and target return data to the first bytecode through a bytecode processing framework, wherein a manner of obtaining a target bytecode may further be: acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data through a bytecode processing framework; adding the second bytecode to the initial position of the first bytecode through a bytecode processing framework to obtain a fourth bytecode; and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode. Adding the target entry and target return data to the first bytecode through a bytecode processing framework, wherein a manner of obtaining a target bytecode may further be: acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data through a bytecode processing framework; adding the second bytecode to the initial position of the first bytecode through a bytecode processing framework to obtain a fourth bytecode; acquiring a target operation type corresponding to the target return data; and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
In a specific example, the method in the ASM framework rewrites the visitcode method to specify the operation type by the visitfieeldinsn method of the methodrevisor, the visivarlnsn method to specify the operation data, the content is added at the beginning according to the bytecode standard, and the visitnsn method is rewritten in the same manner to add the return data. The method is used for creating a method or modifying method bytecode information in the process of accessing a method bytecode of a class so as to change method behaviors, the visitcode method can be used for detecting the beginning and the end of the bytecode of a target method in an event sequence, the visitfieeldinsn method is used for accessing fields of the class, such as assigning and acquiring the fields, and the visitvarlnsn method is used for writing a bytecode instruction and is used for some bytecode instructions needing to specify a parameter; the visitInsn method is used to write a simple bytecode instruction.
It should be noted that the manner of rewriting the visitMethod method, rewriting the visitcode method, and rewriting the visitInsn method in the embodiments of the present invention is not limited.
Optionally, adding the target entry and target return data to the first bytecode to obtain a target bytecode, including:
acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data;
and adding the second byte code and the third byte code into the first byte code to obtain a target byte code.
Specifically, the manner of obtaining the second bytecode corresponding to the target entry parameter may be: and acquiring a bytecode compiling specification (the bytecode compiling specification can be data pre-stored to the local), and compiling the target access parameter according to the bytecode compiling specification to obtain a second bytecode corresponding to the target access parameter.
Specifically, the manner of obtaining the third bytecode corresponding to the target return data may be: and acquiring a byte code writing specification (the byte code writing specification can be data pre-stored to the local), and writing the target return data according to the byte code writing specification to obtain a third byte code.
Specifically, the manner of adding the second bytecode and the third bytecode to the first bytecode to obtain the target bytecode may be: adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode; and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode. Adding the second bytecode and the third bytecode to the first bytecode, and obtaining a target bytecode may further be: adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode, and acquiring a target operation type corresponding to the target return data; and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
Optionally, adding the second bytecode and the third bytecode to the first bytecode to obtain a target bytecode, including:
adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode;
and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode.
Specifically, the manner of adding the third bytecode to the end position of the fourth bytecode to obtain the target bytecode may be: acquiring a target operation type corresponding to the target return data; and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
Optionally, adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode, including:
acquiring a target operation type corresponding to the target return data;
and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
Wherein, the target operation type can be a visitfieeldinsn method using a methodreviser.
Optionally, the log file updating method is executed by a target JAVA virtual machine, and the target JAVA virtual machine is determined by a target process number.
Among them, a JAVA Virtual Machine (JVM) is a specification for a computing device, which is an imaginary computer implemented by simulating various computer functions on an actual computer. The Java language uses a Java virtual machine to shield information related to a specific platform, so that a Java language compiler can operate on various platforms without modification only by generating bytecode which operates on the Java virtual machine.
Specifically, a target process number is received through a JAVA interface, and a target JAVA virtual machine is determined according to the target process number.
According to the technical scheme of the embodiment, a target class path and a target method path are obtained through a JAVA virtual machine, wherein the target method is a method of an application program included in a target class; loading a target class according to the target class path and the target method path to obtain a first byte code corresponding to a target method; determining target entry and target return data according to the first byte code; adding the target entry and target return data to the first byte code to obtain a target byte code; and carrying out hot updating on the application program according to the target byte code to obtain a target log file, so as to solve the problem of error probability increase caused by overlong flow and manual addition of the content of the log file, and realize automatic adaptive processing and reduce the error probability.
Example two
Fig. 2 is a schematic structural diagram of a log file updating apparatus according to an embodiment of the present invention. The present embodiment may be applicable to a case of updating a log file, where the apparatus may be implemented in a software and/or hardware manner, and the apparatus may be integrated in any device that provides a log file updating function, as shown in fig. 2, where the log file updating apparatus specifically includes: an acquisition module 210, a first determination module 220, a second determination module 230, an addition module 240, and an update module 250.
The system comprises an acquisition module, a processing module and a processing module, wherein the acquisition module is used for acquiring a target class path and a target method path, and the target method is a method of an application program included in a target class;
the first determining module is used for loading the target class according to the target class path and the target method path to obtain a first bytecode corresponding to the target method;
the second determining module is used for determining target entry and target return data according to the first byte code;
the adding module is used for adding the target entry participation and target return data into the first byte code to obtain a target byte code;
and the updating module is used for carrying out hot updating on the application program according to the target byte codes to obtain a target log file.
Optionally, the second determining module is specifically configured to:
inputting the first byte code into a first access method to obtain an entry parameter characteristic parameter;
analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method;
and determining target participation and target return data according to the participation type array.
Optionally, the second determining module is specifically configured to:
obtaining a local variable;
determining an input parameter quantity according to the input parameter type array;
and determining target input parameters and target return data according to the input parameters and the local variables.
Optionally, the second determining module is specifically configured to:
acquiring the number of parameter types in the parameter type array;
and determining the number of parameter types in the parameter input type array as parameter input number.
Optionally, the second determining module is specifically configured to:
acquiring subscripts of the local variables;
screening target input parameters from the local variables according to the subscripts of the local variables and the input parameter quantity;
and determining the last frame of data in the local variables as target return data.
Optionally, the second determining module is specifically configured to:
and if the input parameter quantity is N, determining N frame data with subscript 1 to subscript N in the local variables as target input parameters.
Optionally, the adding module is specifically configured to:
and adding the target entry participation and target return data to the first bytecode through a bytecode processing framework to obtain a target bytecode.
Optionally, the adding module is specifically configured to:
acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data;
and adding the second byte code and the third byte code into the first byte code to obtain a target byte code.
Optionally, the adding module is specifically configured to:
adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode;
and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode.
Optionally, the adding module is specifically configured to:
acquiring a target operation type corresponding to the target return data;
and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
Optionally, the log file updating method is executed by a target JAVA virtual machine, and the target JAVA virtual machine is determined by a target process number.
The product can execute the log file updating method provided by any embodiment of the invention, and has corresponding functional modules and beneficial effects of the executing method.
According to the technical scheme of the embodiment, a target class path and a target method path are obtained through a JAVA virtual machine, wherein the target method is a method of an application program included in a target class; loading a target class according to the target class path and the target method path to obtain a first byte code corresponding to a target method; determining target entry and target return data according to the first byte code; adding the target entry and target return data to the first byte code to obtain a target byte code; and carrying out hot updating on the application program according to the target byte code to obtain a target log file, so as to solve the problem of error probability increase caused by overlong flow and manual addition of the content of the log file, and realize automatic adaptive processing and reduce the error probability.
EXAMPLE III
FIG. 3 illustrates a schematic diagram of an electronic device 10 that may be used to implement an embodiment of the present invention. Electronic devices are intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. The electronic device may also represent various forms of mobile devices, such as personal digital assistants, cellular phones, smart phones, wearable devices (e.g., helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions, are meant to be exemplary only, and are not meant to limit implementations of the inventions described and/or claimed herein.
As shown in fig. 3, the electronic device 10 includes at least one processor 11, and a memory communicatively connected to the at least one processor 11, such as a Read Only Memory (ROM)12, a Random Access Memory (RAM)13, and the like, wherein the memory stores a computer program executable by the at least one processor, and the processor 11 can perform various suitable actions and processes according to the computer program stored in the Read Only Memory (ROM)12 or the computer program loaded from a storage unit 18 into the Random Access Memory (RAM) 13. In the RAM 13, various programs and data necessary for the operation of the electronic apparatus 10 can also be stored. The processor 11, the ROM 12, and the RAM 13 are connected to each other via a bus 14. An input/output (I/O) interface 15 is also connected to bus 14.
A number of components in the electronic device 10 are connected to the I/O interface 15, including: an input unit 16 such as a keyboard, a mouse, or the like; an output unit 17 such as various types of displays, speakers, and the like; a storage unit 18 such as a magnetic disk, an optical disk, or the like; and a communication unit 19 such as a network card, modem, wireless communication transceiver, etc. The communication unit 19 allows the electronic device 10 to exchange information/data with other devices via a computer network such as the internet and/or various telecommunication networks.
In some embodiments, the log file update method may be implemented as a computer program tangibly embodied in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program may be loaded and/or installed onto the electronic device 10 via the ROM 12 and/or the communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the log file update method described above may be performed. Alternatively, in other embodiments, the processor 11 may be configured to perform the log file update method by any other suitable means (e.g. by means of firmware):
acquiring a target class path and a target method path, wherein the target method is a method of an application program included in a target class;
loading a target class according to the target class path and the target method path to obtain a first byte code corresponding to a target method;
determining target entry and target return data according to the first byte code;
adding the target entry and target return data to the first byte code to obtain a target byte code;
and carrying out hot updating on the application program according to the target byte code to obtain a target log file.
Various implementations of the systems and techniques described here above may be implemented in digital electronic circuitry, integrated circuitry, Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), system on a chip (SOCs), load programmable logic devices (CPLDs), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include: implemented in one or more computer programs that are executable and/or interpretable on a programmable system including at least one programmable processor, which may be special or general purpose, receiving data and instructions from, and transmitting data and instructions to, a storage system, at least one input device, and at least one output device.
A computer program for implementing the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus, such that the computer programs, when executed by the processor, cause the functions/acts specified in the flowchart and/or block diagram block or blocks to be performed. A computer program can execute entirely on a machine, partly on a machine, as a stand-alone software package partly on a machine and partly on a remote machine or entirely on a remote machine or server.
In the context of the present invention, a computer-readable storage medium may be a tangible medium that can contain, or store a computer program for use by or in connection with an instruction execution system, apparatus, or device. A computer readable storage medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. Alternatively, the computer readable storage medium may be a machine readable signal medium. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
To provide for interaction with a user, the systems and techniques described here can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to a user; and a keyboard and a pointing device (e.g., a mouse or a trackball) by which a user can provide input to the electronic device. Other kinds of devices may also be used to provide for interaction with a user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including acoustic, speech, or tactile input.
The systems and techniques described here can be implemented in a computing system that includes a back-end component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with an implementation of the systems and techniques described here), or any combination of such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: local Area Networks (LANs), Wide Area Networks (WANs), blockchain networks, and the internet.
The computing system may include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. The server can be a cloud server, also called a cloud computing server or a cloud host, and is a host product in a cloud computing service system, so that the defects of high management difficulty and weak service expansibility in the traditional physical host and VPS service are overcome.
It should be understood that various forms of the flows shown above may be used, with steps reordered, added, or deleted. For example, the steps described in the present invention may be executed in parallel, sequentially, or in different orders, and are not limited herein as long as the desired result of the technical solution of the present invention can be achieved.
An embodiment of the present invention further provides a computer program product, which includes a computer program, and when the computer program is executed by a processor, the method for updating a log file according to any embodiment of the present invention is implemented.
The above-described embodiments should not be construed as limiting the scope of the invention. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may be made in accordance with design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (15)
1. A log file updating method is characterized by comprising the following steps:
acquiring a target class path and a target method path, wherein the target method is a method of an application program included in a target class;
loading a target class according to the target class path and the target method path to obtain a first byte code corresponding to a target method;
determining target entry and target return data according to the first byte code; adding the target entry and target return data to the first byte code to obtain a target byte code;
and carrying out hot updating on the application program according to the target byte code to obtain a target log file.
2. The method of claim 1, wherein determining target entry and target return data based on the first bytecode comprises:
inputting the first byte code into a first access method to obtain an access parameter;
analyzing the parameter of the parameter-entering characteristic to obtain a parameter-entering type array corresponding to the target method;
and determining target participation and target return data according to the participation type array.
3. The method of claim 2, wherein determining target participation and target return data based on the set of participation types comprises:
obtaining a local variable;
determining the parameter input quantity according to the parameter input type array;
and determining target input parameters and target return data according to the input parameter quantity and the local variables.
4. The method of claim 3, wherein determining an entry parameter quantity from the set of entry type numbers comprises:
acquiring the number of parameter types in the parameter type array;
and determining the number of parameter types in the parameter input type array as parameter input number.
5. The method of claim 3, wherein determining target engagement and target return data based on the engagement quantities and the local variables comprises:
obtaining subscripts of the local variables;
screening target input parameters from the local variables according to the subscripts of the local variables and the input parameter quantity;
and determining the last frame of data in the local variables as target return data.
6. The method of claim 5, wherein screening the local variables for target entries based on their subscripts and the entry numbers comprises:
and if the input parameter quantity is N, determining N frame data from subscript 1 to subscript N in the local variables as target input parameters.
7. The method of claim 1, wherein adding the target entry and target return data to the first bytecode, resulting in a target bytecode, comprises:
and adding the target entry participation and target return data to the first bytecode through a bytecode processing framework to obtain a target bytecode.
8. The method of claim 1, wherein adding the target entry and target return data to the first bytecode, resulting in a target bytecode, comprises:
acquiring a second bytecode corresponding to the target entry parameter and a third bytecode corresponding to the target return data;
and adding the second byte code and the third byte code into the first byte code to obtain a target byte code.
9. The method of claim 8, wherein adding the second bytecode and the third bytecode to the first bytecode to obtain a target bytecode, comprising:
adding the second bytecode to the initial position of the first bytecode to obtain a fourth bytecode;
and adding the third bytecode to the end position of the fourth bytecode to obtain a target bytecode.
10. The method of claim 9, wherein adding the third bytecode to an end position of the fourth bytecode to obtain a target bytecode, comprising:
acquiring a target operation type corresponding to the target return data;
and adding the third bytecode to the end position of the fourth bytecode according to the target operation type to obtain a target bytecode.
11. The method according to claim 1, wherein the log file updating method is performed by a target JAVA virtual machine, the target JAVA virtual machine being determined by a target process number.
12. An apparatus for updating a log file, comprising:
the system comprises an acquisition module, a processing module and a processing module, wherein the acquisition module is used for acquiring a target class path and a target method path, and the target method is a method of an application program included in a target class;
the first determining module is used for loading the target class according to the target class path and the target method path to obtain a first bytecode corresponding to the target method;
the second determining module is used for determining target entry and target return data according to the first byte code;
the adding module is used for adding the target entry participation and target return data into the first byte code to obtain a target byte code;
and the updating module is used for carrying out hot updating on the application program according to the target byte codes to obtain a target log file.
13. An electronic device, characterized in that the electronic device comprises:
at least one processor; and
a memory communicatively coupled to the at least one processor; wherein,
the memory stores a computer program executable by the at least one processor to enable the at least one processor to perform the log file update method of any one of claims 1-11.
14. A computer-readable storage medium storing computer instructions for causing a processor to implement the log file updating method of any one of claims 1 to 11 when executed.
15. A computer program product, characterized in that the computer program product comprises a computer program which, when being executed by a processor, realizes the log file updating method according to any one of claims 1-11.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210601146.6A CN114996107A (en) | 2022-05-30 | 2022-05-30 | Log file updating method, device, equipment, medium and product |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210601146.6A CN114996107A (en) | 2022-05-30 | 2022-05-30 | Log file updating method, device, equipment, medium and product |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114996107A true CN114996107A (en) | 2022-09-02 |
Family
ID=83031652
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210601146.6A Pending CN114996107A (en) | 2022-05-30 | 2022-05-30 | Log file updating method, device, equipment, medium and product |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114996107A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115576589A (en) * | 2022-12-08 | 2023-01-06 | 平安银行股份有限公司 | Program hot updating method, electronic equipment and storage medium |
| WO2024198779A1 (en) * | 2023-03-30 | 2024-10-03 | 华为技术有限公司 | Method and apparatus for marking operation type of bytecode, and electronic device |
-
2022
- 2022-05-30 CN CN202210601146.6A patent/CN114996107A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115576589A (en) * | 2022-12-08 | 2023-01-06 | 平安银行股份有限公司 | Program hot updating method, electronic equipment and storage medium |
| WO2024198779A1 (en) * | 2023-03-30 | 2024-10-03 | 华为技术有限公司 | Method and apparatus for marking operation type of bytecode, and electronic device |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN114996107A (en) | Log file updating method, device, equipment, medium and product | |
| CN112506602B (en) | Page generation method and device, electronic equipment and computer readable medium | |
| CN113760769B (en) | Test case processing method and device, electronic equipment and storage medium | |
| CN113642295B (en) | Page typesetting method, device and computer program product | |
| CN113392346A (en) | Path processing method and device for resource file, electronic equipment and storage medium | |
| CN117032712A (en) | Pipeline compiling and constructing method and device, electronic equipment and storage medium | |
| CN116009847A (en) | Code generation method, device, electronic equipment and storage medium | |
| CN115309730A (en) | Data auditing method and device, electronic equipment and storage medium | |
| CN117609064A (en) | Unit test method and device, electronic equipment and storage medium | |
| CN115328614A (en) | Process simulation method, device, equipment and storage medium | |
| CN112783574B (en) | Application development method, device, equipment and storage medium | |
| CN115269431A (en) | Interface testing method and device, electronic equipment and storage medium | |
| CN115543748A (en) | Signal testing method, device, equipment and storage medium | |
| CN115659347A (en) | Safety testing method and device, electronic equipment and storage medium | |
| CN115934550A (en) | Test method, test device, electronic equipment and storage medium | |
| CN115757097A (en) | Test case generation method and device, electronic equipment and storage medium | |
| CN114579095A (en) | AspectJ-based AOP development method, device, equipment and medium | |
| CN115495362A (en) | Method, device, storage medium and computer equipment for generating test code | |
| CN115309658A (en) | Test data derivation method, device, equipment and storage medium | |
| CN114549122A (en) | Model training method, commodity recommendation device, equipment and storage medium | |
| CN113138760A (en) | Page generation method and device, electronic equipment and medium | |
| CN113835893B (en) | Data processing method, device, equipment, storage medium and program product | |
| CN115098405B (en) | Software product evaluation method and device, electronic equipment and storage medium | |
| CN117270838B (en) | Method, device, equipment and medium for generating universal formula script | |
| CN118502814B (en) | Software modification evaluation method, device, equipment and medium based on byte codes |
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 |