WO2023155487A1 - Code refactoring method and device - Google Patents

Abstract

A code refactoring method and a device, which are applied in the field of information technology. In the method, a high-level code architecture diagram is able to be presented to a user on a user interface and a modification on a code structure by the user can be received, and the user can modify the code structure by means of an interface operation and obtain a modified code project. Consequently, code refactoring and visual display of a code structure are integrated into one, allowing a user to not need to switch between different code levels, and thereby greatly improving code refactoring efficiency. Additionally, a visual operation lowers a use barrier, and the code refactoring experience of a user is improved.

Description

Code reconstruction method and device

This application claims the priority of the Chinese patent application with the application number 202210152592.3 and the application name "code reconstruction method and device" submitted to the China Patent Office on February 18, 2022, the entire contents of which are incorporated in this application by reference.

technical field

The present application relates to the field of information technology (IT), and in particular to a code reconstruction method and device.

Background technique

In the development process, in order to improve the quality of code engineering, it is often necessary to refactor the code. Code refactoring is to improve the internal structure of a software system without changing its external behavior.

In the traditional code refactoring process, developers often need to understand the entire code structure from the architectural level, then design a refactoring strategy based on the current bad design, and finally implement and complete the code refactoring from the code level. In the process of code refactoring, it is often necessary to understand the entire code project at a higher level to find a bad design in the code. However, refactoring and repairing this bad design can only start from the underlying code level and modify the specific code. Developers often need to switch between different code levels when refactoring, resulting in low code refactoring efficiency.

Contents of the invention

The embodiment of the present application provides a code refactoring method and device, which can greatly improve code refactoring efficiency.

In the first aspect, the embodiment of the present application provides a code reconstruction method, including:

Presenting a first user interface, the first user interface is used to indicate the code structure of the first code project, the code structure includes one or more elements in packages, classes, class members or underlying code;

receiving a first operation input by a user on the first user interface, where the first operation is used to update the code structure of the first code project;

Refactoring of the first code project is requested from a first server based on the first operation.

The embodiment of the present application can present the code structure diagram to the user on the user interface, and the user can modify the code structure through interface operations and obtain the modified code project. In this way, the view display of the code structure and code refactoring are integrated, so that users do not need to switch between different code levels, thus greatly improving the efficiency of code refactoring. In addition, the visualized operation lowers the threshold for using code refactoring and improves the user's code refactoring experience.

In a possible implementation manner of the first aspect, the method further includes:

Acquire the refactored first code project. In this way, the user device can view the refactored code project, which is convenient for the user to confirm the refactored structure, and can continue to refactor the first code project, which improves the user experience in the code refactoring process.

In yet another possible implementation manner of the first aspect, the first operation includes one or more of moving, adding, deleting, editing, and the like for the element.

Wherein, the move operation may update the position of elements in the code structure and the like. Taking moving class members as an example, users can move a class member from one class to another.

The adding operation can add elements. Taking adding a class as an example, the user can create a new class member. Taking adding fields as an example, users can encapsulate new fields.

The delete operation can remove and destroy an element. For example, a user can delete a package, delete a class, delete a class member, etc.

Editing operations can update elements. For example, users can change the attributes of fields, modify the name of classes, split classes, and so on.

Optionally, the first operation also includes sliding, zooming, pointing, clicking, long pressing, and the like. Wherein, operations such as sliding and zooming may be used to adjust a display area, a page size, and the like. Among them, the pointing operation can be used for the user to select an element. The click operation can be used for the user to select an element, select an option, or confirm an operation (such as submitting a modification, etc.). The long press operation can be used for the user to select an element, move an element, or delete an element, etc.

In yet another possible implementation manner of the first aspect, the first user interface is further used to indicate a code architecture smell existing in the first code project.

Through the above design, the user equipment can simultaneously understand the code structure of the first code project and the bad taste of the code structure of the first code project through the first user interface, without switching between multiple windows, reducing operations and saving time. In addition, the bad smell of the code structure is displayed through the interface, so that users do not need to check all elements one by one, which can improve the efficiency and accuracy of code refactoring, and improve the user's code refactoring experience.

In yet another possible implementation manner of the first aspect, the code architecture smell existing in the first code project corresponds to the element;

The first user interface is also used to distinguish the degree of bad code structure smell in the elements by color.

The degree here includes one or more of the degree of quantity, the severity of the code architecture smell, or the urgency of the code architecture smell. In this way, through the distinction of colors, users can understand the distribution of bad architecture smells more quickly, improve the efficiency of users in discovering code architecture smells, and improve user experience.

In yet another possible implementation manner of the first aspect, before presenting the first user interface, the method further includes:

Receive first indication information of the first code project provided by the second server, where the first indication information is used to indicate a code architecture smell existing in the first code project.

In the above embodiments, the code structure smell is provided by the server to the user equipment. Since the server is a device with centralized computing resources, using the server to detect bad code architecture smells can shorten the time for determining bad code architecture smells and improve the efficiency of code refactoring.

Optionally, the first server and the second server may be the same server, or the first server and the second server may be included in the same server.

In yet another possible implementation manner of the first aspect, the first user interface is further used to indicate a refactoring recommendation, and the refactoring recommendation is used to prompt the user to solve the code structure failure existing in the first code project. Flavors make modifications to the first code project.

In the above implementation, on the one hand, the user refactors the code based on the recommended refactoring solution, which can save time and improve the refactoring efficiency; Error adjustments when refactoring improve the accuracy of modifying code architecture bad smells.

In yet another possible implementation manner of the first aspect, before presenting the first user interface, the method further includes:

The reconstruction recommendation sent by the second server is received.

In the above embodiments, the reconstruction recommendation is provided by the server to the user equipment. Since the server is a device with centralized computing resources, determining the refactoring recommendation through the server can shorten the time for determining the refactoring recommendation and improve the efficiency of code refactoring.

In yet another possible implementation manner of the first aspect, the requesting the server to refactor the first code project based on the first operation includes:

According to the first operation, an atomic reconstruction sequence is obtained, and the atomic reconstruction sequence is used to record an operation sequence for updating the first code project;

sending a reconstruction request message to the first server, where the reconstruction request message includes the atomic reconstruction sequence.

In the above implementation, the user's operation sequence can be recorded through the atomic reconstruction sequence, so that the server can reproduce the user's operation sequence according to the atomic reconstruction sequence when reconstructing the code, so as to accurately implement the code according to the user's needs. refactor.

In yet another possible implementation manner of the first aspect, the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and the Parameters in the first code project.

In the above implementation, the content of the atomic reconstruction operation is described. Through the atomic reconstruction operation, the user's operation can be converted into data in a certain format, so that the server can perform code reconstruction according to the formatted data. Improve the efficiency and accuracy of code refactoring.

In yet another possible implementation manner of the first aspect, before presenting the first user interface, the method further includes:

sending second indication information of the first code project to a third server;

Receive the code structure of the first code project provided by the third server.

In the above implementation manner, the code structure of the first code project is provided to the user equipment by the server. Since the server is a device with centralized computing resources, determining the code structure of the first code project through the server can shorten the time for determining the code structure and improve the efficiency of code reconstruction.

Optionally, the first server and the third server may be the same server, or the first server and the third server may be included in the same server. Further, the first server, the second server and the third server may be the same server, or the first server, the second server and the third server may be included in the same server.

In the second aspect, the embodiment of the present application provides a code reconstruction method, including:

receiving a reconstruction request message from the user equipment, the reconstruction request message is obtained according to a first operation input on the first user interface, and the first user interface is used to indicate the code structure of the first code project , the code structure includes one or more elements in package, class, class member or underlying code, and the first operation is used to update the code structure of the first code project;

Refactor the first code project according to the refactoring request message.

In a possible implementation manner of the second aspect, the method further includes:

Feedback the reconstructed first code project to the user equipment.

In yet another possible implementation manner of the second aspect, the first operation includes one or more of moving, adding, deleting, editing, and the like for the element.

Wherein, the move operation may update the position of elements in the code structure and the like. Taking moving class members as an example, users can move a class member from one class to another.

The adding operation can add elements. Taking adding a class as an example, the user can create a new class member. Taking adding fields as an example, users can encapsulate new fields.

The delete operation can remove and destroy an element. For example, a user can delete a package, delete a class, delete a class member, etc.

Editing operations can update elements. For example, users can change the attributes of fields, modify the name of classes, split classes, and so on.

Optionally, the first operation also includes sliding, zooming, pointing, clicking, long pressing, and the like. Wherein, operations such as sliding and zooming may be used to adjust a display area, a page size, and the like. A pointing operation can be used for the user to select an element. The click operation can be used for the user to select an element, select an option, or confirm an operation (such as submitting a modification, etc.). The long press operation can be used for the user to select an element, move an element, or delete an element, etc.

In yet another possible implementation manner of the second aspect, the method further includes:

Determining the code architecture bad smell that exists in the first code project;

Sending first indication information to the user equipment, where the first indication information is used to indicate a code architecture smell existing in the first code project.

In yet another possible implementation manner of the second aspect, the code architecture smell existing in the first code project corresponds to the element;

The first user interface is also used to distinguish the degree of bad code structure smell in the elements by color.

In yet another possible implementation manner of the second aspect, the determining the bad code architecture smell existing in the first code project includes:

The code architecture smell in the first code project is determined by using the architecture smell detection model.

Optionally, the architecture bad smell detection model can be obtained by training in one or more ways such as reinforcement learning, deep learning, or neural network.

