CN116560683A

CN116560683A - Software updating method, device, equipment and storage medium

Info

Publication number: CN116560683A
Application number: CN202310430875.4A
Authority: CN
Inventors: 马刚; 张双双; 张晓平
Original assignee: Lenovo Beijing Ltd
Current assignee: Lenovo Beijing Ltd
Priority date: 2023-04-20
Filing date: 2023-04-20
Publication date: 2023-08-08

Abstract

The embodiment of the application provides a software updating method, device, equipment and storage medium, wherein the method comprises the following steps: responding to a software update request, and analyzing software demand information of software to be updated to obtain demand description information of a target update function; the software updating request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of the target updating function; acquiring historical software demand information of the software to be updated; determining a history related code corresponding to the target update function based on the history software requirement information; determining a target update code corresponding to the target update function based on the history related code and the demand description information; and updating the software to be updated by adopting the target updating code.

Description

Software updating method, device, equipment and storage medium

Technical Field

The embodiments of the present application relate to the field of computer technology, and relate to, but are not limited to, a software updating method, apparatus, device, and storage medium.

Background

With the development of artificial intelligence technology, current artificial intelligence technology (such as Chat GPT) can generate related codes through natural language tools nowadays, but the time spent by developers in actual work is not mainly in writing codes, but is largely spent in reading existing codes and understanding the existing codes.

In the related art, when new functions are developed or old functions are updated to software, a lot of time is required for understanding the structure, logic, implementation, etc. of the existing code. Therefore, when a new code related to a new function or an updated code related to an old function is inserted into a system, it is generally necessary to fully understand an existing code to be able to more quickly combine the code architecture of the existing code and the code architecture of the new code, and thus, how to quickly combine the existing code and the new code is important.

Disclosure of Invention

Based on the problems in the related art, embodiments of the present application provide a method, an apparatus, a device, and a storage medium for updating software.

The technical scheme of the embodiment of the application is realized as follows:

the embodiment of the application provides a software updating method, which comprises the following steps:

responding to a software update request, and analyzing software demand information of software to be updated to obtain demand description information of a target update function; the software updating request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of the target updating function; acquiring historical software demand information of the software to be updated; determining a history related code corresponding to the target update function based on the history software requirement information; determining a target update code corresponding to the target update function based on the history related code and the demand description information; and updating the software to be updated by adopting the target updating code.

An embodiment of the present application provides a software updating apparatus, including:

the analysis module is used for responding to the software update request, analyzing the software demand information of the software to be updated and obtaining the demand description information of the target update function; the software updating request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of the target updating function; the obtaining module is used for obtaining the historical software demand information of the software to be updated; the determining module is used for determining a history related code corresponding to the target updating function based on the history software requirement information; the determining module is further configured to determine a target update code corresponding to the target update function based on the history related code and the requirement description information; and the updating module is used for updating the software to be updated by adopting the target updating code.

In some embodiments, the software to be updated includes a plurality of software functions, and the historical software requirement information includes historical requirement description information for each of the plurality of software functions; the determining module is used for screening historical demand description information corresponding to the target updating function from the historical software demand information; and inquiring a history related code corresponding to the target updating function from a preset database based on the history demand description information of the target updating function.

In some embodiments, the requirement description information of each software function and the corresponding history related code have a preset mapping relation, and the requirement description information of each software function and the corresponding history related code are mapped and then stored in the preset database; the determining module is further configured to query, from the preset database, a history related code corresponding to the target update function based on the mapping relationship of the history requirement description information.

In some embodiments, the apparatus further comprises: the mapping module is used for performing class analysis on the history related code of each software function of the software to be updated to obtain at least one class-level code corresponding to the corresponding software function; performing function level analysis on each class level code to obtain a function level code corresponding to the corresponding class level code; the class level code and the function level code constitute history-related code of the corresponding software function; obtaining requirement description information of each software function; establishing a mapping relation between the history related code of each software function and the requirement description information of the software function; and mapping the history related codes of each software function and the corresponding requirement description information into the preset database.

In some embodiments, the update module is configured to perform a position analysis on the target update code based on the mapping relationship, to obtain a code position corresponding to the target update code; determining an update location of the target update code based on attribute information of the target update code and the code location; and updating the software to be updated by adopting the target updating code based on the updating position.

In some embodiments, after determining a target update code corresponding to the target update function, the apparatus further comprises: a test module for determining at least one test case of the target update code based on the target update function in response to a code test request; calling each test case, and performing unit test on the target updating code to obtain a test result; and if the test result is that the test is not passed, the target updating code is redetermined.

In some embodiments, the apparatus further comprises: the replacing module is used for carrying out function-level grading on the target updating code and determining at least one calling function of the target updating code and a called function corresponding to each calling function; code analysis is carried out on codes in a preset database, and whether the preset database has similar calling functions with the same function as the calling functions or not is determined; if the fact that the preset database comprises similar calling functions with the same function as the calling functions is determined, replacing the calling functions with the similar calling functions; correspondingly, the called function is replaced by a similar called function corresponding to the similar calling function.

The embodiment of the application provides software updating equipment, which comprises the following components: a memory for storing executable instructions; and the processor is used for realizing the software updating method when executing the executable instructions stored in the memory.

The embodiment of the application provides a computer readable storage medium, which stores executable instructions for causing a processor to execute the executable instructions to implement the software updating method.

