CN117707580A

CN117707580A - Updating method and device of software system and electronic equipment

Info

Publication number: CN117707580A
Application number: CN202311787864.8A
Authority: CN
Inventors: 张志威; 刘红阳; 许微微; 谢王梅; 周千惠
Original assignee: Hillstone Networks Co Ltd
Current assignee: Hillstone Networks Co Ltd
Priority date: 2023-12-22
Filing date: 2023-12-22
Publication date: 2024-03-15

Abstract

The application discloses a method and a device for updating a software system and electronic equipment. Wherein the method comprises the following steps: creating a first process and a temporary directory corresponding to the software system, wherein the first process is used for detecting the update state of each class file in N class files in the software system, determining the first class file from the N class files according to the first process, determining the updated first class file as a second class file, storing the second class file into the temporary directory, and updating the software system according to the second class file after detecting that a process lock is added to each second process in M second processes corresponding to the software system, wherein the process lock corresponding to each second process is used for prohibiting the second process from executing new system tasks before the software system is updated. The method and the device solve the technical problem of low system development efficiency caused by restarting the system after the class file is modified in the prior art.

Description

Updating method and device of software system and electronic equipment

Technical Field

The present invention relates to the field of software development technologies, and in particular, to a method and an apparatus for updating a software system, and an electronic device.

Background

In the prior art, part of the programming language does not support code hot updates in CLI (Command Line Interface ) mode. For example, the PHP (Hypertext Preprocessor ) language is used as a programming language for a technician to develop a software system, and when the system is started, PHP files are written into a system memory, and then PHP codes are directly read from the memory during the running process of the system. However, in the process of debugging the system by the technician, after the technician modifies the file content of the PHP class file, since the PHP programming language does not support dynamic unloading of the class file, even if the system detects a file update, the system will not reload the updated PHP file to the memory. Therefore, after the system is restarted, the modified PHP file can be validated, thereby causing a problem of long time for a technician to debug the code of the software system.

In addition, in the process of testing or debugging the system by the technician, a long connection (for example, socket or WebSocket) between the client and the software system needs to be established, after the system is restarted, the technician needs to reestablish the long connection between the client and the system, and needs to re-execute preset operation steps, wherein the preset operation steps are used for restoring the system to a state to be debugged in which defects occur, and therefore the problem of low system development efficiency caused by the fact that the technician needs to restart the system after modifying the class file is caused.

In view of the above problems, no effective solution has been proposed at present.

Disclosure of Invention

The application provides a software system updating method and device and electronic equipment, and aims to at least solve the technical problem of low system development efficiency caused by restarting a system after a class file is modified in the prior art.

According to one aspect of the present application, there is provided a method for updating a software system, including: creating a first process and a temporary directory corresponding to the software system, wherein the first process is used for detecting the update state of each class file in N class files in the software system, N is a positive integer, each class file is used for representing attribute information and behavior information of an interaction object corresponding to the software system in a code manner, and the temporary directory is used for storing the updated class files; determining a first class file from N class files according to a first process, wherein the first class file is a class file needing to be updated in the N class files; determining the updated first type of files as second type of files, and storing the second type of files into a temporary directory; after adding a process lock to each of M second processes corresponding to the software system is detected, updating the software system according to the second type file, wherein M is a positive integer, the M second processes are processes for executing system tasks corresponding to the software system, and the process lock corresponding to each second process is used for prohibiting the second process from executing new system tasks before the software system updating is completed.

Optionally, the method for updating the software system further comprises: initializing a target container in a software system, wherein the target container is used for creating and loading objects in the software system, and the objects are used for representing specific examples generated according to class files; after the completion of the initialization of the target container is detected, a corresponding hot update state of the software system is obtained, wherein the hot update state is an open state or a closed state, the open state is used for representing that the second type file is effective before the restart of the software system, and the closed state is used for representing that the second type file is effective after the restart of the software system.

Optionally, the method for updating the software system further comprises: under the condition that the thermal update state is detected to be in an on state, acquiring an effective version corresponding to the software system, wherein the effective version is used for representing version information of class files actually used in the running process of each second process; acquiring a time stamp corresponding to a first type file, an original file and associated information, wherein the time stamp is used for representing the updating time of the first type file, the original file is used for recording file content before updating the first type file, and the associated information is used for representing code information associated with the file content in the original file; and storing the effective version, the timestamp corresponding to the first type file, the original file and the associated information into an array of the software system.

Optionally, the method for updating the software system further comprises: detecting a process state corresponding to each of the M second processes; under the condition that the process state corresponding to any one of the M second processes is detected to be an idle state, switching the process state of the second process from the idle state to a to-be-updated state, wherein a class file used when the second process in the to-be-updated state runs is a class file to be updated; under the condition that the process state corresponding to any one of the M second processes is detected to be the running state, after the system task being executed by the second process is finished, switching the process state of the second process from the running state to the state to be updated; and adding a process lock for any one of the M second processes under the condition that the process state corresponding to the second process is the state to be updated.