In the above implementation manner, the server may include an architecture smell detection model, through which the code architecture smell in the first code project can be determined. The architectural smell detection model can be obtained through training data, and can automatically detect code architectural smells in the first code project, thereby providing users with more accurate detection results.

In yet another possible implementation manner of the second aspect, the determining the bad code architecture smell existing in the first code project includes:

Static code analysis and text similarity calculation are performed on the first code project to obtain the bad smell of the code structure in the first code project.

In the above manner, the server can automatically detect bad code architecture smells in the first code project by performing code static analysis and text similarity calculation on the code project, thereby providing users with more accurate detection results.

In yet another possible implementation manner of the second aspect, the method further includes:

Determining a refactoring recommendation, where the refactoring recommendation is used to prompt the user to modify the first code project for the bad smell of the code architecture existing in the first code project;

Sending the reconstruction recommendation to the user equipment.

In yet another possible implementation manner of the second aspect, the reconstruction request message includes the atomic reconstruction sequence, and the atomic reconstruction sequence is used to record an operation sequence of modifying and updating the first code project;

The refactoring of the first code project according to the refactoring request message includes:

The first code project is reconstructed according to the atomic reconstruction sequence in the reconstruction request message.

In yet another possible implementation manner of the second aspect, the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and the Elements in the first code project.

In yet another possible implementation manner of the second aspect, before receiving the reconfiguration request message from the user equipment, the method further includes:

receiving indication information of a first code project from the user equipment;

determining the code structure of the first code project;

The code structure of the first code project is provided to the user equipment.

In a third aspect, an embodiment of the present application provides a code reconstruction system, where the code reconstruction system includes a user equipment and a server, wherein;

The user equipment is configured to present a first user interface, the first user interface is used to indicate a code structure of a first code project, and the code structure includes one or more of a package, a class, a class member, or an underlying code kind of element;

The user equipment is further configured to receive a first operation input by a user on the first user interface, where the first operation is used to update the code structure of the first code project;

The user equipment is further configured to send a reconstruction recommendation message to a server, and the reconstruction request message is obtained according to a first operation input on the first user interface;

The server is configured to receive a reconstruction request message from a user equipment;

The server is further configured to refactor the first code project according to the refactoring request message.

In a possible implementation manner of the third aspect, the server is further configured to feed back the reconstructed first code project to the user equipment;

The user equipment is further configured to receive the reconstructed first code project provided by the server.

In yet another possible implementation manner of the third aspect, the first operation includes one or more of moving, adding, deleting, and editing the element.

In yet another possible implementation manner of the third aspect, the server is also used for:

Determining the code architecture bad smell that exists in the first code project;

Sending first indication information to the user equipment, where the first indication information is used to indicate a code architecture smell existing in the first code project;

The user equipment is also used for:

receiving first indication information from the server;

A bad code architecture smell existing in the first code project is indicated through the first user interface.

In yet another possible implementation manner of the third aspect, the server is further configured to determine a code architecture smell in the first code project by using an architecture smell detection model.

In yet another possible implementation manner of the third aspect, the server is further configured to perform code static analysis and text similarity calculation on the first code project to obtain code structure errors in the first code project. smell.

In yet another possible implementation manner of the third aspect, the server is further configured to:

Determining a refactoring recommendation, where the refactoring recommendation is used to prompt the user to modify the first code project for the bad smell of the code architecture existing in the first code project;

sending the reconstruction recommendation to the user equipment;

The user equipment is also used for:

receiving the reconstruction recommendation provided by the server;

The refactoring recommendation is indicated through the first user interface.

In yet another possible implementation manner of the third aspect, the user equipment is further configured to send second indication information of the first code project to the server;

The server is further configured to determine the code structure of the first code project;

The server is further configured to send the code structure of the first code project to the user equipment;

The user equipment is further configured to receive the code structure of the first code project provided by the server;

The user equipment is further configured to indicate the code structure of the first code project through the first user interface.

In a fourth aspect, an embodiment of the present application provides a code reconstruction device, the code reconstruction device includes a processing unit and a communication unit, and the code reconstruction device is used to perform any possible operation of the first aspect or the first aspect. The method described in the embodiment.

In a possible implementation manner of the fourth aspect, the processing unit is configured to present a first user interface, the first user interface is used to indicate the code structure of the first code project, and the code structure includes a package, one or more elements in a class, class member, or underlying code;

The communication unit is configured to receive a first operation input by a user on the first user interface, where the first operation is used to update the code structure of the first code project;

The processing unit and the communication unit are further configured to request the first server to reconstruct the first code project based on the first operation.

In yet another possible implementation manner of the fourth aspect, the processing unit and the communication unit are further configured to obtain the reconstructed first code project.

In yet another possible implementation manner of the fourth aspect, the first operation includes one or more of moving, adding, deleting, editing, and the like for the element.

Wherein, the move operation may update the position of elements in the code structure and the like. Taking moving class members as an example, users can move a class member from one class to another.

The adding operation can add elements. Taking adding a class as an example, the user can create a new class member. Taking adding fields as an example, users can encapsulate new fields.

The delete operation can remove and destroy an element. For example, a user can delete a package, delete a class, delete a class member, etc.

Editing operations can update elements. For example, users can change the attributes of fields, modify the name of classes, split classes, and so on.

Optionally, the first operation also includes sliding, zooming, pointing, clicking, long pressing, and the like. Wherein, operations such as sliding and zooming may be used to adjust a display area, a page size, and the like. Among them, the pointing operation can be used for the user to select an element. The click operation can be used for the user to select an element, select an option, or confirm an operation (such as submitting a modification, etc.). The long press operation can be used for the user to select an element, move an element, or delete an element, etc.

In yet another possible implementation manner of the fourth aspect, the first user interface is further used to indicate a code architecture smell existing in the first code project.

In yet another possible implementation manner of the fourth aspect, the code architecture smell existing in the first code project corresponds to the element;

The first user interface is also used to distinguish the degree of bad code structure smell in the elements by color.

In yet another possible implementation manner of the fourth aspect, the communication unit is further configured to:

Receive first indication information of the first code project provided by the second server, where the first indication information is used to indicate a code architecture smell existing in the first code project.

In yet another possible implementation manner of the fourth aspect, the first user interface is further used to indicate a refactoring recommendation, and the refactoring recommendation is used to prompt the user to solve the code structure failure existing in the first code project. Flavors make modifications to the first code project.

In yet another possible implementation manner of the fourth aspect, the communication unit is further configured to:

The reconstruction recommendation sent by the second server is received.

In yet another possible implementation manner of the fourth aspect, the processing unit is further configured to obtain an atomic reconstruction sequence according to the first operation, and the atomic reconstruction sequence is used to record, modify and update the first code project sequence of operations;

The communication unit is further configured to send a reconstruction request message to the first server, where the reconstruction request message includes the atomic reconstruction sequence.

In yet another possible implementation manner of the fourth aspect, the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and the Parameters in the first code project.

In yet another possible implementation manner of the fourth aspect, the communication unit is further configured to:

sending instruction information of the first code project to the fourth server;

Receive the code structure of the first code project provided by the third server.

In the fifth aspect, the embodiment of the present application provides a code reconstruction device, the code reconstruction device includes a processing unit and a communication unit, and the code reconstruction device is used to implement the second aspect or any possible method of the second aspect. The method described in the embodiment.

In a possible implementation manner of the fifth aspect, the communication unit is configured to receive a reconfiguration request message from the user equipment, where the reconfiguration request message is based on the first Obtained by the operation, the first user interface is used to indicate the code structure of the first code project, the code structure includes one or more elements in packages, classes, class members, or underlying codes, and the first operation uses for updating the code structure of the first code project;

The processing unit is configured to refactor the first code project according to the refactoring request message.

In yet another possible implementation manner of the fifth aspect, the communication unit is further configured to feed back the reconstructed first code project to the user equipment.

In yet another possible implementation manner of the fifth aspect, the first operation includes one or more of moving, adding, deleting, editing, and the like for the element.

Wherein, the move operation may update the position of elements in the code structure and the like. Taking moving class members as an example, users can move a class member from one class to another.

The adding operation can add elements. Taking adding a class as an example, the user can create a new class member. Taking adding fields as an example, users can encapsulate new fields.

The delete operation can remove and destroy an element. For example, a user can delete a package, delete a class, delete a class member, etc.

Editing operations can update elements. For example, users can change the attributes of fields, modify the name of classes, split classes, and so on.

Optionally, the first operation also includes sliding, zooming, pointing, clicking, long pressing, and the like. Wherein, operations such as sliding and zooming may be used to adjust a display area, a page size, and the like. Among them, the pointing operation can be used for the user to select an element. The click operation can be used for the user to select an element, select an option, or confirm an operation (such as submitting a modification, etc.). The long press operation can be used for the user to select an element, move an element, or delete an element, etc.

In yet another possible implementation manner of the fifth aspect, the processing unit is further configured to determine a code architecture smell existing in the first code project;

The communication unit is further configured to send first indication information to the user equipment, where the first indication information is used to indicate a code architecture smell existing in the first code project.

In yet another possible implementation manner of the fifth aspect, the code architecture smell existing in the first code project corresponds to the element;

The first user interface is also used to distinguish the degree of bad code structure smell in the elements by color.

In yet another possible implementation manner of the fifth aspect, the processing unit is further configured to determine a code architecture smell in the first code project by using an architecture smell detection model.

Optionally, the architecture bad smell detection model can be obtained by training in one or more ways such as reinforcement learning, deep learning, or neural network.

