CN114816437A - Method, system and equipment for reversely generating Java entity class - Google Patents
Method, system and equipment for reversely generating Java entity class Download PDFInfo
- Publication number
- CN114816437A CN114816437A CN202210460046.6A CN202210460046A CN114816437A CN 114816437 A CN114816437 A CN 114816437A CN 202210460046 A CN202210460046 A CN 202210460046A CN 114816437 A CN114816437 A CN 114816437A
- Authority
- CN
- China
- Prior art keywords
- field
- http request
- java
- creating
- database table
- 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
Images
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/53—Decompilation; Disassembly
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/315—Object-oriented languages
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
Abstract
The invention provides a method, a system and equipment for reversely generating a Java entity class, wherein the method comprises the following steps: creating a metadata table for storing metadata of all tables; creating a custom event, and monitoring DDL operation in a database table through the custom event; if the DDL operation is executed in the database table, the correction operation of the metadata table is triggered; creating a trigger, and calling an http component to send an http request to a server after the trigger monitors the correction operation, wherein the http request carries the change data; and after receiving the http request, the server analyzes the change data in the http request, generates a Java entity class according to the change data, and updates the content in the Java source file. The invention realizes the synchronous linkage of the database table and the Java source file, can automatically synchronize to the Java source file when the database table is changed, and improves the working efficiency.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a method, a system and equipment for reversely generating Java entity classes.
Background
The Java language is a strong type of compiling language, and during the compiling process of each item, the actual class file (. class) corresponding to the reference type in the source code must be loaded and subjected to declaration checking to complete the compiling work. The class, which is compiled by Java, must exist in a file form in the project environment, and can be compiled and loaded by the compiler and then loaded into the virtual machine for running.
However, in the prior art, synchronous linkage of the data table and the Java entity class cannot be realized, the Java entity class can only be generated in a full-disk reverse mode through the data table, and only manual adjustment can be performed on changes after the entity structure is determined, so that the efficiency is low.
Disclosure of Invention
In view of the foregoing, it is desirable to provide a method, system and device for generating Java entity classes in reverse.
A method for reversely generating Java entity classes comprises the following steps: creating a metadata table, wherein the metadata table is used for storing metadata of all tables; creating a custom event, and monitoring DDL operation in a database table through the custom event; if the DDL operation is executed in the database table, the correction operation of the metadata table is triggered; creating a trigger, and calling an http component to send an http request to a server after the trigger monitors the correction operation, wherein the http request carries the change data; and after receiving the http request, the server analyzes the change data in the http request, generates a Java entity class according to the change data, and updates the content in the Java source file.
In one embodiment, the creating a custom event, and monitoring a DDL operation in a database table through the custom event specifically includes: creating a custom event and setting the time interval for calling the custom event; when the user-defined event is called, comparing columns in a database table with columns in the metadata table, and judging whether DDL operation exists in the database table.
In one embodiment, the triggering a modify operation of the metadata table if the DDL operation is executed in the database table specifically includes: detecting whether the columns in the database table are consistent with the columns in the metadata table; if the column in the database table is consistent with the column in the metadata table, determining that the DDL operation is not executed in the database table; if the columns in the database table are not consistent with the columns in the metadata table, the DDL operation is executed in the database table, the correction operation of the metadata table is triggered, and the inconsistent columns in the metadata table are deleted, changed or added.
In one embodiment, the creating a trigger, after the trigger monitors the correction operation, calls an http component to send an http request to a server, where the http request carries change data, and specifically includes: creating a trigger, and monitoring the correction operation of the metadata table through the trigger; if the fact that the metadata table executes the correction operation is monitored, acquiring a change table name and a change column name which enter the correction operation to form a json character string, and taking the json character string as change data; and calling an http component to send an http request to the server, wherein the http request carries the change data.
In one embodiment, after receiving the http request, the server parses change data in the http request, generates a Java entity class according to the change data, and updates content in a Java source file, which specifically includes: calling an analysis method in the abstract syntax tree to analyze the designated Java source file; analyzing all fields in the Java source file through a static Java analyzer in the abstract syntax tree, and storing all analyzed fields into a field list set; searching a target field corresponding to the changed column name in the field list set; sending the target field to a field index variable, searching a corresponding field, and acquiring a new field according to a search result of the field index variable; reading the content in the Java source file into a character string, generating a Java entity class according to the json character string, and supplementing the Java entity class and the original code into the new field to complete the updating of the Java source file.
In one embodiment, the searching for the target field corresponding to the changed list name in the field list set specifically includes: searching whether a field with the same name as the changed column name exists in the field list set; if the field with the same name as the changed column name exists, the field with the same name is regarded as a target field, and the subscript of the target field in the field list set is returned to the field index variable; and if the field with the same name as the changed column name does not exist, taking the element corresponding to the changed column name as a target field and sending the target field to the field index variable.
In one embodiment, the obtaining a new field according to a search result of the field index variable specifically includes: if the search result of the field index variable is less than 0, the field with the same name does not exist, and a new field is acquired according to the new column name and the new field; and if the search result of the field index variable is greater than or equal to 0, taking the field corresponding to the search result as a new field.
A system for reverse generation of Java entity classes, comprising: the metadata table creating module is used for creating a metadata table, and the metadata table is used for storing metadata of all tables; the custom event creating module is used for creating a custom event and monitoring DDL operation in a database table through the custom event; the correction operation triggering module is used for triggering the correction operation of the metadata table when the DDL operation is executed in the database table; the trigger creating module is used for creating a trigger, and calling an http component to send an http request to a server after the trigger monitors the correction operation, wherein the http request carries the change data; and the Java source file updating module is used for analyzing the change data in the http request after the server receives the http request, generating a Java entity class according to the change data and updating the content in the Java source file.
An apparatus comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the steps of a method for generating a Java entity class in reverse in the above embodiments when executing the program.
Compared with the prior art, the invention has the advantages and beneficial effects that: the invention realizes the synchronous linkage of the database table and the Java source file, can automatically synchronize to the Java source file when the database table is changed, and improves the working efficiency.
Drawings
FIG. 1 is a flowchart illustrating a method for generating Java entity classes in a reverse manner according to an embodiment;
FIG. 2 is a block diagram of a system for reverse generation of Java entity classes, according to an embodiment;
fig. 3 is a schematic diagram of the internal structure of the apparatus in one embodiment.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to the accompanying drawings by way of specific embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.
In one embodiment, as shown in fig. 1, there is provided a method for generating Java entity classes reversely, including the following steps:
step S101, a metadata table is newly created, and the metadata table is used for storing metadata of all tables.
Specifically, a metadata table is created, and metadata of all tables in a repository is stored through the metadata table
And step S102, creating a custom event, and monitoring DDL operation in a database table through the custom event.
Specifically, a custom event is created, for example, the custom event is executed every 5 seconds, each time the custom event is executed, the columns in the database table meta-database are compared with the columns in the current metadata table, and whether the DDL operation is executed in the database table is determined by monitoring the columns which exist in the database table but do not exist in the metadata table, where the database table may be an information _ schema database table.
Step S103, if the DDL operation is executed in the database table, the correction operation of the metadata table is triggered.
Specifically, if the DDL operation is executed in the database table through the custom event, the correction operation is triggered, and the columns in the metadata table, which are inconsistent with the columns in the database table, are deleted, changed or added, so that the consistency of the contents in the database table and the metadata table is ensured.
And step S104, creating a trigger, and calling an http component to send an http request to the server after the trigger monitors the correction operation, wherein the http request carries the change data.
Specifically, a trigger is created, whether a correction operation is executed in the metadata table is monitored through the trigger, if the correction operation is executed in the metadata table, an http component, such as udf-http component, is called, and an http request is sent to the server, where the http request carries the change data of the metadata table.
And step S105, after receiving the http request, the server analyzes the change data in the http request, generates a Java entity class according to the change data, and updates the content in the Java source file.
Specifically, after receiving the http request, the server analyzes change data carried in the http request, converts the change data into a hump character string, searches for a Java source file with the same name in a specified directory on the server through the hump character string obtained through conversion, reads the Java source file through an abstract syntax tree, analyzes all fields of the Java source file, generates a modified Java entity class according to the change data, and fuses the Java entity class and the content in the Java source file to realize the update of the Java source file.
In this embodiment, a metadata table for storing metadata of all tables is newly created, a custom event is created, a DDL operation in a database table is monitored through the custom event, a correction operation of the metadata table is triggered when the DDL operation is executed in the database table, a trigger is created, an http component is called to send an http request to a server after the trigger monitors the correction operation, the http request carries change data, the server receives the http request, analyzes the change data in the http request, generates a Java entity class according to the change data, and updates the content in a Java source file, so that synchronous linkage of the database table and the Java source file is realized, the Java source file can be automatically synchronized when the database table has a change, and the working efficiency is improved.
Wherein, step S102 specifically includes: creating a custom event and setting the time interval for calling the custom event; when the self-defined event is called, the columns in the database table are compared with the columns in the metadata table, and whether the DDL operation exists in the database table is judged.
Specifically, a custom event is created, and a call-up event of the custom event is set, for example, executed every 5 s; when the user-defined event is called, comparing columns in the database table with columns in the metadata table, judging whether inconsistent contents are included, and if the inconsistent contents are included, determining that the database table executes DDL operation; otherwise, the DDL operation is not executed by the database table.
Wherein, step S103 specifically includes: detecting whether the columns in the database table are consistent with the columns in the metadata table or not, and if so, determining that the DDL operation is not executed in the database table; if the columns in the database table are not consistent with the columns in the metadata table, the DDL operation is executed in the database table, the correction operation of the metadata table is triggered, and the inconsistent columns in the metadata table are deleted, changed or added.
Specifically, whether columns in the database table are consistent with columns in the metadata table or not is detected, if yes, the database table is determined not to execute the DDL operation, if not, the data table is determined to execute the DDL operation, the correction operation of the metadata table is triggered, and the inconsistency in the database table is eliminated by executing the deletion, change or addition operation in the metadata table.
Wherein, step S104 specifically includes: creating a trigger, and monitoring the correction operation of the metadata table through the trigger; if the metadata table is monitored to execute the correction operation, acquiring a change table name and a change column name which enter the correction operation to form a json character string, and taking the json character string as change data; and calling an http component to send an http request to the server, wherein the http request carries the change data.
Specifically, a trigger is created, the correction operation of the metadata table is monitored through the trigger, if the metadata table is monitored to execute the correction operation, the change table name and the change column name which enter in the correction operation are obtained, columns with the change table name and the change column name as conditions form a json character string, the json character string is used as change data, an http component is called to send an http request to a server, and the change data formed by the json character string is carried in the http request.
Wherein, step S105 specifically includes: calling an analysis method in the abstract syntax tree to analyze the designated Java source file; analyzing all fields in the Java source file through a static Java analyzer in the abstract syntax tree, and storing all analyzed fields into a field list set; searching a target field corresponding to the changed column name in the field list set; sending the target field to a field index variable, searching a corresponding field, and acquiring a new field according to a search result of the field index variable; reading the content in the Java source file into a character string, generating a Java entity class according to the json character string, and supplementing the Java entity class and the original code into a new field to complete the updating of the Java source file.
Specifically, a designated Java source file is analyzed by calling a StaticJavaParser analysis method in an abstract syntax tree, all fields in the Java source file are analyzed through an abstract syntax tree StaticJavaParser object (a static Java analyzer), all the fields obtained through analysis are stored in a field list set, a target field corresponding to a changed list name is searched in the field list set, the target field is sent to a field index variable, the corresponding field is searched, a new field is obtained according to the search result of the field index variable, the content in the Java source file is read into a character string, the character string of the last brace in the Java source file is removed, a Java entity class is generated according to a json character string, the Java entity class and an original code are supplemented into the new field, the new field is written into the Java source file, and the update of the Java source file is completed.
The method for searching the target field corresponding to the changed column name in the field list set specifically comprises the following steps: searching whether a field with the same name as the changed column name exists in the field list set; if the field with the same name as the changed column name exists, the field with the same name is regarded as a target field, and the subscript of the target field in the field list set is returned to the field index variable; and if the field with the same name as the changed column name does not exist, taking the element corresponding to the changed column name as a target field and sending the target field to the field index variable.
Specifically, searching for a target field corresponding to a changed column name in a field list set specifically includes: searching whether a field with the same name as the name of the changed column exists in the field list set, regarding the field with the same name as a target field, and returning the subscript in the set of the target field to a field index variable; and if the same-name field does not exist, taking an element corresponding to the changed column name as a target field, sending the target field to a field index variable, and detecting whether the target field exists in the Java source file or not through the field index variable.
The obtaining of the new field according to the search result of the field index variable specifically includes: if the search result of the field index variable is less than 0, the field with the same name does not exist, and a new field is acquired by newly building the field according to the new column name; and if the search result of the field index variable is greater than or equal to 0, taking the field corresponding to the search result as a new field.
Specifically, when a new field is searched according to the field index variable, if the search result of the field index variable is less than 0, it indicates that no field with the same name exists, and a new field is created according to the new column name to obtain the new field; and if the search result of the field index variable is greater than or equal to 0, taking the field corresponding to the search result as a new field, and correcting the new field according to the change data, thereby completing the synchronization of the database table and the Java source file.
As shown in fig. 2, there is provided a system 20 for generating Java entity classes in reverse, comprising: a metadata table new creation module 21, a custom event creation module 22, a revision operation triggering module 23, a trigger creation module 24, and a Java source file update module 25, wherein:
a metadata table creating module 21, configured to create a metadata table, where the metadata table is used to store metadata of all tables;
a custom event creating module 22, configured to create a custom event, and monitor a DDL operation in the database table through the custom event;
a correction operation triggering module 23, configured to trigger a correction operation of the metadata table when the DDL operation is executed in the database table;
the trigger creating module 24 is configured to create a trigger, and after the trigger monitors the correction operation, invoke an http component to send an http request to the server, where the http request carries the change data;
and the Java source file updating module 25 is configured to, after receiving the http request, the server parses change data in the http request, generates a Java entity class according to the change data, and updates content in the Java source file.
In one embodiment, the custom event creation module 22 is specifically configured to: creating a custom event and setting the time interval for calling the custom event; when the custom event is called, comparing the columns in the database table with the columns in the metadata table, and judging whether the DDL operation exists in the database table.
In one embodiment, the modification operation triggering module 23 is specifically configured to: detecting whether the columns in the database table are consistent with the columns in the metadata table or not, and if so, determining that the DDL operation is not executed in the database table; if the columns in the database table are not consistent with the columns in the metadata table, the DDL operation is executed in the database table, the correction operation of the metadata table is triggered, and the inconsistent columns in the metadata table are deleted, changed or added.
In one embodiment, the trigger creation module 24 is specifically configured to: creating a trigger, and monitoring the correction operation of the metadata table through the trigger; if the metadata table is monitored to execute the correction operation, acquiring a change table name and a change column name which enter the correction operation to form a json character string, and taking the json character string as change data; and calling an http component to send an http request to the server, wherein the http request carries the change data.
In one embodiment, the Java source file update module 25 is specifically configured to: calling an analysis method in the abstract syntax tree to analyze the designated Java source file; analyzing all fields in the Java source file through a static Java analyzer in the abstract syntax tree, and storing all analyzed fields into a field list set; searching a target field corresponding to the changed column name in the field list set; sending the target field to a field index variable, searching a corresponding field, and acquiring a new field according to a search result of the field index variable; reading the content in the Java source file into a character string, generating a Java entity class according to the json character string, and supplementing the Java entity class and the original code into a new field to complete the updating of the Java source file.
In one embodiment, a device is provided, which may be a server, and its internal structure diagram may be as shown in fig. 3. The device includes a processor, a memory, a network interface, and a database connected by a system bus. Wherein the processor of the device is configured to provide computing and control capabilities. The memory of the device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The database of the device is used for storing configuration templates and also can be used for storing target webpage data. The network interface of the device is used for communicating with an external terminal through a network connection. The computer program is executed by a processor to implement a method of generating Java entity classes in reverse.
It will be appreciated by those skilled in the art that the configuration shown in fig. 3 is a block diagram of only a portion of the configuration associated with the present application, and does not constitute a limitation on the devices to which the present application may be applied, and that a particular device may include more or less components than those shown, or some components may be combined, or have a different arrangement of components.
In one embodiment, a storage medium may also be provided, the storage medium storing a computer program comprising program instructions which, when executed by a computer, cause the computer to perform the method according to the preceding embodiment, the computer may be part of a system for inversely generating Java entity classes of the kind mentioned above.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. The storage medium may be a magnetic disk, an optical disk, a Read-only Memory (ROM), a Random Access Memory (RAM), or the like.
It will be apparent to those skilled in the art that the modules or steps of the invention described above may be implemented in a general purpose computing device, they may be centralized on a single computing device or distributed across a network of computing devices, and optionally they may be implemented in program code executable by a computing device, such that they may be stored on a computer storage medium (ROM/RAM, magnetic disks, optical disks) and executed by a computing device, and in some cases, the steps shown or described may be performed in an order different than that described herein, or they may be separately fabricated into individual integrated circuit modules, or multiple ones of them may be fabricated into a single integrated circuit module. Thus, the present invention is not limited to any specific combination of hardware and software.
The foregoing is a more detailed description of the present invention with reference to specific embodiments thereof, and it is not intended to limit the invention to the specific embodiments thereof. For those skilled in the art to which the invention pertains, several simple deductions or substitutions can be made without departing from the spirit of the invention, and all shall be considered as belonging to the protection scope of the invention.
Claims (9)
1. A method for reversely generating Java entity classes is characterized by comprising the following steps:
creating a metadata table, wherein the metadata table is used for storing metadata of all tables;
creating a custom event, and monitoring DDL operation in a database table through the custom event;
if the DDL operation is executed in the database table, the correction operation of the metadata table is triggered;
creating a trigger, and calling an http component to send an http request to a server after the trigger monitors the correction operation, wherein the http request carries the change data;
and after receiving the http request, the server analyzes the change data in the http request, generates a Java entity class according to the change data, and updates the content in the Java source file.
2. The method of claim 1, wherein the creating a custom event and monitoring DDL operations in a database table through the custom event specifically include:
creating a custom event and setting the time interval for calling the custom event;
when the user-defined event is called, comparing columns in a database table with columns in the metadata table, and judging whether DDL operation exists in the database table.
3. The method of claim 2, wherein if the DDL operation is executed in the database table, the triggering of the modification operation of the metadata table specifically includes:
detecting whether the columns in the database table are consistent with the columns in the metadata table;
if the column in the database table is consistent with the column in the metadata table, determining that the DDL operation is not executed in the database table;
if the columns in the database table are not consistent with the columns in the metadata table, the DDL operation is executed in the database table, the correction operation of the metadata table is triggered, and the inconsistent columns in the metadata table are deleted, changed or added.
4. The method according to claim 3, wherein the creating of the trigger calls an http component to send an http request to the server after the trigger monitors the modification operation, the http request carrying the change data specifically includes:
creating a trigger, and monitoring the correction operation of the metadata table through the trigger;
if the fact that the metadata table executes the correction operation is monitored, acquiring a change table name and a change column name which enter the correction operation to form a json character string, and taking the json character string as change data;
and calling an http component to send an http request to the server, wherein the http request carries the change data.
5. The method according to claim 4, wherein the server, after receiving the http request, parses change data in the http request, generates a Java entity class according to the change data, and updates contents in a Java source file, specifically comprising:
calling an analysis method in the abstract syntax tree to analyze the designated Java source file;
analyzing all fields in the Java source file through a static Java analyzer in the abstract syntax tree, and storing all analyzed fields into a field list set;
searching a target field corresponding to the changed column name in the field list set;
sending the target field to a field index variable, searching a corresponding field, and acquiring a new field according to a search result of the field index variable;
reading the content in the Java source file into a character string, generating a Java entity class according to the json character string, and supplementing the Java entity class and the original code into the new field to complete the updating of the Java source file.
6. The method according to claim 5, wherein the searching for the target field corresponding to the changed column name in the field list set specifically includes:
searching whether a field with the same name as the changed column name exists in the field list set;
if the field with the same name as the changed column name exists, the field with the same name is regarded as a target field, and the subscript of the target field in the field list set is returned to the field index variable;
and if the field with the same name as the changed column name does not exist, taking the element corresponding to the changed column name as a target field and sending the target field to the field index variable.
7. The method according to claim 5, wherein the obtaining of the new field according to the search result of the field index variable specifically includes:
if the search result of the field index variable is less than 0, the field with the same name does not exist, and a new field is acquired according to the new column name and the new field;
and if the search result of the field index variable is greater than or equal to 0, taking the field corresponding to the search result as a new field.
8. A system for generating Java entity classes in reverse, comprising:
the metadata table creating module is used for creating a metadata table, and the metadata table is used for storing metadata of all tables;
the custom event creating module is used for creating a custom event and monitoring DDL operation in a database table through the custom event;
the correction operation triggering module is used for triggering the correction operation of the metadata table when the DDL operation is executed in the database table;
the trigger creating module is used for creating a trigger, and calling an http component to send an http request to a server after the trigger monitors the correction operation, wherein the http request carries the change data;
and the Java source file updating module is used for analyzing the change data in the http request after the server receives the http request, generating a Java entity class according to the change data and updating the content in the Java source file.
9. An apparatus comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the steps of the method of any of claims 1 to 7 are implemented when the computer program is executed by the processor.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210460046.6A CN114816437A (en) | 2022-04-28 | 2022-04-28 | Method, system and equipment for reversely generating Java entity class |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210460046.6A CN114816437A (en) | 2022-04-28 | 2022-04-28 | Method, system and equipment for reversely generating Java entity class |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114816437A true CN114816437A (en) | 2022-07-29 |
Family
ID=82509896
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210460046.6A Pending CN114816437A (en) | 2022-04-28 | 2022-04-28 | Method, system and equipment for reversely generating Java entity class |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114816437A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115481932A (en) * | 2022-10-20 | 2022-12-16 | 广州市扬海数码科技有限公司 | ERP system database trigger generation method, storage medium and electronic device |
-
2022
- 2022-04-28 CN CN202210460046.6A patent/CN114816437A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115481932A (en) * | 2022-10-20 | 2022-12-16 | 广州市扬海数码科技有限公司 | ERP system database trigger generation method, storage medium and electronic device |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109032631B (en) | Application program patch package obtaining method and device, computer equipment and storage medium | |
| US10990515B2 (en) | Automated unit testing in a mainframe environment | |
| CN111414350B (en) | Service generation method and device | |
| CN109710220B (en) | Relational database query method, relational database query device, relational database query equipment and storage medium | |
| US20150143348A1 (en) | Hybrid dynamic code compiling device, method, and service system thereof | |
| US20180004508A1 (en) | Program code comparison and reporting | |
| CN108415998B (en) | Application dependency relationship updating method, terminal, device and storage medium | |
| US9760470B2 (en) | Device, method, and program analysis of new source code to be added to execution program to check for bug | |
| CN110543427A (en) | Test case storage method and device, electronic equipment and storage medium | |
| CN112612502A (en) | Patch generation method, device, equipment and storage medium | |
| CN114816437A (en) | Method, system and equipment for reversely generating Java entity class | |
| CN113495728A (en) | Dependency relationship determination method, dependency relationship determination device, electronic equipment and medium | |
| CN106909434B (en) | Method and device for detecting undefined function in executable program | |
| CN115794214B (en) | Application module metadata management method, device, storage medium and apparatus | |
| CN112506518A (en) | Compiling method and device based on configuration file | |
| CN111679976A (en) | Method and device for searching page object | |
| CN113126998B (en) | Incremental source code acquisition method and device, electronic equipment and storage medium | |
| CN115729590A (en) | Service deployment method, device, equipment and computer readable storage medium | |
| EP2721494B1 (en) | System and method to in-line script dependencies | |
| CN113515303B (en) | Project transformation method, device and equipment | |
| CN113360156B (en) | IOS compiling method and related equipment | |
| CN114816816A (en) | Collapse stack information processing method, device, equipment and storage medium | |
| CN112800194A (en) | Interface change identification method, device, equipment and storage medium | |
| JP4937387B2 (en) | Automatic rewriting program and automatic rewriting device | |
| US11256602B2 (en) | Source code file retrieval |
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 |