Optionally, the method for updating the software system further comprises: splicing the file names corresponding to the first type of files and the time stamps to obtain the file names corresponding to the second type of files, wherein the file names are unique identifiers of the type of files; and storing the second class files into the temporary directory according to the file names corresponding to the second class files.

Optionally, the method for updating the software system further comprises: and updating the effective version corresponding to the software system according to the second type file of the temporary directory.

Optionally, the method for updating the software system further comprises: deleting the corresponding object of the first type file in the target container; creating a target object according to the target container, wherein the target object is an object corresponding to the second type file; detecting whether a callback function exists in the target object, wherein the callback function is used for executing a preset task corresponding to the software system; executing the callback function corresponding to the target object under the condition that the callback function exists in the target object is detected, and updating the associated information according to the target object; under the condition that the target object is detected to have no callback function, updating the associated information according to the target object; after detecting that the associated information update is complete, it is determined that the software system update is complete.

Optionally, the method for updating the software system further comprises: and switching the process state corresponding to each second process in the M second processes from the state to be updated to the updated state, and releasing the process lock corresponding to each second process.

According to another aspect of the present application, there is also provided an updating apparatus of a software system, including: the system comprises a creation unit, a storage unit and a temporary directory, wherein the creation unit is used for creating a first process and a temporary directory corresponding to a software system, the first process is used for detecting the update state of each class file in N class files in the software system, each class file is used for representing attribute information and behavior information of an interaction object corresponding to the software system in a code mode, and the temporary directory is used for storing the updated class files; the first determining unit is used for determining a first type file from N type files according to a first process, wherein the first type file is a type file needing to be updated in the N type files; a second determining unit configured to determine the updated first type file as a second type file, and store the second type file in the temporary directory; and the first updating unit is used for updating the software system according to the second type file after detecting that a process lock is added to each of M second processes corresponding to the software system, wherein M is a positive integer, the M second processes are processes for executing system tasks corresponding to the software system, and the process lock corresponding to each second process is used for prohibiting the second process from executing new system tasks before the software system is updated.

According to another aspect of the present application, there is also provided an electronic device, wherein the electronic device includes one or more processors and a memory for storing one or more programs, wherein the one or more programs, when executed by the one or more processors, cause the one or more processors to implement the method of updating a software system of any of the above.

In the application, a first process and a temporary directory corresponding to a software system are firstly created, wherein the first process is used for detecting an update state of each class file in N class files in the software system, N is a positive integer, each class file is used for representing attribute information and behavior information of an interaction object corresponding to the software system in a code manner, the temporary directory is used for storing updated class files, secondly, the first class files are determined from the N class files according to the first process, the first class files are class files needing to be updated in the N class files, then the updated first class files are determined to be second class files, the second class files are stored in the temporary directory, then, after a process lock is detected to be added to each second process in M second processes corresponding to the software system, the software system is updated according to the second class files, M is a positive integer, the M second processes are processes for executing system tasks corresponding to the software system tasks, and the process lock corresponding to each second process is used for prohibiting the second processes from executing new system tasks before the software system updating is completed.

As can be seen from the foregoing, the present application actually provides a method for performing a hot update on a code of a software system, that is, a first process is used to monitor all class files in the software system, a first class file is determined from N class files corresponding to the software system by using the first process, and the updated first class file is stored in a temporary directory, then, a process lock is added to each of M second processes, so as to avoid a problem of abnormal operation of the software system caused by that the second processes continue to perform a system task in a process of updating the software system, and then, each second process in the software system is updated according to the second class file, that is, the first class file used by each second process lock is updated to the second class file.

Therefore, in the process of debugging the software system by the technical scheme, the aim of frequently restarting the system is achieved, so that the time for debugging the software system by the technical scheme is shortened, the technical effect of improving the efficiency of developing the system by the technical scheme is achieved, and the technical problem of low system development efficiency caused by restarting the system after modifying the class file in the prior art is solved.

Drawings

The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiments of the application and together with the description serve to explain the application and do not constitute an undue limitation to the application. In the drawings:

FIG. 1 is a flow chart of an alternative method of updating a software system according to an embodiment of the present application;

FIG. 2 is a flow chart of an alternative method of adding a process lock according to an embodiment of the present application;

FIG. 3 is a flow chart of an alternative method of updating a software system according to a second type of file according to an embodiment of the present application;

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

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

fig. 6 is a schematic diagram of an alternative electronic device according to an embodiment of the present application.

Detailed Description

In order to make the present application solution better understood by those skilled in the art, the following description will be made in detail and with reference to the accompanying drawings in the embodiments of the present application, it is apparent that the described embodiments are only some embodiments of the present application, not all embodiments. All other embodiments, which can be made by one of ordinary skill in the art based on the embodiments herein without making any inventive effort, shall fall within the scope of the present application.