The software updating method, the device, the equipment and the storage device are used for receiving children, analyzing software requirement information of the software to be updated, and obtaining requirement description information of a target updating function; then, based on the historical software requirement information of the software to be updated, determining a historical related code corresponding to the target updating function; then, determining a target update code corresponding to the target update function based on the history related code and the demand description information; and finally, updating the software to be updated by adopting the target updating code. Therefore, the embodiment of the application can quickly generate the target update code of the target update function through the history related code corresponding to the target update function, and because the history related code belongs to the existing code and is not required to be written again, when the target update code is generated through the history related code, the code architecture of the history related code is not required to be analyzed secondarily, the time required to analyze the history related code is saved, the history related code is not required to be written secondarily, the resources occupied by a computer when the history related code is written are saved, the time required to generate the target update code is reduced to a great extent, and the computer resources occupied by the target update code is reduced, so that the software update time is saved, and the software update efficiency is improved. Meanwhile, a large number of history related codes are adopted to generate the target updating code, and the history related codes are subjected to code checksum code testing before the software to be updated runs, so that secondary checksum secondary testing on the history related codes is not needed when the target updating code is generated, and the accuracy and the system stability of the target updating code can be improved to a certain extent.

Drawings

FIG. 1 is a schematic diagram of a code time consuming duty cycle diagram provided by an embodiment of the present application;

FIG. 2 is a schematic diagram of a software update system according to an embodiment of the present application;

FIG. 3 is a schematic flow chart of a software update method according to an embodiment of the present application;

FIG. 4 is another flow chart of a software update method according to an embodiment of the present application;

fig. 5 is a flow chart of a mapping relation establishment method provided in an embodiment of the present application;

FIG. 6 is a flow chart of a code testing method according to an embodiment of the present disclosure;

fig. 7 is a schematic diagram of a composition structure of a software updating apparatus according to an embodiment of the present application;

fig. 8 is a schematic diagram of a composition structure of a software updating device according to an embodiment of the present application.

Detailed Description

For the purpose of making the objects, technical solutions and advantages of the present application more apparent, the present application will be described in further detail with reference to the accompanying drawings, and the described embodiments should not be construed as limiting the present application, and all other embodiments obtained by those skilled in the art without making any inventive effort are within the scope of the present application.

In the following description, reference is made to "some embodiments" which describe a subset of all possible embodiments, but it is to be understood that "some embodiments" can be the same subset or different subsets of all possible embodiments and can be combined with one another without conflict. Unless defined otherwise, all technical and scientific terms used in the embodiments of the present application have the same meaning as commonly understood by one of ordinary skill in the art to which the embodiments of the present application belong. The terminology used in the embodiments of the present application is for the purpose of describing the embodiments of the present application only and is not intended to be limiting of the present application.

In the related art, when software is updated to be updated, the efficiency of the software update can be generally improved by improving the readability of the code, and when the readability of the code is improved, the following is achieved:

1) Design of code readability and maintainability: when the codes are written, the readability and maintainability of the codes can be improved, so that the codes can be read and understood more quickly and more conveniently. In practical application, the method can be realized by writing clear, concise and modularized codes, using code notes, code documents and the like. 2) Modular design of code: the code is split into a plurality of modules, each module realizes a specific function, so that the code can be split into smaller parts, and the reading burden when the code is read is reduced. 3) Using ancillary tools and techniques: some tools and techniques may be used to assist in reading code, such as code editors, debuggers, code annotation tools, etc., that may more quickly understand and modify code. 4) Establishing good programming specifications and team cooperation mechanisms: the code can be better understood and cooperatively developed by establishing good programming specifications and team cooperation mechanisms, the complexity and difficulty of the code are reduced, and the difficulty of the system in reading and understanding the code is reduced.

However, the above-mentioned related art does not truly solve the problem of a great deal of time and effort that a development team needs to expend when inserting a code into a system, but simply advances many drawbacks when inserting a code to the design and management stage of the code. In order to better understand the time-consuming duty ratio in operation, the embodiment of the present application provides a schematic diagram of an encoding time-consuming duty ratio chart, as shown in fig. 1, fig. 1 respectively shows the time-consuming duty ratio of each item of work when updating the software to be updated, where: the rate of time spent understanding code is about 35%, the rate of time spent encoding related activities is about 10%, the rate of time spent writing code is about 5%, and the rate of time spent non-encoding activities is about 50%.

In the related art, there are the following problems in improving the insertion efficiency of codes: 1) The design of readability and maintainability of the code may require more time and effort to write clear, compact, modular code and use code annotation and code documentation to ensure readability and maintainability of the code. This may lead to an extension of the code development cycle and increased costs. 2) The modular design of code may require more effort to split the code into multiple modules, each of which performs a particular function, requiring more time to lay out the code's structure and logic to ensure code correctness and scalability. This may increase layout time before writing code and the workload when writing code. 3) The use of appropriate tools and techniques may require learning costs, learning the use of code editors, debuggers, code annotation tools, etc. in order to better read and modify the code. This approach may require additional time and effort, as well as additional learning costs. 4) Establishing good programming specifications and team collaboration mechanisms may require more time and effort to coordinate and manage the code development process. This may result in additional management costs and team collaboration challenges.

However, in practical applications, when inserting a code, it is still necessary to understand the structure and logic of the code, and various complex data structures and algorithms involved in the code, which still requires repeated review of the existing code to resist forgetfulness.