In yet another possible implementation manner of the fifth aspect, the processing unit is further configured to perform code static analysis and text similarity calculation on the first code project to obtain the code structure in the first code project bad taste.

In yet another possible implementation manner of the fifth aspect, the processing unit is further configured to determine a refactoring recommendation, and the refactoring recommendation is used to prompt the user to respond to the bad code architecture smell existing in the first code project. said first code project is modified;

The communication unit is further configured to send the reconstruction recommendation to the user equipment.

In yet another possible implementation manner of the fifth aspect, the reconstruction request message includes the atomic reconstruction sequence, and the atomic reconstruction sequence is used to record an operation sequence of modifying and updating the first code project;

The processing unit is further configured to reconstruct the first code project according to the atomic reconstruction sequence in the reconstruction request message.

In yet another possible implementation manner of the fifth aspect, the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and the Elements in the first code project.

In yet another possible implementation manner of the fifth aspect, the communication unit is further configured to receive indication information of the first code project from the user equipment;

The processing unit is further configured to determine a code structure of the first code project;

The communication unit is further configured to provide the code structure of the first code project to the user equipment.

In a sixth aspect, an embodiment of the present application provides a computing device, the computing device includes a processor and a communication interface; the communication interface is used to receive and/or send data, and/or the communication interface is used to provide the The processor provides input and/or output; the processor is used to implement the method described in any one of the first aspect or any one of the second aspect.

It should be noted that the processor included in the computing device described in the sixth aspect above may be a processor dedicated to executing these methods (referred to as a dedicated processor for easy distinction), or it may be executed by calling a computer program Handlers for these methods, such as general-purpose handlers. Optionally, at least one processor may also include both a special-purpose processor and a general-purpose processor.

Optionally, the above computer programs may be stored in memory. Exemplarily, the memory can be a non-transitory (non-transitory) memory, such as a read-only memory (Read Only Memory, ROM), which can be integrated with the processor on the same device, or can be respectively arranged on different devices , the embodiment of the present application does not limit the type of the memory and the arrangement of the memory and the processor.

In a possible implementation manner, the at least one memory is located outside the computing device.

In yet another possible implementation manner, the at least one memory is located within the computing device.

In yet another possible implementation manner, part of the memory of the at least one memory is located inside the computing device, and another part of the memory is located outside the computing device.

In this application, the processor and the memory may also be integrated into one device, that is, the processor and the memory may also be integrated together.

In the seventh aspect, the embodiment of the present application provides a code reconstruction system, the code reconstruction system includes a user equipment and a server, the user equipment includes the code reconstruction device according to any one of the fourth aspect; the server includes The code reconstruction device according to any one of the fifth aspect.

In the eighth aspect, the embodiment of the present application provides a computer-readable storage medium, the computer-readable storage medium stores instructions, and when the instructions are run on at least one processor, any one of the aforementioned first aspects is implemented. Or the method described in any one of the second aspect.

In a ninth aspect, the present application provides a computer program product, the computer program product includes computer instructions, and when the instructions are run on at least one processor, it can realize any one of the above-mentioned first aspect or any one of the second aspect. described method.

Optionally, the computer program product may be a software installation package. If the aforementioned method needs to be used, the computer program product may be downloaded and executed on the computing device.

For the beneficial effects of the technical methods provided in the second to ninth aspects of the present application, reference may be made to the beneficial effects of the technical solution in the first aspect, and details are not repeated here.

Description of drawings

The drawings that need to be used in the description of the embodiments will be briefly introduced below.

FIG. 1 is a schematic diagram of the architecture of a code refactoring system provided by an embodiment of the present application;

FIG. 2 is a schematic flowchart of a code reconstruction method provided by an embodiment of the present application;

FIG. 3A is a schematic diagram of a code structure hierarchy provided by an embodiment of the present application;

FIG. 3B is a schematic diagram of another code structure hierarchy provided by the embodiment of the present application;

FIG. 3C is a schematic diagram of another code structure hierarchy provided by the embodiment of the present application;

FIG. 3D is a schematic diagram of another code structure hierarchy provided by the embodiment of the present application;

Fig. 4 is a schematic diagram of a user interface provided by an embodiment of the present application;

Fig. 5 is a schematic diagram of another user interface provided by the embodiment of the present application;

Fig. 6 is a schematic diagram of another user interface provided by the embodiment of the present application;

Fig. 7 is a schematic diagram of an operation provided by the embodiment of the present application;

Fig. 8 is a schematic flowchart of another code reconstruction method provided by the embodiment of the present application;

Fig. 9 is a work flow chart of an architecture bad smell automatic detection and reconstruction scheme recommendation module provided by the embodiment of the present application;

FIG. 10 is a schematic structural diagram of a code reconstruction device provided by an embodiment of the present application;

FIG. 11 is a schematic structural diagram of a computing device provided by an embodiment of the present application.

Detailed ways

Embodiments of the present application will be described in detail below in conjunction with the accompanying drawings.

For ease of understanding, the following descriptions of some concepts related to the embodiments of the present application are provided by way of example for reference. As follows:

Code engineering includes code files written by developers according to certain programming language specifications. In this application, code files generally refer to source code files. A code file includes a series of human-readable computer language instructions, which can be compiled into computer-executable binary instructions by a compiler. When the binary instruction is executed, the function corresponding to the binary instruction can be realized.

Of course, the code project may also contain other files, such as configuration files, resource files, reference files, etc. related to the development environment of the code project. This application does not limit this.

In the process of project development, although developers will follow some development plans and specifications for development, when the business structure is complex, the schedule is tight, or due to time migration and version iterations, some bad designs may appear in the code. These bad designs are also known as "bad taste". Exemplarily, code smells may include one or more of the following types: repeated code, long functions, too long parameter lists, circular dependencies, or unstable dependencies.

The emergence of bad smells will affect the quality of code engineering, and code refactoring can improve the structure of the code, modify the bad smells in code engineering, adjust the program code to improve the quality and performance of the software, and make the design pattern and structure of the program more Reasonable, improve the scalability and maintainability of the software.

Developers often need to understand the entire code project at a higher level when they find bad design in the code. However, refactoring and repairing this bad design can only start from the underlying code level and modify the specific code. Developers often need to switch between different code levels when refactoring, resulting in low code refactoring efficiency.

In view of this, the embodiment of the present application provides a code refactoring method and device, which can integrate the view display of the code structure and code refactoring, so that developers do not need to switch between different code levels, thereby greatly improving code refactoring efficiency. In addition, the visual operation lowers the threshold of use and improves the user's code refactoring experience.

The system architecture of the embodiment of the present application is exemplarily described below. It should be noted that the system architecture described in this application is to illustrate the technical solution of this application more clearly, and does not constitute a limitation to the technical solution provided by this application. Those of ordinary skill in the art know that with the evolution of system architecture and For the emergence of new business scenarios, the technical solution provided by this application is also applicable to similar technical problems.

Please refer to FIG. 1 . FIG. 1 is a schematic structural diagram of a possible code refactoring system provided by an embodiment of the present application. The code reconstruction system 10 includes a user device 101 and a server 102 . Optionally, the system 10 further includes a server 103 and/or a server 104 .

Wherein, the user equipment 101 is an electronic equipment capable of data processing and data sending and receiving, capable of presenting a user interface and receiving user input operations. The user equipment 101 may include an independent device such as a desktop computer, a notebook computer, a handheld terminal, a wearable device, a vehicle, or a robot, or may be a component included in an independent device (such as a chip or an integrated circuit, etc.). Exemplarily, when the terminal device is a handheld terminal, it may be a mobile phone, a tablet computer (pad), or a palmtop computer.

The server 102 is a device having data processing, and is capable of refactoring code engineering. It should be understood that it is referred to as a server for convenience of description here, and its specific form may be a physical device such as a server or a host, or a virtual device such as a virtual machine or a container. Optionally, the server 102 may be independently deployed on one device, or may be distributed and deployed on multiple devices.

The server 103 is a device with data processing capabilities, capable of determining bad smells in code engineering, and/or, capable of generating refactoring recommendations for code engineering.

The server 104 is a device having data processing capability, capable of generating a code structure of a code project.

It should be noted that the aforementioned servers, such as server 102, server 103, or server 104, etc., may be independent devices, or may be integrated in other devices, or partly independent devices, partly integrated in other devices.

As a possible solution, the server 102 (or the server, or the server 104, etc.) may be a process or a thread running on a computing device, capable of data processing.

As yet another optional method, the foregoing server 102, server 103, or server 104 may also be integrated into the same device.

When a communication connection is established between any two of the above four, the link of the communication connection may include one or more types of connection media, including wired links (such as optical fibers), wireless links, or wired links and wireless combination of links, etc. For example, the connection medium can be a wireless link, and the wireless link adopts a short-distance connection technology, such as 802.11b/g technology, Bluetooth (Blue Tooth) technology, Zigbee (Zigbee) technology, radio frequency identification (Radio Frequency Identification, RFID) technology, ultra-wideband (Ultra Wideband, UWB) technology, wireless short-range communication (such as vehicle-mounted wireless short-distance communication) technology or vehicle networking (vehicle to everything, V2X, information exchange between vehicles and the outside world) technology, etc. For another example, the wireless link adopts long-distance connection technology, such as Global System for Mobile Communications (GSM), General Packet Radio Service (GPRS), Universal Mobile Telecommunications System (Universal Mobile Telecommunications System) , UMTS), LTE, or 5G and other wireless access technologies.