It should be noted that the terms "first," "second," and the like in the description and claims of the present application and the above figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that embodiments of the present application described herein may be implemented in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

It should be further noted that, the related information (including, but not limited to, attribute information and behavior information of the interaction object corresponding to the software system) and the data (including, but not limited to, data for presentation and data for analysis) related to the application are both information and data authorized by the user or sufficiently authorized by each party. For example, an interface is provided between the system and the relevant user or institution, before acquiring the relevant information, the system needs to send an acquisition request to the user or institution through the interface, and acquire the relevant information after receiving the consent information fed back by the user or institution.

It is to be understood that the description of the various embodiments of the present disclosure emphasizes the differences between the various embodiments, and that the same or similar features may be referred to each other for brevity and will not be repeated.

The present application is further illustrated below in conjunction with various embodiments.

Example 1

According to the embodiments of the present application, there is provided an embodiment of a method for generating application program code, it should be noted that the steps illustrated in the flowcharts of the drawings may be executed in a computer system such as a set of computer executable instructions, and that although a logical order is illustrated in the flowcharts, in some cases, the steps illustrated or described may be executed in an order different from that herein.

The present application provides a method for executing an update method of a software system in a software system (abbreviated as update system), fig. 1 is a flowchart of an alternative method for updating a software system according to an embodiment of the present application, as shown in fig. 1, and the method includes the following steps:

step S101, a first process and a temporary directory corresponding to a software system are created.

In step S101, the first process is configured to detect an update status of each of N class files in the software system, where N is a positive integer, each class file is configured to code attribute information and behavior information of an interaction object corresponding to the software system, and the temporary directory is configured to store the updated class files.

Optionally, the class file is used for recording definition codes of classes in the software system, the classes are abstract descriptions of things in a class, the classes can be used for creating a plurality of similar objects, each object can correspondingly have independent attribute and behavior, the objects contain attribute and method defined by the classes, and the update system can call the method and access attribute defined in the class through the objects.

By way of example, example 1: after the software system is started, the updating system creates a class file monitoring process (namely a first process), and then the updating system stores the updating time and the file path corresponding to each class file in N class files into an associated array A corresponding to the software system, wherein the associated array A is a storage unit corresponding to an array in the software system, the updating system creates a timing task, the associated array A is detected once every a preset time period, whether the updating time of the class files in the associated array A is consistent with the last recorded time is judged, and the last recorded time of the class files is the generation time of the class files or the last recorded time of the modification of the class files.

Optionally, in the case that the update time of the class file in the association array a and the last recorded time are inconsistent, the latest update time of the class file is saved, and the update system sets a preset field (for example, a new update field) in a cache (dis) or a temporary file (for example, a processstatus. Txt) to a preset value (for example, a preset value of 1), records the updated class name through a class name field (for example, a className field), where dis is an open-source memory database, and the dis supports various data structures such as a string, a list, a collection, a hash table, and the like.

Step S102, determining a first class file from the N class files according to the first process.

In step S102, the first class file is a class file that needs to be updated from the N class files.

Optionally, in a state in which the software system starts the hot update function, before determining the first class file from the N class files according to the first process, the stored content in the temporary directory is deleted, i.e. the temporary directory is emptied.

Step S103, the updated first type file is determined to be a second type file, and the second type file is stored in the temporary directory.

Optionally, the updating system renames the updated first type file to obtain a second type file, and then the updating system stores the second type file in the temporary directory, for example, example 2, and then example 1: copying the class file a (i.e. the updated first class file) to the temporary directory, renaming the class file a to be 'the file name of a+the timestamp', obtaining a class file b, and loading the class file b.

Step S104, after detecting that a process lock is added to each of M second processes corresponding to the software system, updating the software system according to the second type file.

In step S104, M is a positive integer, and M second processes are processes for executing system tasks corresponding to the software system, where each process lock corresponding to the second process is used to prohibit the second process from executing new system tasks before the software system is updated.

Optionally, before each second process in the M second processes executes a system task, the update system needs to detect a value corresponding to the needledupdate first, and if the needledupdate is 0, the update system controls the second process to continue executing a new round of system task; and under the condition that the needledUpdate is 1, updating a class file corresponding to a className in a system load cache (Redis) or a temporary file (for example, processStatus. Txt), and modifying the process state of a second process corresponding to the class file corresponding to the className into a state to be updated in the temporary file.

Illustratively, the process state is initialized when each of the M second processes is started and saved in a temporary file, where the temporary file may store the process state by using a Map, for example, a key is a process id, a value of 0 indicates initialization, a value of 1 indicates to be updated, and a value of 2 indicates that updating is completed, but the embodiment of the present application is not limited thereto. All processes need to judge the value corresponding to the newupdate in the updateinfo.txt before executing the task.