Based on at least one of the above problems in the related art, the embodiment of the present application provides a software updating method, which analyzes software requirement information of software to be updated to obtain requirement description information of a target updating function; then, based on the historical software requirement information of the software to be updated, determining a historical related code corresponding to the target updating function; then, determining a target update code corresponding to the target update function based on the history related code and the demand description information; and finally, updating the software to be updated by adopting the target updating code. Therefore, the embodiment of the application can quickly generate the target update code of the target update function through the history related code corresponding to the target update function, and because the history related code belongs to the existing code and is not required to be written again, when the target update code is generated through the history related code, the code architecture of the history related code is not required to be analyzed secondarily, the time required to analyze the history related code is saved, the history related code is not required to be written secondarily, the resources occupied by a computer when the history related code is written are saved, the time required to generate the target update code is reduced to a great extent, and the computer resources occupied when the target update code is generated are reduced, so that the software update time is saved, and the software update efficiency is improved. Meanwhile, a large number of history related codes are adopted to generate the target updating code, and the history related codes are subjected to code checksum code testing before the software to be updated runs, so that secondary checksum secondary testing on the history related codes is not needed when the target updating code is generated, and the accuracy and the system stability of the target updating code can be improved to a certain extent.

An exemplary application of the software updating apparatus according to the embodiment of the present application is described below, where the software updating apparatus provided in the embodiment of the present application may be implemented as a terminal or as a server. In one implementation manner, the software updating device provided in the embodiments of the present application may be implemented as various types of terminals such as a notebook computer, a tablet computer, a desktop computer, a mobile device, and the like; in another implementation manner, the software updating apparatus provided in the embodiments of the present application may be implemented as a server, where the server may be an independent physical server, or may be a server cluster or a distributed system formed by multiple physical servers, or may be a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, content distribution networks (CDN, content Delivery Network), and basic cloud computing services such as big data and artificial intelligence platforms. The terminal and the server may be directly or indirectly connected through wired or wireless communication, which is not limited in the embodiments of the present application. In the following, an exemplary application when the software updating apparatus is implemented as a server will be described.

Turning to fig. 2, fig. 2 is a schematic structural diagram of a software update system according to an embodiment of the present application. The software updating system 20 provided in the embodiment of the present application includes a terminal 100, a network 200, and a server 300, where the server 300 is a server of a software updating application. The server 300 may constitute a software updating device of an embodiment of the present application. The terminal 100 is connected to the server 300 through the network 200, and the network 200 may be a wide area network or a local area network, or a combination of both.

In some embodiments, the terminal may be any software update enabled terminal such as a mobile device (e.g., mobile phone, satellite phone, portable updater, personal digital assistant, dedicated update device, portable update device), notebook computer, tablet computer, desktop computer, etc. The terminal may also be an update device of the software update device. Of course, the terminal may be another type of device or apparatus with a software update function, which is not limited in particular in the embodiment of the present application.

In some embodiments, referring to fig. 2, when software is updated in the software to be updated, the terminal 100 sends a software update request to the server 300 through the network 200, and the server 300 responds to the software update request and analyzes the software requirement information of the software to be updated to obtain the requirement description information of the target update function. The software update request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of a target update function. The server 300 obtains historical software demand information of the software to be updated; then, based on the historical software requirement information, determining a historical related code corresponding to the target updating function; determining a target update code corresponding to the target update function based on the history related code and the demand description information; and finally, updating the software to be updated by adopting the target updating code. After the software update, the server 300 may send the updated software version information to the terminal 100 through the network 200 to implement the update of the software to be updated.

In some embodiments, the terminal 100 may also implement a software update method, that is, the terminal is used as an execution body to analyze the software requirement information of the software to be updated to obtain requirement description information of the target update function; acquiring historical software demand information of software to be updated; then, based on the historical software requirement information, determining a historical related code corresponding to the target updating function; then, determining a target update code corresponding to the target update function based on the history related code and the demand description information; and finally, updating the software to be updated by adopting the target updating code.

The software updating method provided in the embodiment of the present application may also be implemented based on a cloud platform and by using cloud technology, for example, the server 300 may be a cloud server. The method comprises the steps of analyzing software demand information of software to be updated through a cloud server, or determining historical related codes corresponding to target updating functions through the cloud server, or determining target updating codes corresponding to the target updating functions through the cloud server and the like.

In some embodiments, the system may further have a cloud storage, and the historical software requirement information of each of the plurality of software functions of the software to be updated may be stored in the cloud storage, or a mapping relationship between the requirement description information of each software function and the corresponding historical related code may be stored in the cloud storage.

Here, cloud technology (Cloud technology) refers to a hosting technology that unifies serial resources such as hardware, software, and networks in a wide area network or a local area network to implement calculation, storage, processing, and sharing of data. The cloud technology is based on the general names of network technology, information technology, integration technology, management platform technology, application technology and the like applied by the cloud computing business mode, can form a resource pool, and is flexible and convenient as required. Cloud computing technology will become an important support. Background services of technical networking systems require a large amount of computing, storage resources, such as video websites, picture-like websites, and more portals. Along with the high development and application of the internet industry, each article possibly has an own identification mark in the future, the identification mark needs to be transmitted to a background system for logic processing, data with different levels can be processed separately, and various industry data needs strong system rear shield support and can be realized only through cloud computing.

The software updating method provided by each embodiment of the present application may be executed by a software updating device, where the software updating device may be any terminal having software updating and information transmission functions, or may also be a server, that is, the software updating method of each embodiment of the present application may be executed by the terminal, or may also be executed by the server, or may also be executed by the terminal interacting with the server.

Referring to fig. 3, fig. 3 is a schematic flow chart of the software updating method provided in the embodiment of the present application, and as shown in fig. 3, the software updating method 30 includes the following steps S301 to S303:

step S301, responding to a software update request, analyzing software demand information of software to be updated to obtain demand description information of a target update function; the software update request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of the target update function.

In some embodiments, the software to be updated may refer to one or more software in the terminal operating system that needs to be updated with a function, or one or more software in the terminal operating system that needs to be added with a new function, and of course, the software to be updated may also refer to one or more software in the server operating system that needs to be updated with a function, or one or more software in the server operating system that needs to be added with a new function. Here, the operating system may be any operating system that can be run, such as a Windows operating system, a Mac OS system, a Linux system, a UNIX system, a pure DOS system, or the like. Of course, the software to be updated may also be software that operates in other manners, which is not specifically limited in the embodiments of the present application.