In a possible design, the foregoing servers, such as the server 102, the server 103, or the server 104, may be deployed on a cloud platform. Among them, the cloud platform includes a large number of basic resources provided by cloud service providers (including but not limited to computing resources, recording resources, or network resources, etc.), where computing resources can be provided by one or more computing modules (such as rack server , blade server, or virtual machine, etc.).

In a possible implementation scenario, the functions performed by the server in the above code reconstruction system can be abstracted into code reconstruction cloud services by the cloud service provider on the cloud platform and provided to users. For example, after a user purchases a code refactoring cloud service, the cloud platform responds to the user's request, refactors the code project on the resources provided by the cloud service provider, and then provides the user with the refactored code project. Correspondingly, the user equipment used by the user can present the interface and use the code to reconstruct the cloud service.

It should be noted that, in the embodiment of the present application, the cloud platform may be a cloud platform of the central cloud, a cloud platform of the edge cloud, or a cloud platform including the central cloud and the edge cloud, which is not specifically limited in the embodiment of the present application. Moreover, when the cloud platform includes a central cloud and an edge cloud, the code reconstruction system may be partially deployed on the edge cloud cloud platform and partially deployed on the central cloud cloud platform.

The method in the embodiment of the present application will be described in detail below.

[Example 1]

Please refer to FIG. 2 . FIG. 2 is a schematic flowchart of a code refactoring method provided by an embodiment of the present application. Optionally, the method can be applied to the system shown in FIG. 1 .

The code reconstruction method shown in FIG. 2 may include steps S201 to S205. It should be understood that, for the convenience of description, the present application uses the sequence of S201 to S205 for description, and does not intend to limit the execution to be performed in the above sequence. The embodiment of the present application does not limit the execution sequence, execution time, and execution times of the above one or more steps. Step S201 to step S205 are as follows:

Step S201: the user equipment presents a first user interface.

The first user interface is used to indicate the code structure of the code project. The code structure of the code project includes one or more elements in the first code project.

Exemplarily, the code structure includes one or more elements in packages, classes, class members, or underlying code. Further, when the code structure of the code project is displayed in the form of package elements, the code structure of the code project may also be called the package structure of the code project. Similarly, when the code structure of the code project is displayed in the form of class elements, the code structure of the code project may also be called the class structure of the code project. The rest of the elements can also be analogized in the same way, and will not be repeated here.

As a possible solution, the code structure contains multiple levels, and each level is used to mainly display a certain kind of element. For example, the code structure level that mainly displays package elements is called package structure, the code structure level that mainly shows cumulative elements is called class structure, and so on for other levels. Further, different levels can be switched, which is convenient for users to understand the code structure of the code project from each level.

For example, please refer to FIG. 3A , FIG. 3B , FIG. 3C and FIG. 3D . FIG. 3A , FIG. 3B , FIG. 3C and FIG. 3D are schematic diagrams of levels of several possible code structures provided by the embodiments of the present application. FIG. 3A is used to exemplarily show the package structure of the code project, wherein the package structure can be global or local, so that users can understand the package elements of the code project according to requirements. As a possible solution, the user equipment may display the partial packet structure after receiving an operation input by the user for the partial packet structure. Exemplarily, the user clicks one of the packages to enter the class structure diagram of the code project as shown in FIG. 3B . The class structure diagram can display one or more items of class names, parameters, methods, and the like. Exemplarily, the user clicks on one of the classes to enter the class member structure diagram of the code project as shown in FIG. 3C . A class member structure diagram can display one or more of the methods, attributes, or other class members in the class. Exemplarily, when the user clicks on one of the class members, the source code related to the class member may be displayed, as shown in FIG. 3D .

Optionally, there may be one code project or multiple code projects. For ease of description, the following first code project is taken as an example for illustration.

For example, please refer to FIG. 4 , which is a schematic diagram of a possible user interface provided by an embodiment of the present application. The user interface 401 includes multiple interface components, and each interface component is used to display one or more elements of the code structure. Exemplarily, the interface component 402 in the user interface 401 is used to display the package in the code structure, wherein the rectangular box shown in the area 403 is used to display the name of the package. For ease of understanding, Figure 4 uses "package 1", "package 2" and so on to describe the name of the package as an example, and does not represent a limitation on the display form of the package. Do limited.

Optionally, the user interface can also display connections between elements. Wherein, the relationship between the elements may include a call relationship, a containment relationship, a reference relationship, or a dependency relationship between the elements. Exemplarily, in the user interface shown in FIG. 4 , package 4 may include package 5 and package 6 , and there may be a dependency relationship between package 1 and package 2 .

Optionally, the code structure of the first code project can be obtained in the following two ways:

Mode 1, the code structure of the first code project may be generated by the user equipment itself. For example, the first code project is stored in the user equipment, and the user equipment analyzes the first code project to generate a code structure of the first code project. Further, the user equipment displays the code structure of the first code project through the first user interface.

Mode 2, the code structure of the first code project may be provided to the user equipment by other devices (such as a server, or other terminals related to the user equipment, or a management device corresponding to the user equipment, etc.). For example, the server (hereinafter referred to as the third server for ease of distinction) may provide the user equipment with the code structure of the first code project.

Further, the user equipment may send a request message to the third server, and the third server responds to the request of the user equipment to feed back the code structure of the first code project to the user equipment. Wherein, the request message may include indication information of the first code project (referred to as second indication information for convenience of distinction), and the second indication information is, for example: the first code project itself, the identification (identify, ID) of the first code project, the first The code project number, the user ID to which the first code project belongs, the device ID where the first code project is located, or the name of the first code project, etc.

Exemplarily, the user equipment provides the first code project to the third server, and the third server analyzes the first code project to feed back the code structure of the first code project to the user equipment.

For another example, the code engineering is stored in the code hosting server, and IDs are used for identification. The user equipment provides the ID of the first code project to the third server, and the third server acquires the first code project based on the ID of the first code project, analyzes the first code project, and feeds back the code structure of the first code project to the user equipment.

Optionally, the foregoing first server and the third server may be the same server, or the first server and the third server may be included in the same server. Further, the first server, the second server and the third server may be the same server, or the first server, the second server and the third server may be included in the same server.

In a possible design, the first user interface is also used to indicate code architecture smells existing in the first code project. Among them, bad code architecture smell refers to bad design in code engineering, such as one or more of repeated code, long function, too long parameter list, circular dependency, or unstable dependency. It should be understood that the types of code architecture smells, judgment rules, etc. may be defined or configured by computer program management agencies, enterprises, laws and regulations, or users, and this application is applicable to code architecture smells set in different ways.

For ease of understanding, this application exemplifies the following possible solutions:

Solution 1: the first user interface is also used to indicate whether there is a code architecture smell in the first code project.

Further, when there is a bad code architecture smell in the first code project, the user equipment may present a reminder message on the first user interface, and the reminder message may remind the user that there is a code architecture smell in the first code project.

Scheme 2: The first user interface is also used to indicate the content of the code architecture smell existing in the first code project, and the content of the code smell includes the number and type of the code smell. Wherein, the number of code architecture bad smells existing in the first code project may be one or more. For example, please refer to Fig. 5, which is a schematic diagram of another possible user interface provided by the embodiment of the present application. Among them, the area 502 is used to indicate the code structure of the first code project, and the area 501 is used to display the bad smell of the code structure existing in the first code project. Exemplarily, the following bad code architecture smells exist in the first code project: circular dependencies, unstable dependencies, and the like.

Solution 3: The first user interface is further used to indicate the elements of the code architecture smell existing in the first code project, or to indicate the location of the code architecture smell existing in the first code project.

Among them, elements with bad code architecture smell that exist are distinguished from elements with bad code architecture smell that do not exist. Exemplarily, as shown in FIG. 5 , elements with bad code architecture smell are displayed by black rectangle components (as shown in component 503 ), and elements without code architecture smell are displayed by rectangle components of other colors.

Solution 4: The first user interface is also used to distinguish the degree of bad code architecture smell in the elements through colors. The degree here includes one or more of the degree of quantity, the severity of the code architecture smell, or the urgency of the code architecture smell.

For example, an element has a more compelling display when displayed when the greater the number of code architecture smells present in the element. For example, when the number of bad tastes in an element falls within the interval [1,5], the element is displayed with the first color; when the number of bad tastes in an element falls into the interval [6,10] range, the element is displayed with the second color; when the number of bad tastes in the element is greater than 10, the element is displayed with the third color. Wherein, the third color has higher brightness than the first color and the second color, and the second color has higher brightness than the second color.

For another example, different code architecture smells have different negative impacts on code engineering, so different types of code architecture smells have different urgency levels. The higher the urgency level of a code architecture smell present in an element, the more compelling the element is when displayed.

In one possible design, the degree of bad code architecture in elements can be distinguished through heat maps, where heat maps are displayed in the form of special (such as highlighting, high saturation, or brilliant display effects, etc.) A diagram showing areas of the page that users care about more.

It should be understood that the above solution is an exemplary solution, and in a specific design, there may be more solutions for reminding the user of bad code architecture smells in the first code project. For example, the user is prompted by sound, light, electricity, vibration, etc. The above-mentioned solutions can also be combined under the condition that they are not mutually exclusive, and details will not be repeated here.

Optionally, the bad code structure smell in the first code project may be determined by the user equipment, or through other devices (such as a server, or other terminals related to the user device, or a management device corresponding to the user device, etc.) definite. For ease of understanding, this application exemplifies the following possible implementations:

Implementation mode 1, the code architecture smell existing in the first code project may be determined by the user equipment. At this time, the user equipment may analyze the first code project to obtain the bad smell of the code structure of the first code project. Further, when presenting the user interface, the bad smell of the code architecture in the first code project and the code structure of the first code project are fused together for presentation.

Implementation mode 2, the bad smell of the code structure existing in the first code project may be provided to the user equipment by other devices. For example, the server (hereinafter referred to as the second server for ease of distinction) may provide the user equipment with the code architecture smell existing in the first code project.

Further, the user equipment may send a request message to the second server, and the second server responds to the request of the user equipment, analyzes the bad smell of the code architecture in the first code project, and provides the user equipment with the first instruction information of the first code project. The indication information is used to indicate the bad smell of the code architecture existing in the first code project.

Optionally, the foregoing first server and the second server may be the same server, or the first server and the second server may be included in the same server.

In a possible design, the first user interface is also used to indicate reconstruction recommendations. The refactoring recommendation is used to prompt the user to modify the first code project for the bad code architecture smell existing in the first code project.

For example, please refer to FIG. 6 . FIG. 6 is a schematic diagram of another possible user interface provided by an embodiment of the present application. Among them, the area 601 is used to indicate the code structure of the first code project, and the area 602 is used to display the contents of the bad smell of the code structure existing in the first code project. The components shown in the area 603 are used to display the information of the class in the first code project, and the information of the class includes the class name (as shown in the area 604), the parameters of the class (as shown in the area 605), or the method in the class ( One or more of the above, as shown in area 606). Exemplarily, the class name can be, for example, "SpecialOrder" (that is, a class for processing special order business, or called a special order class), "Customer (that is, a class for processing customers, or called a customer class)", "Order (that is, the class used to process orders, or called the order class)", "NormalOrder (that is, the class used to process regular orders, or called the normal order class)" and so on. The parameters of the class can optionally include the parameter name and the data type of the parameter. For example, the data type of the parameter name is a string (represented as: String in Figure 6), and the data type of the parameter date is a date format (represented as: Date in Figure 6) . The methods in the class are usually displayed in the form of "method name ()", for example: "SendOrder()", "ReceiveOrder()", "GetOrderDate()", "Confirm()", "Close()", "Dispatch ()", "Receive()", etc.

In Figure 6, the content shown in bold and underlined is the bad smell of the "feature attachment" architecture in the first code project (that is, the GetOrderDate() method in the class structure makes the class structure of the first code project exist. architecture smells bad). As shown in area 607, the first user interface also indicates a refactoring recommendation to eliminate the bad smell of this architecture, which is used to prompt the user: the GetOrderDate() method is more suitable to be moved to the Order class.

Optionally, the reconstruction recommendation may be determined by the user equipment, or determined by other devices (such as a server, or other terminals related to the user device, or a management device corresponding to the user device, etc.). For ease of understanding, this application exemplifies the following possible situations:

In case 1, the reconstruction recommendation may be determined by the user equipment. At this time, the user equipment may analyze the first code project to determine a refactoring recommendation for the first code project.

As an optional solution, when the user equipment presents the user interface, the reconstruction recommendation and the code structure of the first code project are fused together for presentation.

Optionally, when the user equipment acquires the architectural smell of the first code project, the architectural smell of the first code project, the refactoring recommendation, and the code structure of the first code project may also be presented together.

In case 2, the reconstruction recommendation may be provided to the user equipment by other devices. For example, the server (hereinafter referred to as the second server for ease of distinction) may provide the user equipment with the code architecture smell existing in the first code project.

Further, the user equipment may send a request message to the second server, and the second server responds to the request of the user equipment, determines the reconstruction recommendation, and provides the reconstruction recommendation to the user equipment.

As an optional solution, the second server may also provide the user equipment with a first user interface, where the first user interface combines the code structure of the refactoring recommendation and the first code engineering. Optionally, when the second server determines the architectural smell of the first code project, the first user interface may also incorporate the architectural smell of the first code project, the refactoring recommendation, and the code structure of the first code project.

Step S202: the user equipment receives a first operation input by the user on the first user interface.

Specifically, the first operation is used to update the code structure of the first code project.

Optionally, the first operation may include one or more items of moving, adding, deleting, editing, sliding, zooming, pointing, clicking, long pressing, etc. for the element.

Wherein, the move operation may update the position of elements in the code structure and the like. Taking moving class members as an example, users can move a class member from one class to another. Exemplarily, the user equipment may present a user interface as shown in FIG. 6 , and the user may drag the GetOrderDate() method into the Order class in the user interface. Correspondingly, the user equipment receives the mobile operation of the user for the GetOrderDate() method.

The adding operation can add elements. Taking adding a class as an example, the user can create a new class member. Taking adding fields as an example, users can encapsulate new fields. Taking Figure 4 as an example, the user can create a new package, for example called "package 7".

The delete operation can remove and destroy an element. For example, users can delete packages, delete classes, delete class members, or delete dependencies, etc. For example, in the user interface shown in Figure 6, the user can delete the location field in the customer class.

Editing operations can update elements in the code project. For example, users can change the attributes of fields, modify the name of classes, split classes, and so on. Taking FIG. 4 as an example, the user can rename the name of the package on the user interface, for example, rename "package 4" to "package 8".

Wherein, operations such as sliding and zooming may be used to adjust a display area, a page size, and the like. For example, sliding on the user interface can adjust the display area to a certain area. For another example, as shown in FIG. 7 is a schematic diagram of a possible operation provided by the embodiment of the present application. Through the zoom operation, the user interface can view a part of the structure shown in part (a) of FIG. 7, namely The structure shown in part (b) of FIG. 7 makes it possible to view the elements more clearly and facilitate updating of the elements.

Among them, the pointing operation can be used for the user to select an element. The click operation can be used for the user to select an element, select an option, or confirm an operation (such as submitting a modification, etc.). The long press operation can be used for the user to select an element, move an element, or delete an element, etc.

It should be understood that the first operation may be one operation or multiple operations. When the first operation is multiple operations, the user equipment may record multiple operations input by the user on the first user interface.

Step S203: the user equipment requests reconstruction of the first code project from the first server based on the first operation.

Specifically, the first operation is used to update the code structure of the first code project, so the user equipment may request the first server to reconstruct the first code project based on the operation input by the user.

For example, the user equipment may send a reconstruction request message to the first server, where the reconstruction request message includes indication information corresponding to the first operation. Correspondingly, the first server may receive the reconstruction request message.

In a possible design, the indication information corresponding to the first operation may include an atomic reconstruction sequence. Specifically, the user equipment may generate an atomic reconstruction sequence according to the input first operation, and the atomic reconstruction sequence is used to record an operation sequence for updating the first code project. The user equipment may send the atomic reconstruction sequence to the first server, and the atomic reconstruction sequence is used for the server to reconstruct the first code project according to the user's operation sequence.

As a possible solution, the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and parameters in the first code project involved in the atomic reconstruction operation (for convenience described below as control parameters). For ease of understanding, Table 1 exemplarily lists a possible identifier of an atomic reconstruction operation and corresponding control parameters. Wherein, the identifiers of the refactoring operations are, for example, "movemethod", "movefield", etc., which correspond to the user's method move operation and field move operation. When moving a method, the control parameters include source (source), target (target), and method name (method), which are used to record where the method starts to move, the destination of the move, and the name of the method.

Table 1 Identification and parameters of atomic reconstruction operation

Exemplarily, when the user moves the method (as shown in FIG. 6, the user can move the GetOrderDate() method), the user equipment records the identifier (namely movemethod) and control parameters (namely: "source: Customer", "target: Order", "method: GetOrderDate()"). In the specific implementation process, the atomic reconstruction operation can be expressed by the following formula:

ref(p1,p2,...)

Wherein, ref represents the identifier of the atomic reconstruction, and p1, p2, etc. represent the control parameters of the atomic reconstruction operation. Furthermore, the atomic reconstruction sequence CR can be expressed by the following expression:

CR=[ref1(p1 ₁ , pi1 ₂ ,...), ref2(p2 ₁ , pi2 ₂ ,...),...]

Among them, ref1(p1 ₁ , pi1 ₂ ,...) is the first atomic reconstruction operation, ref1 represents the identification of the first atomic reconstruction operation, p1 ₁ , pi1 ₂ , etc. represent the control parameters of the first atomic reconstruction operation , and so on for the rest of the parameters.

It should be understood that the information of the atomic reconstruction operation shown in Table 1 is only an example. During the specific implementation process, the instruction information of the operation generated by the user equipment may also be defined or configuration. Optionally, the atomic reconstruction operation may contain more or less content than Table 1, and its storage, transmission, and display forms may also be corresponding relationship sets, queues, heaps, stacks, or database tables. This is not limited.

Step S204: the first server reconstructs the first code project.

Based on the operation input by the user, the user equipment may request the first server to reconstruct the first code project. The first server reconstructs the first code project in response to the request of the user equipment.

Optionally, the first server may receive a reconfiguration request message from the user equipment, where the reconfiguration request message includes indication information corresponding to the first operation. The first server reconstructs the first code project according to the indication information corresponding to the first operation.

In a possible design, the indication information corresponding to the first operation may include an atomic reconstruction sequence, and the atomic reconstruction sequence is used to record an operation sequence for updating the first code project. The server may reconstruct the first code project according to the user's operation sequence according to the atomic reconstruction sequence.

Optionally, the code refactoring method shown in FIG. 2 may include step S205, which may be understood as optional here, step S205 may or may not be executed during the specific implementation process. Step S205 is specifically as follows:

Step S205: the first server feeds back the reconstructed first code project to the user equipment. Correspondingly, the user equipment receives the reconstructed first code project provided by the server.

In a possible design, the first server may feed back the refactored first code project to the code hosting server, and the first server feeds back a refactoring completion message to the user equipment. In response to the reconstruction completion message, the user equipment receives the reconstructed first code project from the code hosting server.

In yet another possible design, after the first code project is reconstructed, the first server may feed back the code structure of the reconstructed first code project to the user equipment, so that the user equipment can present the reconstructed first code project code structure. When the user equipment requests the first code project, the first server feeds back the first code project to the user equipment.

Optionally, after the user equipment acquires the reconstructed first code project (or the code structure of the reconstructed first code project). The user equipment may receive an operation output by the user to continue to reconstruct the first code project.

In the embodiment shown in FIG. 2 , the user equipment can present the code structure diagram to the user on the user interface, and the user can modify the code structure through interface operations and obtain the modified code project. In this way, the view display of the code structure and code refactoring are integrated, so that users do not need to switch between different code levels, thus greatly improving the efficiency of code refactoring. In addition, the visualized operation lowers the threshold for using code refactoring and improves the user's code refactoring experience.

[Example 2]

The embodiment shown in FIG. 2 includes various possible solutions, some of which are further described below. Please refer to FIG. 8 . FIG. 8 is a flowchart of another possible code refactoring method provided by the embodiment of the present application. The steps shown in FIG. 8 may include part or all of the steps in step S801-step S810. It should be understood that, for the convenience of description, the present application uses the sequence of S801 to S810 for description, and does not intend to limit the execution to be performed in the above sequence. There is no limitation on the execution sequence, execution time, and execution times of the above one or more steps. Step S801-step S810 are specifically as follows:

Step S801: the user equipment opens the first code project.

Wherein, the first code project may be stored locally. The user equipment opens the first code project, and all code files of the first code project will be acquired. Optionally, the user may input an operation on the user equipment, and the user equipment responds to the operation input by the user to open the first code project.

Alternatively, the first code project may be stored in other devices. The user equipment may send a request to the device storing the code project to present relevant content of the first code project.

Step S802: the server determines the code structure of the first code project.

Optionally, the server may use static program analysis techniques to analyze the source code, and obtain multiple elements in the code project.

Optionally, the server may also determine the relationship between elements in the code project, for example, determine code relationship meta-information such as call relationship, inheritance dependency relationship, inclusion relationship, etc. in the code project.

Step S803: the server generates a code structure diagram.

Specifically, the server generates a code structure diagram according to the elements of the first code project and the relationships between elements (optional).

Optionally, the code structure diagram may contain multiple levels, such as a package structure diagram, a class structure diagram, or a class member structure diagram.

As a possible solution, the server can generate a code structure diagram through a unified modeling language (Unified Modeling Language, UML) class diagram generation technology.

Step S804: The server performs code smell detection.

Specifically, the server performs bad smell detection on the first code project, so as to determine the bad smell of the code structure existing in the first code project.

In a possible design, step S804 may be executed by an automatic architecture smell detection module in the server. This module can determine the bad smell of code architecture in the first code project through the following two methods:

Mode 1, using an architecture smell detection model to determine the code architecture smell in the first code project. Among them, the architecture bad smell automatic detection module can be based on the deep learning network, and analyze the bad smell in the code according to the trained neural network model.

Mode 2: Static code analysis and text similarity calculation are performed on the first code project to obtain the bad smell of the code architecture in the first code project.

Optionally, the architecture bad smell automatic detection module can analyze various metrics in the code based on the code static analysis technology, and combine the text similarity calculation in the code to detect the bad architecture smell in the code project.

It should be understood that the above two methods can also be combined, and the correctness of the detection result can be improved by combining the two methods.

Optionally, the code refactoring method shown in FIG. 8 may include step S805, which can be understood as optional here, the server may execute step S805, or may not execute step S805. During the specific implementation process, if the user checks the For the reconstruction recommendation service, the server may determine the reconstruction recommendation, and/or, if the user purchases the reconstruction recommendation service, the server may determine the reconstruction recommendation. Step S805 is specifically as follows:

Step S805: the server determines the reconstruction recommendation.

Specifically, the server determines a refactoring recommendation for the bad code structure smell in the first code project, so as to prompt the user how to update the first code project. In this way, the efficiency and accuracy of user code refactoring can be improved, and the experience of user code refactoring can be improved.

In a possible design, step S804 and step S805 can be executed by an automatic architecture smell detection and reconstruction scheme recommendation module in the server, and this module can realize the functions of the above-mentioned automatic architecture smell detection module. For related descriptions, please refer to the description of the automatic detection module for bad architecture smells, so I won't repeat them here.

Please refer to FIG. 9 . FIG. 9 is a work flow chart of a possible automatic detection of architecture bad smell and recommendation module for reconstruction scheme provided by the present application. The deep learning model is trained by training data from pre-set or pre-defined positive sample code bins. The positive sample code warehouse can also be used to mine refactoring patterns to obtain refactoring patterns, and the refactoring patterns are used to generate refactoring code recommendations. Deep learning models can be used to detect bad smells in code. The architecture smell detection module can obtain the code architecture smell in the first code project through code static analysis and text similarity calculation. It should be understood that both the deep learning model and the architecture bad smell detection module may exist in the specific implementation process, or one of them may be retained. The feature extraction module is used to obtain code features, which may represent one or more metrics in code engineering. Optionally, the type and format of the code feature may be pre-defined or pre-configured.

During work, the code project to be analyzed is input into the feature extraction module (optional), and the feature extraction module can extract code features in the code project. The code features are further provided to the deep learning model and/or the architecture smell detection module to obtain the architecture smells existing in the code engineering. The refactoring code recommendation module can generate refactoring recommendations for bad architecture smells in code engineering. Architecture bad smells and refactoring recommendations in code engineering can be output for the server to feed back to user devices.

Step S806: The server integrates the code structure diagram and the bad smell of the code structure.

In this way, the user device can view the code structure of the first code project and the bad taste of the code structure of the first code project at the same time through the code structure diagram, without switching between multiple windows, reducing operations, saving time, and improving the efficiency of code refactoring and accuracy.

Optionally, when the server determines the refactoring recommendation, the server can also integrate the refactoring recommendation, the bad smell of the code architecture, and the code structure diagram.

The server may provide the fused code structure diagram to the user equipment, and correspondingly, the user equipment receives the fused code structure diagram.

Step S807: the user equipment presents a first user interface.

For related description, refer to step S201.

Step S808: the user equipment receives a first operation input by the user.

For related description, refer to step S202.

In a possible design, the user equipment indicates the code smell information and the recommended refactoring solution through the first user interface. The user can update the first code project through interface operations (for example: element dragging, adding, deleting, etc.) on the first user interface. After receiving the user's reconstruction confirmation operation, the user equipment requests the server to reconstruct the first code project.

When requesting reconfiguration, the user equipment may send a reconfiguration request message to the server, and correspondingly, the server receives the reconfiguration request message from the user equipment. Optionally, the reconstruction request message includes indication information of the first operation.

Step S809: the server obtains the atomic reconstruction sequence.

Optionally, the reconstruction request message includes an atomic reconstruction sequence, so that the server obtains the atomic reconstruction sequence.

Or optionally, the reconstruction request message includes the indication information of the first operation, and the server converts the atomic reconstruction sequence according to the indication information of the first operation.

Step S810: The server reconstructs the first code project.

For related description, refer to step S204.

In the embodiment shown in Figure 8, the user equipment can present the high-level code architecture diagram to the user on the user interface and receive the user's modification of the code structure, and the user can modify the code structure through interface operations and obtain the modified code structure. The code behind works. In this way, the view display of the code structure and code refactoring are integrated, so that users do not need to switch between different code levels, thus greatly improving the efficiency of code refactoring. In addition, the visual operation lowers the threshold of use and improves the user's code refactoring experience.

[Embodiment 3]

In a possible design, the functions performed by the server shown in FIG. 8 may be performed by the first server, the second server, and the third server respectively. Among them, the first server is used to implement functions related to refactoring code engineering, the second server is used to implement functions related to determining bad code architecture in code engineering and determining refactoring recommendations, and the third server is used to implement code engineering related functions. Structure related functions.

Wherein, the first server, the second server, and the third server may be independent devices, or may be integrated in the same device, or partly be independent devices, and partly be integrated into an independent device. As a possible solution, the first server, the second server, and the third server may also be software services, computing modules, or processes or threads on the cloud platform.

The method of the embodiment of the present application has been described in detail above, and the device of the embodiment of the present application is provided below.

Please refer to FIG. 10 , which is a schematic structural diagram of a code reconstruction apparatus 100 provided in an embodiment of the present application. The code reconstruction apparatus 100 may include a processing unit 1001 and a communication unit 1002 . The code reconstruction apparatus 100 is used to implement the aforementioned code reconstruction method, for example, the code reconstruction method in the embodiment shown in FIG. 2 or FIG. 8 .

It should be noted here that the division of the above multiple units is only a logical division based on functions, and is not intended to limit the specific structure of the code reconstruction apparatus 100 . In a specific implementation, some of the functional modules may be subdivided into more smaller functional modules, and some of the functional modules may also be combined into one functional module, but no matter whether these functional modules are subdivided.

In a possible design, the code reconstruction apparatus 100 is configured to implement the method on the user equipment side in the embodiment shown in FIG. 2 or FIG. 8 .