Optionally, after each of the M second processes is in a state to be updated, updating a class file used in each second process, after the class file in each second process is updated, switching a process state of each second process in the dis to an updated state (for example, storing a process state of the second process by using a Map, using a key to represent a process id of the second process, and using a value to represent a process state of the second process), setting a newupdate in the dis to 0 after the class file monitoring process judges that all processes are updated, and clearing the Map storing the process state, and then, continuing to execute the system task by the second process.

In an alternative embodiment, the update system first initializes a target container in the software system, wherein the target container is used to create and load objects in the software system, the objects being used to characterize specific instances generated from class files. Then, after the completion of the initialization of the target container is detected, the updating system acquires a thermal updating state corresponding to the software system, wherein the thermal updating state is an on state or an off state, the on state is used for representing that the second type file is effective before the software system is restarted, and the off state is used for representing that the second type file is effective after the software system is restarted.

Optionally, the technical solution of the present application is based on the programming concept of the IOC (Inversion of Control, control inversion), and the call procedure between the object creation and the object is unified to the IOC container (i.e. the target container), and when the software system needs to create an object or obtain an object that has been created, the call procedure must be obtained from the IOC container. Therefore, technicians do not need to pay attention to specific creation and acquisition processes of objects, so that the aim of reducing the coupling degree between design codes of a software system is fulfilled.

In an alternative embodiment, the update system first obtains an effective version corresponding to the software system when the thermal update state is detected to be in an on state, where the effective version is used to characterize version information of class files actually used by each second process in the running process. And then, the updating system acquires a time stamp corresponding to the first type of file, an original file and associated information, wherein the time stamp is used for representing the updating time of the first type of file, the original file is used for recording the file content before the first type of file is updated, and the associated information is used for representing code information associated with the file content in the original file. Then, the update system stores the validated version, the timestamp corresponding to the first type file, the original file and the associated information into an array of the software system.

Example 3, example 2: the updating system records the time stamp corresponding to the first class file into an associated array A, records the original file and the effective version into an associated array B, and records the associated information corresponding to the original file into an array C, wherein the associated information at least comprises subclasses inheriting the original class and codes using the attribute and the method corresponding to the original class, the original class is the class in the original file, and the associated array A, the associated array B and the associated array C are different storage units in the array corresponding to the software system.

In an alternative embodiment, fig. 2 is a flowchart of an alternative process lock addition method according to an embodiment of the present application, as shown in fig. 2, the method including the steps of:

step S201, detecting a process state corresponding to each of the M second processes.

Step S202, when detecting that the process state corresponding to any one of the M second processes is an idle state, switching the process state of the second process from the idle state to a to-be-updated state.

In step S202, the class file used when the second process in the state to be updated runs is the class file to be updated.

In step S203, when it is detected that the process state corresponding to any one of the M second processes is the running state, after the system task being executed by the second process is finished, the process state of the second process is switched from the running state to the to-be-updated state.

Step S204, adding a process lock for any one of the M second processes when detecting that the process state corresponding to the second process is the state to be updated.

Optionally, the update system uses the Redis technology to implement the addition of the process lock, that is, the process state corresponding to each second process is stored to the Redis, and in the case that the first process detects the update of the class file, the update system locks all idle processes (i.e., processes with idle states) in the M second processes, in addition, the update system prohibits processes except the idle processes in the M second processes from executing new system tasks, and then, after each non-idle process completes the current system work, the update system switches the process state corresponding to each second process to the to-be-updated state.

In an alternative embodiment, the update system first splices the file name corresponding to the first type of file with the timestamp to obtain the file name corresponding to the second type of file, wherein the file name is the unique identifier of the type of file, and then the update system stores the second type of file into the temporary directory according to the file name corresponding to the second type of file.

Optionally, the file names of the second type files and the file names of the first type files obtained by the method are different, so that the problem of file name conflict caused by the fact that the first type files before updating exist in the memory after the updated first type files (namely the second type files) are loaded into the memory of the software system is avoided, and the purpose of loading the updated type files into the memory of the software system is achieved.

In an alternative embodiment, the updating system updates the corresponding effective version of the software system according to the second type file of the temporary directory after storing the second type file in the temporary directory.

Example 4, example 3: the update system switches the class in the validated version stored in the associated array B to the class in the newly loaded class file B.

In an alternative embodiment, FIG. 3 is a flowchart of an alternative method of updating a software system according to a second type of file according to embodiments of the present application, as shown in FIG. 3, the method comprising the steps of:

in step S301, the object corresponding to the first type file in the target container is deleted.

Step S302, a target object is created according to the target container, wherein the target object is an object corresponding to the second type file.

Step S303, detecting whether a callback function exists in the target object, wherein the callback function is used for executing a preset task corresponding to the software system.

Optionally, the callback function is a function called when a specific event occurs, and is commonly used for processing asynchronous operations, such as processing user input, network request or timer triggering, through the call of the callback function, a program can execute specific logic when the specific event occurs, so that the expansibility and flexibility of the program are improved.