In practical application, the software to be updated may be chat type software waiting for updating, shopping type software waiting for updating, or game type software waiting for updating. Of course, the software to be updated may be other types of software or application programs, which are not limited in particular in the embodiments of the present application.

In some embodiments, the software update request is used to request a server to perform a software update operation on the currently to-be-updated software. For example, the software update request may be a request to update the chat interface function of chat software a; the software update request may be a request to update the shopping cart function of shopping software B; the software update request may be a request to update the application mall function of game software C. That is, the software update request may be any software update request, which is not specifically limited in the embodiments of the present application. Correspondingly, the target update function is for requesting

In some embodiments, the software requirement information refers to software requirement content written in natural language. In practical applications, the software requirement information may be represented in the form of a document, such as a product requirement document (PRD, product Requirements Document). In practice, the software requirement information is to refine and refine the software feasibility analysis established during the software planning, analyze various possible solutions, and assign to individual software elements. This is the last step in the software definition phase, which is to determine which tasks the system must do, i.e. to put complete, accurate, clear, specific requirements on the target system.

In some embodiments, the requirement descriptive information is a brief, simple description of the target update function from the perspective of the person (typically the user or client of the system) that is in need of the target update function. They generally follow a simple template: as < type of user >, i want < some goal > in order to achieve < some reason >, i.e. user story. For example, user stories may typically be written on an index card or memo, stored in a shoe box, and arranged on a wall or table to facilitate planning and discussion.

In some embodiments, the function identification refers to a unique function identification for each software function in the software to be updated. That is, the function identifier is used to indicate a function that needs to be updated in the software to be updated. For example, in the real-time communication software, the function identifier may be an identifier of a forwarding function, an identifier of a copy function, an identifier of a delete function, or the like. For example, the function identifier may be included in the software requirement information in the form of text or icons.

Step S302, obtaining the historical software requirement information of the software to be updated.

In some embodiments, the historical software requirement information refers to software requirement content corresponding to other software functions in the software to be updated. The historical software requirement information may include a function identification for each software function.

Step S303, based on the history software requirement information, determining a history related code corresponding to the target updating function.

In some embodiments, the history related code refers to related code corresponding to the history requirement description information, which is used for the software function before the update.

In some embodiments, the preset database may store therein history requirement description information corresponding to each software function, and history update codes corresponding to the history requirement description information. After the server determines the history requirement description information of the target updating function, the server can query a history related code corresponding to the target updating function in a preset database.

Step S304, determining a target update code corresponding to the target update function based on the history related code and the requirement description information.

In some embodiments, the target update code refers to code for updating a target update function.

And step S305, updating the software to be updated by adopting the target updating code.

In the embodiment of the present application, the software to be updated may be updated by using the target update code based on the target update code obtained in step S304, so as to implement the update of the software function.

According to the software updating method provided by the embodiment of the application, software demand information of software to be updated is analyzed, and demand description information of a target updating function is obtained; then, based on the historical software requirement information of the software to be updated, determining a historical related code corresponding to the target updating function; then, determining a target update code corresponding to the target update function based on the history related code and the demand description information; and finally, updating the software to be updated by adopting the target updating code. Therefore, the embodiment of the application can quickly generate the target update code of the target update function through the history related code corresponding to the target update function, and because the history related code belongs to the existing code and is not required to be written again, when the target update code is generated through the history related code, the code architecture of the history related code is not required to be analyzed secondarily, the time required to analyze the history related code is saved, the history related code is not required to be written secondarily, the resources occupied by a computer when the history related code is written are saved, the time required to generate the target update code is reduced to a great extent, and the computer resources occupied by the target update code is reduced, so that the software update time is saved, and the software update efficiency is improved. Meanwhile, a large number of history related codes are adopted to generate the target updating code, and the history related codes are subjected to code checksum code testing before the software to be updated runs, so that secondary checksum secondary testing on the history related codes is not needed when the target updating code is generated, and the accuracy and the system stability of the target updating code can be improved to a certain extent.

Based on the foregoing embodiments, the embodiments of the present application provide a software updating method, which may be executed by a server, referring to fig. 4, and fig. 4 is another flow chart of the software updating method provided by the embodiments of the present application, and will be described with reference to the steps shown in fig. 4.

In step S401, the terminal acquires a software update operation initiated by a user.

In step S402, the terminal encapsulates the software requirement information corresponding to the software update operation into the software update request.

In step S403, the terminal sends a software update request to the server.

In some embodiments, the software update request includes software requirement information for the software to be updated, the software requirement information including a function identification of the target update function.

In step S404, the server responds to the software update request, and analyzes the software requirement information of the software to be updated to obtain the requirement description information of the target update function.

In step S405, the server obtains historical software requirement information of the software to be updated.

In some embodiments, the software to be updated includes a plurality of software functions, and the historical software requirement information includes historical requirement description information for each of the plurality of software functions.

In step S406, the server screens the historical demand description information corresponding to the target update function from the historical software demand information.

In step S407, the server queries the history related code corresponding to the target update function from the preset database based on the history requirement description information of the target update function.

Here, the preset database may store therein history demand description information corresponding to each software function, and history update codes corresponding to the history demand description information. After the server determines the history requirement description information of the target updating function, the server can query a history related code corresponding to the target updating function in a preset database.

In the embodiment of the application, the inclusion relationship between the historical software requirement information and the historical requirement description information is described, that is, when the historical requirement description information is determined, the historical requirement description information can be determined through screening.