In a possible implementation manner, the processing unit 1001 is configured to present a first user interface, the first user interface is used to indicate the code structure of the first code project, and the code structure includes a package, a class, a class one or more elements in a member or underlying code;

The communication unit 1002 is configured to receive a first operation input by a user on the first user interface, where the first operation is used to update the code structure of the first code project;

The processing unit 1001 and the communication unit 1002 are further configured to request the first server to reconstruct the first code project based on the first operation;

The processing unit 1001 and the communication unit 1002 are further configured to obtain the reconstructed first code project.

In yet another possible implementation manner, the first operation includes one or more of moving, adding, deleting, editing, and the like for the element.

Wherein, the move operation may update the position of elements in the code structure and the like. Taking moving class members as an example, users can move a class member from one class to another.

The adding operation can add elements. Taking adding a class as an example, the user can create a new class member. Taking adding fields as an example, users can encapsulate new fields.

The delete operation can remove and destroy an element. For example, a user can delete a package, delete a class, delete a class member, etc.

Editing operations can update elements. For example, users can change the attributes of fields, modify the name of classes, split classes, and so on.

Optionally, the first operation also includes sliding, zooming, pointing, clicking, long pressing, and the like. Wherein, operations such as sliding and zooming may be used to adjust a display area, a page size, and the like. Among them, the pointing operation can be used for the user to select an element. The click operation can be used for the user to select an element, select an option, or confirm an operation (such as submitting a modification, etc.). The long press operation can be used for the user to select an element, move an element, or delete an element, etc.

In yet another possible implementation manner, the first user interface is further used to indicate a code architecture smell existing in the first code project.

In yet another possible implementation manner, the code architecture smell existing in the first code project corresponds to the element;

The first user interface is also used to distinguish the degree of bad code structure smell in the elements by color.

In yet another possible implementation manner, the communication unit 1002 is further configured to:

Receive first indication information of the first code project provided by the second server, where the first indication information is used to indicate a code architecture smell existing in the first code project.

In yet another possible implementation manner, the first user interface is further used to indicate a refactoring recommendation, and the refactoring recommendation is used to prompt the user to correct the code architecture smell existing in the first code project. The first code works to be modified.

In yet another possible implementation manner, the communication unit 1002 is further configured to:

The reconstruction recommendation sent by the second server is received.

Optionally, the first server and the second server may be the same server, or the first server and the second server may be included in the same server.

In yet another possible implementation manner, the processing unit 1001 is further configured to obtain an atomic reconstruction sequence according to the first operation, and the atomic reconstruction sequence is used to record, modify and update the operation sequence of the first code project ;

The communication unit 1002 is further configured to send a reconstruction request message to the first server, where the reconstruction request message includes the atomic reconstruction sequence.

In yet another possible implementation manner, the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and the first code project involved in the atomic reconstruction operation parameters in .

In yet another possible implementation manner, the communication unit 1002 is further configured to:

sending indication information of the first code project to a third server;

Receive the code structure of the first code project provided by the third server.

For related descriptions, reference may also be made to the descriptions in the embodiment shown in FIG. 2 or FIG. 8 , and details are not repeated here.

In yet another possible design, the code reconstruction apparatus 100 is used to implement the method on the server side in the embodiment shown in FIG. 2 or FIG. 8 .

In a possible implementation manner, the communication unit 1002 is configured to receive a reconstruction request message from a user equipment, where the reconstruction request message is obtained according to a first operation input on the first user interface , the first user interface is used to indicate the code structure of the first code project, the code structure includes one or more elements in packages, classes, class members, or underlying codes, and the first operation is used to update the first A code structure of a code project;

The processing unit 1001 is configured to refactor the first code project according to the refactoring request message;

The communication unit 1002 is further configured to feed back the reconstructed first code project to the user equipment.

In yet another possible implementation manner, the first operation includes one or more of moving, adding, deleting, editing, and the like for the element.

Wherein, the move operation may update the position of elements in the code structure and the like. Taking moving class members as an example, users can move a class member from one class to another.

The adding operation can add elements. Taking adding a class as an example, the user can create a new class member. Taking adding fields as an example, users can encapsulate new fields.

The delete operation can remove and destroy an element. For example, a user can delete a package, delete a class, delete a class member, etc.

Editing operations can update elements. For example, users can change the attributes of fields, modify the name of classes, split classes, and so on.

Optionally, the first operation also includes sliding, zooming, pointing, clicking, long pressing, and the like. Wherein, operations such as sliding and zooming may be used to adjust a display area, a page size, and the like. Among them, the pointing operation can be used for the user to select an element. The click operation can be used for the user to select an element, select an option, or confirm an operation (such as submitting a modification, etc.). The long press operation can be used for the user to select an element, move an element, or delete an element, etc.

In yet another possible implementation manner, the processing unit 1001 is further configured to determine a code architecture smell existing in the first code project;

The communication unit 1002 is further configured to send first indication information to the user equipment, where the first indication information is used to indicate a code architecture smell existing in the first code project.

In yet another possible implementation manner, the code architecture smell existing in the first code project corresponds to the element;

The first user interface is also used to distinguish the degree of bad code structure smell in the elements by color.

In yet another possible implementation manner, the processing unit 1001 is further configured to determine a code architecture smell in the first code project by using an architecture smell detection model.

In yet another possible implementation manner, the processing unit 1001 is further configured to perform code static analysis and text similarity calculation on the first code project to obtain code architecture smells in the first code project.

In yet another possible implementation manner, the reconstruction request message includes the atomic reconstruction sequence, and the atomic reconstruction sequence is used to record the operation sequence of modifying and updating the first code project;

The processing unit 1001 is further configured to reconstruct the first code project according to the atomic reconstruction sequence in the reconstruction request message.

In yet another possible implementation manner, the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and the first code project involved in the atomic reconstruction operation elements in .

In yet another possible implementation manner, the communication unit 1002 is further configured to receive indication information of the first code project from the user equipment;

The processing unit 1001 is further configured to determine a code structure of the first code project;

The communication unit 1002 is further configured to provide the user equipment with the code structure of the first code project.

For related descriptions, reference may also be made to the descriptions in the embodiment shown in FIG. 2 or FIG. 8 , and details are not repeated here.

Please refer to FIG. 11. FIG. 11 is a schematic structural diagram of a computing device 110 provided by an embodiment of the present application. The computing device 110 may be an independent device (such as one or more of a server, or a user device, etc.), or may be It is an internal component of an independent device (such as a chip, a software module or a hardware module, etc.). The computing device 110 may include at least one processor 1101 . Optionally, at least one memory 1103 may also be included. Further optionally, the computing device 110 may further include a communication interface 1102 . Further optionally, a bus 1104 may also be included, wherein the processor 1101 , the communication interface 1102 and the memory 1103 are connected through the bus 1104 .

Wherein, the processor 1101 is a module for performing arithmetic operations and/or logic operations, specifically, a central processing unit (central processing unit, CPU), a picture processing unit (graphics processing unit, GPU), a microprocessor (microprocessor unit, MPU) ), Application Specific Integrated Circuit (ASIC), Field Programmable Logic Gate Array (Field Programmable Gate Array, FPGA), Complex Programmable Logic Device (Complex programmable logic device, CPLD), coprocessor (assisting central processing One or more combinations of processing modules such as processors to complete corresponding processing and applications), Microcontroller Units (MCUs) and other processing modules.

Communication interface 1102 may be used to provide information input or output to the at least one processor. And/or, the communication interface 1102 can be used to receive data sent from the outside and/or send data to the outside, and can be a wired link interface such as an Ethernet cable, or a wireless link (Wi-Fi, Bluetooth, general wireless transmission, vehicle short-range communication technology and other short-range wireless communication technologies, etc.) interface. Optionally, the communication interface 1102 may further include a transmitter (such as a radio frequency transmitter, an antenna, etc.) or a receiver coupled with the interface.

The memory 1103 is used to provide a storage space, in which data such as operating systems and computer programs can be stored. Memory 1103 can be random access memory (random access memory, RAM), read-only memory (read-only memory, ROM), erasable programmable read-only memory (erasable programmable read only memory, EPROM), or portable read-only memory One or more combinations of memory (compact disc read-only memory, CD-ROM), etc.

At least one processor 1101 in the computing device 110 is configured to execute the aforementioned code reconstruction method, for example, the code reconstruction method described in the embodiment shown in FIG. 2 or FIG. 8 .

Optionally, the processor 1101 may be a processor dedicated to executing these methods (referred to as a dedicated processor for convenience), or a processor that executes these methods by invoking computer programs, such as a general-purpose processor. Optionally, at least one processor may also include both a special-purpose processor and a general-purpose processor. Optionally, in the case that the computing device includes at least one memory 1103 , the above computer programs may be stored in the memory 1103 .

The present application also provides a computer-readable storage medium, where instructions are stored in the computer-readable storage medium, and when the instructions are run on at least one processor, the aforementioned code reconstruction method is implemented, as shown in Figure 2 Or the code refactoring method shown in Figure 8.

The present application also provides a computer program product, the computer program product includes computer instructions, and when executed by a computing device, implements the aforementioned code refactoring method, such as the code refactoring method shown in FIG. 2 or FIG. 8 .

In the embodiments of the present application, words such as "exemplary" or "for example" are used as examples, illustrations or descriptions. Any embodiment or design described herein as "exemplary" or "for example" is not to be construed as preferred or advantageous over other embodiments or designs. Rather, the use of words such as "exemplary" or "such as" is intended to present related concepts in a concrete manner.