Step S304, executing the callback function corresponding to the target object and updating the associated information according to the target object under the condition that the callback function exists in the target object.

In step S305, when it is detected that the callback function does not exist in the target object, the association information is updated according to the target object.

Step S306, after detecting that the associated information is updated, determining that the software system is updated.

Optionally, the object in the software system usually exists in the form of a single instance, in order to implement updating of the object, the updating system firstly destroys an original object (that is, an object corresponding to the first type of file) in the IOC container, then creates an object corresponding to the updated type of file, copies an attribute value of the original object to maintain an internal state of a current new object, and then, the updating system judges whether an updateAfter method (corresponding to a callback function in the application) exists in the newly created object, and immediately executes the updateAfter method corresponding to the object in the presence of the updateAfter method.

In addition, the specific steps of updating the associated information according to the target object include: the update system uses the class name of the class in the original file to find the associated class corresponding to the original file from the associated array C, reassigns the instance attribute of the used original class in the associated class according to the object corresponding to the second class file, modifies the parent class of the subclass into the class corresponding to the second class file for the subclass in the associated class, and then updates the subclass.

In an alternative embodiment, the update system switches the process state corresponding to each of the M second processes from the state to be updated to the updated state, and releases the process lock corresponding to each of the second processes.

Optionally, fig. 4 is a flowchart of another alternative method for updating a software system according to an embodiment of the present application, as shown in fig. 4, the method includes the steps of:

after the software system is started, the updating system firstly initializes the IOC container, then the updating system judges whether to start a corresponding hot updating function of the software system, and the normal operation of the software system is maintained under the condition that the hot updating function is not started; under the condition of starting a hot update function, a temporary directory corresponding to the software system is emptied, the update of class files in the software system is monitored, and assuming that the class file a needs to be updated, each process (corresponding to a second process in the application) in the software system waits for executing the current system task before being actually updated, and then a process lock is added for each process in the software system.

Then, the updating system copies the class file a to the temporary directory, renames the class file a as a class file B, loads the class file B to a memory of the software system, modifies the effective version stored in the associated array B to a version corresponding to the class file B, then the updating system destroys an object instance corresponding to the original class a (namely an object corresponding to the first class file) in the IOC container, then the updating system creates a new object according to the class file B, and updates the instance corresponding to the first class file according to the new object.

In addition, the updating system judges whether a new object corresponding to the class file b has an updateAfter method, and under the condition that the updateAfter method exists, the updating system immediately executes the updateAfter method corresponding to the object; under the condition that the updateAfter method does not exist, the updating system performs traversal check on the storage content in the associated array C, and updates the object instance corresponding to the original class a in the associated array C into a new object instance corresponding to the class file b until all the stored associated information in the associated array C is traversed.

Optionally, an optional application scenario based on the PHP-CLI development project according to an embodiment of the present application includes: in the development process based on PHP-CLI mode in the prior art, because the system can stay in the memory and can take effect only by restarting after modifying codes, the debugging of technicians is inconvenient, and the development efficiency of developing software systems by the technicians is reduced.

However, when the technical scheme of the application is adopted, the updating system can automatically detect the updating of the class file, automatically load the new class file to replace the old class file, and replace the instance object corresponding to the old class file in the system memory at the same time.

Optionally, an application scenario of an optional long connection-based system according to an embodiment of the present application includes: in the prior art, because the modification code needs to restart the system to take effect when the PHP programming language is used, when a technician is in joint debugging, the server waits for the client to be reconnected after restarting to perform the next operation, and in certain scenes, a certain function needs to be repeatedly subjected to a plurality of operations for joint debugging test each time, the operation steps are complicated, and after the server is restarted, the connection time set by the client is longer, so that the problems of long joint debugging test time and low joint debugging test efficiency of the technician are caused.

However, when the technical scheme of the application is adopted, the software system does not need to be restarted after the class file is updated, the updating system can automatically load a new class file, the original instance object is replaced by the instance object corresponding to the updated class file, and meanwhile, the updating system can copy the attribute value in the old instance into the new instance, so that the aim of keeping the state before the system updating is fulfilled, the problem that a technician executes complex testing steps after waiting for the system to restart is avoided, the joint debugging testing time of the technician is shortened, and the efficiency of joint debugging testing of the software system is improved.

Optionally, an application scenario of an optional test timing task according to an embodiment of the present application includes: when testing the timing task, after the technician modifies the class file, if the operation result of the timing task needs to be obtained immediately, the triggering interval of the timing task needs to be modified, or the system time needs to be modified, and the operation is complex.

However, when the technical scheme of the application is adopted, after a technician modifies a class file, the system is not required to be restarted, if the operation result of the timing task is required to be immediately acquired, the operation result of the timing task can be directly seen after the system is updated by only calling the updateAfter method in the class file, and the operation steps of the technician are simplified, so that the efficiency of the technician for developing the software system is improved.