In some embodiments, the requirement description information of each software function and the corresponding history related code have a preset mapping relationship, and the requirement description information of each software function and the corresponding history related code are mapped and then stored in a preset database. The above step S407 may also be determined by: the server may query, from a preset database, a history-related code corresponding to the target update function based on the mapping relation of the history demand description information.

In step S408, the server determines a target update code corresponding to the target update function based on the history-related code and the demand description information.

In step S409, the server updates the software to be updated with the target update code.

In some embodiments, the above step S409 may also be determined by:

firstly, the server performs position analysis on the target update code based on the mapping relation to obtain the code position corresponding to the target update code. Next, the server determines an update location of the target update code based on the attribute information of the target update code and the code location. And finally, the server updates the software to be updated by adopting the target update code based on the update position.

In practical applications, the code may be divided into front-end code, back-end code, middleware code, etc. (i.e., database table structure). The location analysis is used to indicate the code location where each code in the target update code is located.

In some embodiments, the attribute information is to distinguish whether the target update code is a front-end code or a back-end code.

In step S410, the server obtains the software version information of the software to be updated.

In step S411, the server transmits the software version information to the terminal.

In the embodiment of the application, firstly, the code position required to be modified is inquired through the selected software interface, the software function corresponding requirement description information and the understanding of the historical software, so that the working efficiency and the working quality of the software update can be improved, the time wasted when the codes are read and the related codes of the historical modification can be reduced, the computer resource occupancy rate can be reduced, the software update time can be saved, and the software update efficiency and quality can be improved. Secondly, generating a target update code of the target update function by combining the requirement description information of the target update function with the historical requirement description information of the software function, programming languages of the historical related codes, referenced class libraries, programming styles and other factors; the target updating code can keep the consistent programming style with the history related code, so that the target updating code can be conveniently inserted into the system and can be operated in cooperation with the history related code. The technical means can reduce the possibility of error occurrence of codes and the possibility of risk during the running of the codes, and can avoid errors and risks caused by human factors, thereby improving the reliability of the codes and the stability of a system. In addition, the server can save the needed computer resources and time consumption for writing the target update codes, and can generate the target update codes of the target update functions according to the structure and logic of the history related codes, thereby reducing the workload for writing the target update codes and reducing the resource occupancy rate.

In some embodiments, after determining the history related code, the server may also establish a mapping relationship between the history related code and the requirement description information of the software function. Based on the foregoing embodiments, the embodiments of the present application provide a mapping relation establishment method, which may be executed by a server, and which may be executed after the foregoing step S303. Referring to fig. 5, fig. 5 is a flowchart of a mapping relation establishment method provided in an embodiment of the present application, and will be described with reference to the steps shown in fig. 5.

In step S501, the server performs class analysis on the history related code of each software function of the software to be updated, to obtain at least one class level code corresponding to the corresponding software function.

In some embodiments, class analysis refers to class-level interpretation of each code in the history-related code, that is, the server analyzes the meaning represented by each class code in class analysis units to be able to obtain at least one class-level code corresponding to the corresponding software function.

In step S502, the server performs function level analysis on each class code to obtain a function level code corresponding to the corresponding class code.

Here, the class-level code and the function-level code constitute history-related code of the corresponding software function.

In some embodiments, function level analysis refers to performing function level interpretation on each code in each class of code, that is, the server analyzes the meaning represented by each function code in function analysis units to be able to obtain the function level code corresponding to the corresponding class of code.

In step S503, the server obtains the requirement description information of each software function.

In step S504, the server establishes a mapping relationship between the history related code of each software function and the requirement description information of the software function.

In step S505, the server maps the history related code and the corresponding requirement description information of each software function to a preset database.

In some embodiments, the server may also establish a mapping relationship between the software interface, the requirement description information, the front end code, the back end code, and the database table, where the mapping relationship may be implemented by the above-mentioned establishing method, or may be implemented by other manners, and the specific establishing process is not specifically limited in the embodiments of the present application.

In the embodiment of the application, the mapping relation between the historical related codes of the software function and the requirement description information of the software function can be established, so that when a server processes a system or code with high complexity, the complex system and code structure can be analyzed and read more quickly according to the preset stored mapping relation, and the working efficiency of the system and code structure with higher processing complexity is improved.

In some embodiments, after determining the target update code corresponding to the target update function, the server may further perform a code test on the target update code determined in the foregoing step to verify the correctness of the target update code. Based on the foregoing embodiments, the present embodiments provide a code testing method, which may be executed by a server, and which may be executed after the above step S304. Referring to fig. 6, fig. 6 is a flowchart of a code testing method according to an embodiment of the present application, and will be described with reference to the steps shown in fig. 6.

In step S601, the server determines at least one test case of the target update code based on the target update function in response to the code test request.

Step S602, the server calls each test case, and performs unit test on the target update code to obtain a test result.

In step S603, if the server determines that the test result is that the test is not passed, the target update code is redetermined.

In some embodiments, the test results may include both cases where the test result is a test pass and the test result is a no pass. And ending the code test process when the test result is that the test passes. At this time, the test result is that the test passes the indication that the currently determined target update codes are correct codes capable of operating normally, and no error codes or operation faults exist. When the test result is that the test fails, the target update code of the target update function needs to be redetermined in response to the test result being that the test fails.

In the embodiment of the application, the server can perform code testing and verification on the target update code so as to ensure the correctness of the target update code and the stability of the whole running system.

In some embodiments, after the server performs code testing on the target update code, the server may further perform code replacement on the code having the same function as the target update code in the preset database, so as to improve the reliability of the target update code. Code substitution that works the same for a function may be achieved by:

first, the server may perform function-level classification on the target update code, and determine at least one calling function of the target update code and a called function corresponding to each calling function. Then, the server analyzes the codes in the preset database to determine whether the preset database has similar calling functions with the same function as the calling functions. And finally, if the server determines that the preset database comprises the similar calling function with the same function as the calling function, replacing the calling function with the similar calling function. Correspondingly, the called function is replaced by a similar called function corresponding to the similar calling function.

In some embodiments, function-level classification refers to performing function-level code analysis on each code in the target update code, and searching the calling function and the called function corresponding to the calling function in the target update code.

In some embodiments, the function is the same, meaning that the calling function a in the target update code and the calling function B in the preset database play the same role in the update process of the software function. For example, the function actions of calling function a and calling function B may be for addition processing, difference processing, variance processing, or the like.

In the embodiment of the application, the server can automatically modify the calling function of the target updating code at the same time, so that the target updating code can be seamlessly inserted and work together with the history related code.

In some embodiments, after the server performs code replacement on the target update code, the server may also perform correlation test on codes with different functions in the target update code (i.e., the codes to be detected in the embodiment). The correlation test of the codes to be detected with different functions can be realized by the following modes:

first, the server obtains a code to be detected in response to a correlation test request. Here, the code to be detected includes code that acts differently from the calling function in the target update code. And then, the server carries out correlation detection on the code to be detected and the historical correlation code to obtain a detection result. If the detection result is that the correlation of part of codes in the codes to be detected is greater than or equal to a preset correlation threshold, combining the part of codes with class-level codes in the historical correlation codes to obtain combined codes, and inserting the combined codes into an updating position to update the software to be updated. If the detection result is that the correlation of the part of codes in the codes to be detected is smaller than the preset correlation threshold value, determining the part of codes as a new class, and storing the new class into a preset database.

In the embodiment of the application, the part of codes with the correlation larger than or equal to the preset correlation threshold value in the codes to be detected can be combined with the historical correlation codes, and the combined codes are subjected to code style standardization processing, so that the combined codes can be conveniently inserted into an updating position, and the software updating efficiency is improved.

In the following, an exemplary application of the embodiments of the present application in a practical application scenario will be described.

The embodiment of the application provides a software updating method, which can quickly generate the target updating code of the target updating function through the history related code corresponding to the target updating function, can reduce the time consumed in generating the target updating code and reduce the computer resources occupied in generating the target updating code, thereby saving the time of software updating and improving the efficiency and quality of software updating. Meanwhile, the embodiment of the application adopts a large amount of history related codes to generate the target updating codes, and can improve the correctness and the system stability of the target updating codes to a certain extent.

And (c): it is necessary to establish an association relationship between the product demand document (PRD, product Requirements Document, i.e., the software demand information in the above embodiment) and the code (i.e., the mapping relationship in the above embodiment), wherein the code is further divided into a front-end code, a back-end code, a middleware code (database table structure), and the like. Meanwhile, the association relationship among the software interface, the user story (i.e. the requirement description information in the above embodiment) and the code is also established.

In some embodiments, the server may establish the association by: 1) PRD and code relation establishment: according to the formal development flow, the PRD is first split into user stories, and software functions are designed and developed according to the user stories. Then, when the written codes are submitted to a code base (i.e., a preset database in the above embodiment), remarks are needed to describe the corresponding user stories of each code implementation. And distinguishing whether the front-end code or the back-end code is realized according to the attribute information of the realization target updating code. 2) Analyzing the submitted target update code: the code role of the object update code is understood and read. Firstly, performing class analysis on target update codes and history related codes of software functions to obtain at least one class-level code corresponding to the corresponding software functions; and then, carrying out function level analysis on each class code to obtain the function level code corresponding to the corresponding class code. Finally, the following association relation is formed: product demand document > user story > class level code > function level code. 3) The software interface is determined by the front-end code, and the relation between the software interface and the front-end code is determined. 4) The front end code can call the back end code, the back end code can call the database table, and the server can establish the association relation through static scanning. 5) In some embodiments, some dynamic calls may not be directly implemented in static code, and associations between codes may be inferred by running a system log recorded when test cases.

The following relationship can be established by the above method: product demand document > user story > class level code > function level code. Software interface > user story > front end code > back end code > database table. Wherein the code needs to be split into class level code and function level code.

Two): and storing the established association relationship into a preset database, such as an elastic search engine (full text), and establishing indexes capable of inquiring each other. The user stories are stored in a vector database for later semantic searching.

Three): when adding the target update function or modifying the software function, the corresponding PRD (i.e. the software requirement information in the above embodiment) needs to be provided, then the PRD is split into a plurality of user stories, the history requirement description information directly related to the target update function is found, and the history related code is queried by using the history requirement description information of the software function. Then, based on the history-related code and the demand description information, a target update code is generated. Finally, it is determined whether the target update function involves a front end code, a back end code, and a database table structure.

Fourth): code testing is carried out on the target updating code so as to test the correctness of the target updating code.

In some embodiments, determining at least one test case of the target update code based on the target update function; calling each test case, and performing unit test on the target updating code to obtain a test result; if the test result is that the test is not passed, the target update code is redetermined.

Fifth): and the verified target update code is interpreted to give class-level analysis and function-level analysis.

Sixth): firstly, searching in all code libraries through function level interpretation to determine whether historical function codes with the same function as the target updating code exist, if so, calling the new function in the target updating code, modifying the calling of the old code, and modifying calling codes and related codes for processing return values.