The "at least one" mentioned in the embodiments of the present application refers to one or more, and the "multiple" refers to two or more. "At least one of the following" or similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one item (piece) of a, b, or c may represent: a, b, c, (a and b), (a and c), (b and c), or (a and b and c), where a, b, c can be single or multiple. "And/or" describes the association relationship of associated objects, indicating that there may be three types of relationships, for example, A and/or B, which may indicate: A exists alone, A and B exist simultaneously, and B exists alone, among which A and B may be singular or plural. The character "/" generally indicates that the contextual objects are an "or" relationship.

And, unless otherwise stated, the embodiments of the present application use ordinal numerals such as "first" and "second" to distinguish multiple objects, and are not used to limit the order, timing, priority or importance of multiple objects degree. For example, the first transaction and the second transaction are only for the convenience of description, and do not represent the difference in transaction structure, importance, etc. of the first transaction and the second transaction. In some embodiments, the first transaction and the second transaction A transaction can also be the same transaction.

As used in the above embodiments, depending on the context, the term "when" may be interpreted to mean "if..." or "after" or "in response to determining..." or "in response to detecting... ". The above are only optional embodiments of the application, and are not intended to limit the application. Any modifications, equivalent replacements, improvements, etc. made within the concept and principles of the application shall be included in the protection of the application. within range.

Those of ordinary skill in the art can understand that all or part of the steps for implementing the above embodiments can be completed by hardware, and can also be completed by instructing related hardware through a program. The program can be stored in a computer-readable storage medium. The above-mentioned The storage medium mentioned may be a read-only memory, a magnetic disk or an optical disk, and the like.

Claims (34)

1. A code refactoring method, characterized in that it comprises:

   Presenting a first user interface, the first user interface is used to indicate the code structure of the first code project, the code structure includes one or more elements in packages, classes, class members or underlying code;

   receiving a first operation input by a user on the first user interface, where the first operation is used to update the code structure of the first code project;

   Refactoring of the first code project is requested from a first server based on the first operation.
2. method according to claim 1, is characterized in that, described method also comprises:

   Acquire the refactored first code project.
3. The method according to claim 2, wherein the first operation includes one or more of moving, adding, deleting, editing, etc. for the element.
4. The method according to any one of claims 1-3, wherein the first user interface is further used to indicate bad code architecture smells existing in the first code project.
5. The method according to claim 4, wherein the code architecture bad smell existing in the first code project corresponds to the element;

   The first user interface is also used to distinguish the degree of bad code structure smell in the elements by color.
6. The method according to claim 3 or 4, wherein, before presenting the first user interface, the method further comprises:

   Receive first indication information of the first code project provided by the second server, where the first indication information is used to indicate a code architecture smell existing in the first code project.
7. The method according to any one of claims 1-6, wherein the first user interface is further used to indicate a refactoring recommendation, and the refactoring recommendation is used to prompt the user for The code architecture bad smell makes modifications to the first code project.
8. The method according to claim 7, wherein, before presenting the first user interface, the method further comprises:

   The reconstruction recommendation sent by the second server is received.
9. The method according to any one of claims 1-8, wherein the requesting the server to reconstruct the first code project based on the first operation comprises:

   According to the first operation, an atomic reconstruction sequence is obtained, and the atomic reconstruction sequence is used to record an operation sequence for updating the first code project;

   sending a reconstruction request message to the first server, where the reconstruction request message includes the atomic reconstruction sequence.
10. The method according to any one of claims 1-9, wherein the atomic reconstruction sequence includes multiple atomic reconstruction operations, and each atomic reconstruction operation includes an identifier of the atomic reconstruction operation and the atomic reconstruction operation parameters in the first code project involved in the construction operation.
11. The method according to any one of claims 1-10, wherein before presenting the first user interface, the method further comprises:

    sending second indication information of the first code project to a third server;

    Receive the code structure of the first code project provided by the third server.
12. A code refactoring method, characterized in that it comprises:

    receiving a reconstruction request message from the user equipment, the reconstruction request message is obtained according to a first operation input on the first user interface, and the first user interface is used to indicate the code structure of the first code project , the code structure includes one or more elements in package, class, class member or underlying code, and the first operation is used to update the code structure of the first code project;

    Refactor the first code project according to the refactoring request message.
13. The method according to claim 12, characterized in that the method further comprises;

    Feedback the reconstructed first code project to the user equipment.
14. The method according to claim 13, wherein the first operation includes one or more of moving, adding, deleting, and editing the element.
15. The method according to any one of claims 12-14, wherein the method further comprises:

    Determining the code architecture bad smell that exists in the first code project;

    Sending first indication information to the user equipment, where the first indication information is used to indicate a code architecture smell existing in the first code project.
16. The method according to claim 15, wherein the code architecture bad smell existing in the first code project corresponds to the element;

    The first user interface is further used to indicate the degree of bad code structure smell in the element through color distinction.
17. The method according to claim 15 or 16, wherein the determining the bad smell of the code architecture in the first code project comprises:

    The code architecture smell in the first code project is determined by using the architecture smell detection model.
18. The method according to any one of claims 13-15, wherein the determining the bad smell of the code architecture existing in the first code project comprises:

    Static code analysis and text similarity calculation are performed on the first code project to obtain the bad smell of the code structure in the first code project.
19. The method according to any one of claims 12-18, wherein the method further comprises:

    Determining a refactoring recommendation, where the refactoring recommendation is used to prompt the user to modify the first code project for the bad smell of the code architecture existing in the first code project;

    Sending the reconstruction recommendation to the user equipment.
20. The method according to any one of claims 12-19, wherein the reconstruction request message includes the atomic reconstruction sequence, and the atomic reconstruction sequence is used to record the operation sequence of modifying and updating the first code project ;

    The refactoring of the first code project according to the refactoring request message includes:

    The first code project is reconstructed according to the atomic reconstruction sequence in the reconstruction request message.
21. The method according to any one of claims 12-20, wherein the atomic reconstruction sequence contains multiple atomic reconstruction operations, and each atomic reconstruction operation contains the identifier of the atomic reconstruction operation and the atomic reconstruction operation Elements in the first code project involved in the construct operation.
22. The method according to any one of claims 12-21, wherein before receiving the reconfiguration request message from the user equipment, the method further comprises:

    receiving indication information of a first code project from the user equipment;

    determining the code structure of the first code project;

    The code structure of the first code project is provided to the user equipment.
23. A code reconstruction system, characterized in that the code reconstruction system includes a user device and a server, wherein;

    The user equipment is configured to present a first user interface, the first user interface is used to indicate a code structure of a first code project, and the code structure includes one or more of a package, a class, a class member, or an underlying code kind of element;

    The user equipment is further configured to receive a first operation input by a user on the first user interface, where the first operation is used to update the code structure of the first code project;

    The user equipment is further configured to send a reconstruction recommendation message to the server, where the reconstruction request message is obtained according to a first operation input on the first user interface;

    The server is configured to receive a reconfiguration request message from the user equipment;

    The server is further configured to refactor the first code project according to the refactoring request message.
24. The system according to claim 23, wherein the server is further configured to feed back the reconstructed first code project to the user equipment;

    The user equipment is further configured to receive the reconstructed first code project provided by the server.
25. The system according to claim 23 or 24, wherein the first operation includes one or more of moving, adding, deleting and editing of the element.
26. The system according to any one of claims 23-25, wherein the server is also used for:

    Determining the code architecture bad smell that exists in the first code project;

    Sending first indication information to the user equipment, where the first indication information is used to indicate a code architecture smell existing in the first code project;

    The user equipment is also used for:

    receiving first indication information from the server;

    A bad code architecture smell existing in the first code project is indicated through the first user interface.
27. The system according to claim 26, wherein the server is further configured to determine a code architecture smell in the first code project by using an architecture smell detection model.
28. The system according to claim 26 or 27, wherein the server is further configured to perform code static analysis and text similarity calculation on the first code project to obtain the code structure in the first code project bad taste.
29. The system according to any one of claims 23-28, wherein the server is also used for:

    Determining a refactoring recommendation, where the refactoring recommendation is used to prompt the user to modify the first code project for the bad smell of the code architecture existing in the first code project;

    sending the reconstruction recommendation to the user equipment;

    The user equipment is also used for:

    receiving the reconstruction recommendation provided by the server;

    The refactoring recommendation is indicated through the first user interface.
30. The system according to any one of claims 23-29, wherein the user equipment is further configured to send second indication information of the first code project to the server;

    The server is further configured to determine the code structure of the first code project;

    The server is further configured to send the code structure of the first code project to the user equipment;

    The user equipment is further configured to receive the code structure of the first code project provided by the server;

    The user equipment is further configured to indicate the code structure of the first code project through the first user interface.
31. A code reconstruction device, characterized in that the code reconstruction device comprises a processing unit and a communication unit, and the code reconstruction device is used to implement the method according to any one of claims 1-11.
32. A code reconstruction device, characterized in that the code reconstruction device includes a processing unit and a communication unit, and the code reconstruction device is used to implement the method described in any one of claims 12-22.
33. A computing device, characterized in that the computing device includes a processor and a memory;

    A computer program is stored in the memory; when the processor executes the computer program, the computing device realizes the method according to any one of claims 1-11, or realizes any one of claims 12-22 the method described.
34. A computer-readable storage medium, characterized in that instructions are stored in the computer-readable storage medium, and when the instructions are run on at least one processor, the method described in any one of claims 1 to 22 is implemented. method.

Images