Optionally, a Java code hot-updating method in the prior art includes: receiving at least one target class file information of an application program in an operating state, wherein the target class file information comprises: compiling a generated target class file and a unique identifier of the application program by Java code of the application program; establishing connection with the process of the application program according to the unique identification; and calling a redefinaeclaps interface according to the information of the at least one target class file, and respectively replacing the at least one corresponding at least one original class file with the at least one target class file so as to realize Java code hot update of the application program. The Java code hot updating method can compile the modified Java code in jvm without restarting the corresponding application program, shortens the time consumption of updating the Java code and improves the updating efficiency of the Java code.

From the content analysis of the above prior art, it is known that: in the prior art, an original class file is directly replaced by calling a redefinassess interface, and an object is created again after replacement, so that a new object is obtained, however, the object before replacement is an old class instance, the redefinassess interface is a Java language characteristic, PHP language is not applicable, and in addition, in the case that a plurality of processes exist in a system, the processes are not locked when the original class file is replaced, so that the problem of abnormal system operation in the process of code hot update is caused.

However, the technical solution provided in the present application is applicable to an item running based on PHP-CLI mode, and the present solution is based on the IOC container to implement management of objects during program running, and generates a new class file and updates the objects in the IOC container when the file is updated, where the characteristics of the present solution include: under the condition of not restarting the system, the modified PHP file can take effect; objects in the software system must be acquired and created from the IOC container, and class file updating can be automatically performed inside the IOC container, so that external use is not affected; realizing process lock based on Redis, namely waiting for all processes to execute updating operation after finishing the current work, and avoiding the problem of abnormal system operation caused by updating codes in a multi-process environment; in addition, the method also supports the start and stop of the configuration hot update function, and the hot update function is usually started in a development environment and is closed when the software system runs on line, so that the resource consumption of the software system is reduced; in addition, the technical scheme of the application supports the callback function to be executed after the class file is updated, and the attribute value of the object in the current running system can be directly modified or a preset task can be executed by executing the callback function.

In the embodiments of the present application, some or all of the steps and optional implementations thereof may be arbitrarily combined with some or all of the steps in other embodiments, and may also be arbitrarily combined with optional implementations of other embodiments.

Example 2

According to an embodiment of the present application, an embodiment of an updating device (simply referred to as an updating device) of a software system is provided. FIG. 5 is a schematic diagram of an alternative software system update apparatus according to an embodiment of the present application, as shown in FIG. 5, where the software system update apparatus includes: a creation unit 501, a first determination unit 502, a second determination unit 503, and a first update unit 504.

Optionally, the creating unit is configured to create a first process and a temporary directory corresponding to the software system, where the first process is configured to detect an update status of each class file in N class files in the software system, each class file is configured to represent attribute information and behavior information of an interaction object corresponding to the software system in a code manner, and the temporary directory is configured to store the updated class files; the first determining unit is used for determining a first type file from N type files according to a first process, wherein the first type file is a type file needing to be updated in the N type files; a second determining unit configured to determine the updated first type file as a second type file, and store the second type file in the temporary directory; and the first updating unit is used for updating the software system according to the second type file after detecting that a process lock is added to each of M second processes corresponding to the software system, wherein M is a positive integer, the M second processes are processes for executing system tasks corresponding to the software system, and the process lock corresponding to each second process is used for prohibiting the second process from executing new system tasks before the software system is updated.

Optionally, the class file is used for recording definition codes of classes in the software system, the classes are abstract descriptions of things of a class, the classes can be used for creating a plurality of similar objects, each object can correspondingly have independent attribute and behavior, the objects contain attribute and method defined by the class, and the updating device can call the method and access attribute defined in the class through the object.

Optionally, in a state in which the software system starts the hot update function, the update means deletes the stored content in the temporary directory, i.e. clears the temporary directory, before determining the first class file from the N class files according to the first process.

In an alternative embodiment, the updating means of the software system further comprises: an initializing unit and a first acquiring unit.

Optionally, an initializing unit, configured to initialize a target container in the software system, where the target container is used to create and load an object in the software system, and the object is used to characterize a specific instance generated according to the class file; the first obtaining unit is used for obtaining a thermal update state corresponding to the software system after the completion of the initialization of the target container is detected, wherein the thermal update state is an open state or a closed state, the open state is used for representing that the second type file is effective before the restart of the software system, and the closed state is used for representing that the second type file is effective after the restart of the software system.

In an alternative embodiment, the updating means of the software system further comprises: the second acquisition unit, the third acquisition unit and the storage unit.