In some embodiments, the object update code is functionally graded to determine at least one calling function of the object update code and a called function corresponding to each calling function; code analysis is carried out on codes in a preset database, and whether the preset database has similar calling functions with the same function as the calling functions or not is determined; if the fact that the preset database comprises the similar calling function with the same function as the calling function is determined, replacing the calling function with the similar calling function; correspondingly, the called function is replaced by a similar called function corresponding to the similar calling function.

Seventh): and analyzing the function level of the rest codes in the target updating codes, and detecting the correlation with class level interpretation of the searched historical related codes. If the correlation is above the set threshold, the function of the new code is merged with the class of the old code.

In some embodiments, the server obtains the code to be detected in response to a correlation test request. Here, the code to be detected includes code that acts differently from the calling function in the target update code. And then, the server carries out correlation detection on the code to be detected and the historical correlation code to obtain a detection result. If the detection result is that the correlation of part of codes in the codes to be detected is greater than or equal to a preset correlation threshold, combining the part of codes with class-level codes in the historical correlation codes to obtain combined codes, and inserting the combined codes into an updating position to update the software to be updated. If the detection result is that the correlation of the part of codes in the codes to be detected is smaller than the preset correlation threshold value, determining the part of codes as a new class, and storing the new class into a preset database.

In the following, an exemplary application of the embodiments of the present application in another practical application scenario will be described.

In the embodiment of the application, the software system is continuously analyzed by a natural language processing technology to form a corresponding relation library of each interface and the front and back end codes. When the target update function needs to be added or modified, first, the code position needing to be modified is located by selecting a corresponding interface, and the requirement description information of the target update function is described by using natural language. Then, the natural language processing technology is utilized to analyze the demand description information, and the code positions of components (such as front end, back end, database and the like) and the components thereof which are required to be modified for completing the function are automatically determined by combining the existing code library. Then, in combination with the preset code library, a target update code for the target update function is generated. And the newly generated mark updating codes are automatically inserted into corresponding components by utilizing a machine learning algorithm, so that the complexity and the error rate of manual operation are reduced. Then, the old code interface calling the new function is automatically modified, so that the new code can be seamlessly integrated into the original system.

When the modified code is compiled automatically, the machine learning algorithm can automatically detect and solve most compiling errors, so that the workload and development time during software updating are reduced. If a compiling error which cannot be automatically solved occurs, the system prompts a developer to manually solve the compiling error, so that the quality and the correctness of the modified code are ensured. And finally, after the code compiling is passed, automatically updating the corresponding relation library of each interface of the software and the front and back end codes so as to modify the code and add the functions next time. Thus, the system continuously optimizes itself, and improves development efficiency and code quality.

Fig. 7 is a schematic diagram of a composition structure of a software updating apparatus according to an embodiment of the present application, and as shown in fig. 7, a software updating apparatus 700 includes: the analysis module 701 is configured to respond to a software update request, and analyze software requirement information of software to be updated to obtain requirement description information of a target update function; the software updating request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of the target updating function; an obtaining module 702, configured to obtain historical software requirement information of the software to be updated; a determining module 703, configured to determine, based on the historical software requirement information, a history-related code corresponding to the target update function; the determining module 703 is further configured to determine a target update code corresponding to the target update function based on the history related code and the requirement description information; and the updating module 704 is used for updating the software to be updated by adopting the target updating code.

It should be noted that, the description of the apparatus in the embodiment of the present application is similar to the description of the embodiment of the method described above, and has similar beneficial effects as the embodiment of the method, so that a detailed description is omitted. For technical details not disclosed in the embodiments of the present apparatus, please refer to the description of the embodiments of the method of the present application for understanding.

It should be noted that, in the embodiment of the present application, if the software updating method described above is implemented in the form of a software functional module, and sold or used as a separate product, the software updating method may also be stored in a computer readable storage medium. Based on such understanding, the technical solutions of the embodiments of the present application may be essentially or part contributing to the related art, and the computer software product may be stored in a storage medium, including several instructions for causing a terminal to execute all or part of the methods described in the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read Only Memory (ROM), a magnetic disk, an optical disk, or other various media capable of storing program codes. Thus, embodiments of the present application are not limited to any specific combination of hardware and software.

Correspondingly, the embodiment of the present application provides a software updating apparatus, fig. 8 is a schematic structural diagram of the software updating apparatus provided in the embodiment of the present application, and as shown in fig. 8, the software updating apparatus 800 at least includes: a processor 801 and a computer readable storage medium 802 configured to store executable instructions, wherein the processor 801 generally controls the overall operation of the software updating apparatus. The computer-readable storage medium 802 is configured to store instructions and applications executable by the processor 801, and may also cache data to be processed or processed by each module in the processor 801 and the software update apparatus 800, and may be implemented by a FLASH memory (FLASH) or a random access memory (Random Access Memory, RAM).

The present embodiments provide a storage medium having stored therein executable instructions that, when executed by a processor, cause the processor to perform a method provided by the embodiments of the present application, for example, as shown in fig. 3.

In some embodiments, the storage medium may be a computer readable storage medium, such as a ferroelectric Memory (FRAM, ferromagnetic Random Access Memory), read Only Memory (ROM), programmable Read Only Memory (PROM, programmable Read Only Memory), erasable programmable Read Only Memory (EPROM, erasable Programmable Read Only Memory), electrically erasable programmable Read Only Memory (EEPROM, electrically Erasable Programmable Read Only Memory), flash Memory, magnetic surface Memory, optical Disk, or Compact Disk-Read Only Memory (CD-ROM), or the like; but may be a variety of devices including one or any combination of the above memories.

In some embodiments, the executable instructions may be in the form of programs, software modules, scripts, or code, written in any form of programming language (including compiled or interpreted languages, or declarative or procedural languages), and they may be deployed in any form, including as stand-alone programs or as modules, components, subroutines, or other units suitable for use in a computing environment.