Optionally, the second obtaining unit is configured to obtain an effective version corresponding to the software system when the thermal update state is detected to be in an on state, where the effective version is used to characterize version information of a class file actually used by each second process in the running process; the third acquisition unit is used for acquiring a time stamp corresponding to the first type of file, an original file and associated information, wherein the time stamp is used for representing the updating time of the first type of file, the original file is used for recording the file content before the updating of the first type of file, and the associated information is used for representing code information associated with the file content in the original file; and the storage unit is used for storing the effective version, the timestamp corresponding to the first type file, the original file and the associated information into an array of the software system.

In an alternative embodiment, the updating means of the software system further comprises: the device comprises a first detection unit, a first switching unit, a second switching unit and an adding unit.

Optionally, the first detection unit is configured to detect a process state corresponding to each of the M second processes; the first switching unit is used for switching the process state of any one of the M second processes from the idle state to the to-be-updated state under the condition that the process state corresponding to the second process is detected to be the idle state, wherein the class file used when the second process in the to-be-updated state runs is the class file to be updated; the second switching unit is used for switching the process state of the second process from the running state to the state to be updated after the system task being executed by the second process is finished under the condition that the process state corresponding to any one of the M second processes is detected to be the running state; and the adding unit is used for adding a process lock for any one of the M second processes under the condition that the process state corresponding to the second process is detected to be the state to be updated.

Optionally, the updating device uses the Redis technology to implement the addition of the process lock, that is, the process state corresponding to each second process is stored to the Redis, and in the case that the first process detects the update of the class file, the updating device locks all idle processes (i.e. processes with idle states) in the M second processes, in addition, processes except the idle processes in the M second processes are prohibited from executing new system tasks, and then, after each non-idle process completes the current system work, the updating device switches the process state corresponding to each second process to the state to be updated.

In an alternative embodiment, the second determining unit comprises: and the splicing subunit and the storage subunit.

Optionally, a splicing subunit is configured to splice a file name and a timestamp corresponding to the first type of file to obtain a file name corresponding to the second type of file, where the file name is a unique identifier of the type of file; and the storage subunit is used for storing the second-class files into the temporary directory according to the file names corresponding to the second-class files.

In an alternative embodiment, the updating means of the software system further comprises: and a second updating unit.

Optionally, the second updating unit is configured to update the effective version corresponding to the software system according to the second type file of the temporary directory.

In an alternative embodiment, the first updating unit comprises: the system comprises a deleting subunit, a creating subunit, a detecting subunit, a first updating subunit, a second updating subunit and an updating finishing subunit.

Optionally, a deleting subunit, configured to delete an object corresponding to the first type file in the target container; the creating subunit is used for creating a target object according to the target container, wherein the target object is an object corresponding to the second type file; the detection subunit is used for detecting whether a callback function exists in the target object, wherein the callback function is used for executing a preset task corresponding to the software system; the first updating subunit is used for executing the callback function corresponding to the target object under the condition that the callback function exists in the target object, and updating the associated information according to the target object; the second updating subunit is used for updating the associated information according to the target object under the condition that the target object is detected to have no callback function; and the updating completion subunit is used for determining that the software system is updated after the completion of the updating of the associated information is detected.

In an alternative embodiment, the updating means of the software system further comprises: and a third switching unit.

Optionally, the third switching unit is configured to switch a process state corresponding to each of the M second processes from a state to be updated to an updated state, and release a process lock corresponding to each of the second processes.

Example 3

According to another aspect of the embodiments of the present application, there is also provided an electronic device, including: a processor; and a memory for storing executable instructions of the processor; wherein the processor is configured to perform the method of updating the software system of any of the above-described embodiments 1 via execution of executable instructions.

Fig. 6 is a schematic diagram of an alternative electronic device according to an embodiment of the present application, and as shown in fig. 6, the embodiment of the present application provides an electronic device, where the electronic device includes a processor, a memory, and a program stored on the memory and capable of running on the processor, and the processor implements the method for updating the software system of any one of the foregoing embodiments 1 when executing the program.

The foregoing embodiment numbers of the present application are merely for describing, and do not represent advantages or disadvantages of the embodiments.

In the foregoing embodiments of the present application, the descriptions of the embodiments are emphasized, and for a portion of this disclosure that is not described in detail in this embodiment, reference is made to the related descriptions of other embodiments.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

In one typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory. The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, etc., such as Read Only Memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. Computer-readable media, as defined herein, does not include transitory computer-readable media (transmission media), such as modulated data signals and carrier waves.

It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, 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, article, 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 an element.

It will be appreciated by those skilled in the art that embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The foregoing is merely exemplary of the present application and is not intended to limit the present application. Various modifications and changes may be made to the present application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc. which are within the spirit and principles of the present application are intended to be included within the scope of the claims of the present application.

Claims

1. A method for updating a software system, comprising:

creating a first process and a temporary directory corresponding to a software system, wherein the first process is used for detecting the update state of each class file in N class files in the software system, N is a positive integer, each class file is used for representing attribute information and behavior information of an interaction object corresponding to the software system in a code manner, and the temporary directory is used for storing the updated class files;