As an example, the executable instructions may, but need not, correspond to files in a file system, may be stored as part of a file that holds other programs or data, for example, in one or more scripts in a hypertext markup language (HTML, hyper Text Mar kup Language) document, in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, sub-programs, or portions of code). As an example, executable instructions may be deployed to be executed on one electronic device or on multiple electronic devices located at one site or, alternatively, on multiple electronic devices distributed across multiple sites and interconnected by a communication network.

The foregoing is merely exemplary embodiments of the present application and is not intended to limit the scope of the present application. Any modifications, equivalent substitutions, improvements, etc. that are within the spirit and scope of the present application are intended to be included within the scope of the present application.

It should be appreciated that reference throughout this specification to "one embodiment" or "an embodiment" means that a particular feature, structure or characteristic described in connection with the embodiment is included in at least one embodiment of the present application. Thus, the appearances of the phrases "in one embodiment" or "in an embodiment" in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. It should be understood that, in various embodiments of the present application, the sequence numbers of the foregoing processes do not mean the order of execution, and the order of execution of the processes should be determined by the functions and internal logic thereof, and should not constitute any limitation on the implementation process of the embodiments of the present application. The foregoing embodiment numbers of the present application are merely for describing, and do not represent advantages or disadvantages of the embodiments.

It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element. In the several embodiments provided in this application, it should be understood that the disclosed apparatus and method may be implemented in other ways. The above described device embodiments are only illustrative, e.g. the division of the units is only one logical function division, and there may be other divisions in practice, such as: multiple units or components may be combined or may be integrated into another system, or some features may be omitted, or not performed.

The foregoing is merely an embodiment of the present application, but the protection scope of the present application is not limited thereto, and any person skilled in the art can easily think about changes or substitutions within the technical scope of the present application, and the changes and substitutions are intended to be covered in the protection scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims

1. A method of software updating, the method comprising:

responding to a software update request, and analyzing software demand information of software to be updated to obtain demand description information of a target update function; the software updating request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of the target updating function;

acquiring historical software demand information of the software to be updated;

determining a history related code corresponding to the target update function based on the history software requirement information;

determining a target update code corresponding to the target update function based on the history related code and the demand description information;

and updating the software to be updated by adopting the target updating code.

2. The method of claim 1, the software to be updated comprising a plurality of software functions, the historical software requirement information comprising historical requirement description information for each of the plurality of software functions;

the determining, based on the historical software requirement information, a history-related code corresponding to the target update function includes:

screening historical demand description information corresponding to the target updating function from the historical software demand information;

and inquiring a history related code corresponding to the target updating function from a preset database based on the history demand description information of the target updating function.

3. The method according to claim 2, wherein a predetermined mapping relationship exists between the requirement description information of each software function and the corresponding history related code, and the requirement description information of each software function and the corresponding history related code are mapped and stored in the predetermined database;

the querying, from a preset database, a history related code corresponding to the target update function based on the history demand description information of the target update function includes:

and inquiring a history related code corresponding to the target updating function from the preset database based on the mapping relation of the history demand description information.

4. A method according to claim 3, the method further comprising:

performing class analysis on the history related code of each software function of the software to be updated to obtain at least one class-level code corresponding to the corresponding software function;

performing function level analysis on each class level code to obtain a function level code corresponding to the corresponding class level code; the class level code and the function level code constitute history-related code of the corresponding software function;

obtaining requirement description information of each software function;

establishing a mapping relation between the history related code of each software function and the requirement description information of the software function;

and mapping the history related codes of each software function and the corresponding requirement description information into the preset database.

5. The method of claim 4, the updating the software to be updated with the target update code comprising:

based on the mapping relation, carrying out position analysis on the target updating code to obtain a code position corresponding to the target updating code;

determining an update location of the target update code based on attribute information of the target update code and the code location;

And updating the software to be updated by adopting the target updating code based on the updating position.

6. The method of claim 1, after determining a target update code corresponding to the target update function, the method further comprising:

determining at least one test case of the target update code based on the target update function in response to a code test request;

calling each test case, and performing unit test on the target updating code to obtain a test result;

and if the test result is that the test is not passed, the target updating code is redetermined.

7. The method of claim 1, the method further comprising:

performing function-level classification on the target updating code, and determining at least one calling function of the target updating code and a called function corresponding to each calling function;

code analysis is carried out on codes in a preset database, and whether the preset database has similar calling functions with the same function as the calling functions or not is determined;

if the fact that the preset database comprises similar calling functions with the same function as the calling functions is determined, replacing the calling functions with the similar calling functions;

Correspondingly, the called function is replaced by a similar called function corresponding to the similar calling function.

8. A software updating apparatus, the apparatus comprising:

the analysis module is used for responding to the software update request, analyzing the software demand information of the software to be updated and obtaining the demand description information of the target update function; the software updating request comprises software requirement information of the software to be updated, and the software requirement information comprises a function identifier of the target updating function;

the obtaining module is used for obtaining the historical software demand information of the software to be updated;

the determining module is used for determining a history related code corresponding to the target updating function based on the history software requirement information;

the determining module is further configured to determine a target update code corresponding to the target update function based on the history related code and the requirement description information;

and the updating module is used for updating the software to be updated by adopting the target updating code.

9. A software updating apparatus, comprising:

a memory for storing executable instructions; a processor for implementing the software updating method of any of claims 1 to 7 when executing executable instructions stored in said memory.

10. A computer readable storage medium storing executable instructions for causing a processor to execute the executable instructions to implement the software updating method of any one of claims 1 to 7.