Determining a first class file from the N class files according to the first process, wherein the first class file is a class file which needs to be updated in the N class files;

determining the updated first type of files as second type of files, and storing the second type of files into the temporary directory;

after detecting that a process lock is added to each of M second processes corresponding to the software system, updating the software system according to the second type file, wherein M is a positive integer, the M second processes are processes for executing system tasks corresponding to the software system, and the process lock corresponding to each second process is used for prohibiting the second process from executing new system tasks before the software system updating is completed.

2. The method for updating a software system according to claim 1, wherein before creating the first process and the temporary directory corresponding to the software system, the method for updating a software system further comprises:

initializing a target container in the software system, wherein the target container is used for creating and loading an object in the software system, and the object is used for representing a specific instance generated according to the class file;

And after the completion of the initialization of the target container is detected, acquiring a thermal update state corresponding to the software system, wherein the thermal update state is an open state or a closed state, the open state is used for representing that the second type file is effective before the software system is restarted, and the closed state is used for representing that the second type file is effective after the software system is restarted.

3. The method for updating a software system according to claim 2, wherein after acquiring the corresponding hot update state of the software system, the method for updating a software system further comprises:

acquiring an effective version corresponding to the software system under the condition that the thermal updating state is detected to be the starting state, wherein the effective version is used for representing version information of class files actually used by each second process in the running process;

acquiring a time stamp corresponding to the first type of file, an original file and associated information, wherein the time stamp is used for representing the updating time of the first type of file, the original file is used for recording file content before the first type of file is updated, and the associated information is used for representing code information associated with the file content in the original file;

And storing the effective version, the timestamp corresponding to the first type file, the original file and the associated information into an array of the software system.

4. The method for updating a software system according to claim 1, wherein before updating the software system according to the second type file, the method for updating a software system further comprises:

detecting a process state corresponding to each second process in the M second processes;

under the condition that the process state corresponding to any one of the M second processes is detected to be an idle state, switching the process state of the second process from the idle state to a to-be-updated state, wherein a class file used when the second process in the to-be-updated state runs is a class file to be updated;

when detecting that the process state corresponding to any one of the M second processes is an operation state, after the system task being executed by the second process is finished, switching the process state of the second process from the operation state to the state to be updated;

and adding the process lock for any one of the M second processes under the condition that the process state corresponding to the second process is the state to be updated.

5. The method for updating a software system according to any one of claims 1 to 4, wherein determining the updated first-type file as the second-type file, and storing the second-type file to the temporary directory, comprises:

splicing the file names corresponding to the first type of files and the time stamps to obtain the file names corresponding to the second type of files, wherein the file names are unique identifiers of the type of files;

and storing the second type files into the temporary directory according to the file names corresponding to the second type files.

6. The method for updating a software system according to any one of claims 1 to 4, wherein after storing the second-type file in the temporary directory, the method for updating a software system further comprises:

and updating the effective version corresponding to the software system according to the second type file of the temporary directory.

7. A method of updating a software system according to claim 3, wherein updating the software system in accordance with the second type of file comprises:

deleting the corresponding object of the first type file in the target container;

Creating a target object according to the target container, wherein the target object is an object corresponding to the second type file;

detecting whether a callback function exists in the target object, wherein the callback function is used for executing a preset task corresponding to the software system;

executing a callback function corresponding to the target object under the condition that the callback function exists in the target object, and updating the associated information according to the target object;

under the condition that the callback function does not exist in the target object, updating the associated information according to the target object;

after detecting that the associated information update is complete, determining that the software system update is complete.

8. The method for updating a software system according to claim 4, wherein after updating the software system according to the second type file, the method for updating a software system further comprises:

and switching the process state corresponding to each second process in the M second processes from the state to be updated to the updated state, and releasing the process lock corresponding to each second process.

9. An updating apparatus of a software system, comprising:

the system comprises a creation unit, a storage unit and a storage unit, wherein the creation unit is used for creating a first process and a temporary directory corresponding to a software system, the first process is used for detecting the update state of each class file in N class files in the software system, each class file is used for representing attribute information and behavior information of an interaction object corresponding to the software system in a code manner, and the temporary directory is used for storing the updated class files;

the first determining unit is used for determining a first class file from the N class files according to the first process, wherein the first class file is a class file which needs to be updated in the N class files;

a second determining unit, configured to determine the updated first type file as a second type file, and store the second type file in the temporary directory;

and the first updating unit is used for updating the software system according to the second type file after detecting that a process lock is added to each of M second processes corresponding to the software system, wherein M is a positive integer, the M second processes are processes for executing system tasks corresponding to the software system, and the process lock corresponding to each second process is used for prohibiting the second process from executing new system tasks before the software system is updated.

10. An electronic device comprising one or more processors and a memory for storing one or more programs, wherein the one or more programs, when executed by the one or more processors, cause the one or more processors to implement the method of updating a software system of any of claims 1-8.