CN116820940A - Software system detection method, device, storage medium and equipment - Google Patents
Software system detection method, device, storage medium and equipment Download PDFInfo
- Publication number
- CN116820940A CN116820940A CN202310682481.8A CN202310682481A CN116820940A CN 116820940 A CN116820940 A CN 116820940A CN 202310682481 A CN202310682481 A CN 202310682481A CN 116820940 A CN116820940 A CN 116820940A
- Authority
- CN
- China
- Prior art keywords
- software system
- class
- starting
- target software
- initialization
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000001514 detection method Methods 0.000 title claims abstract description 38
- 238000000034 method Methods 0.000 claims abstract description 47
- 238000005457 optimization Methods 0.000 claims abstract description 18
- 238000004590 computer program Methods 0.000 claims description 11
- 238000012544 monitoring process Methods 0.000 claims description 11
- 238000012545 processing Methods 0.000 abstract description 21
- 230000007547 defect Effects 0.000 abstract description 4
- 230000008569 process Effects 0.000 description 16
- 238000007689 inspection Methods 0.000 description 10
- 238000010586 diagram Methods 0.000 description 9
- 238000004891 communication Methods 0.000 description 7
- 230000006870 function Effects 0.000 description 7
- 125000004122 cyclic group Chemical group 0.000 description 5
- 238000005516 engineering process Methods 0.000 description 5
- 230000009471 action Effects 0.000 description 3
- 230000018109 developmental process Effects 0.000 description 3
- 230000003993 interaction Effects 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 238000005065 mining Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000008439 repair process Effects 0.000 description 2
- 238000009412 basement excavation Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005538 encapsulation Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000000977 initiatory effect Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 238000007639 printing Methods 0.000 description 1
- 230000011664 signaling Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000033772 system development Effects 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The embodiment of the application provides a software system detection method, a device, a storage medium and equipment, wherein in the method, a starting log is acquired based on a starting time point of a target software system, each module type of the target software system is checked according to the starting log, the self-starting initialization of the system is detected by utilizing the starting log, and then optimization information for indicating the failed module type and the type to be optimized is output according to a checking result and a detection result. Therefore, the defects of the target software system are developed in advance through the starting log of the target software system, so that a developer can optimize the system in advance or solve the potential problem of the system, and the processing efficiency of the developer is effectively improved.
Description
Technical Field
The present application relates to the field of code development technologies, and in particular, to a software system detection method, device, storage medium and apparatus.
Background
Based on the software development flow, the system is often required to wait for starting in the self-test process after the system is developed, and part of complex systems occupy more time when being started once, and because the system resources are limited, when the starting occupies the machine resources, the developer is required to wait for the completion of the starting before the subsequent processing. This results in a developer spending more time waiting to affect the processing efficiency.
Disclosure of Invention
The application aims to provide a software system detection method, a device, a storage medium and equipment, and aims to solve the problem that a developer in the related technology needs to spend a great deal of time waiting for system start and influencing the processing efficiency when developing and processing a software system.
In a first aspect, the present application provides a software system detection method, including:
collecting a starting log based on a starting time point of a target software system;
checking each module category of the target software system according to the starting log, and detecting an initializing category of the self-starting of the target software system;
and outputting optimization information according to the checking result and the detection result, wherein the optimization information is used for indicating the module category which fails to be checked and the category to be optimized.
In the implementation process, based on the starting time point of the target software system, a starting log is collected, each module type of the target software system is checked according to the starting log, the starting log is utilized to detect the initialization of the system self-starting, and then the optimization information for indicating the module type which fails to be checked and the type to be optimized is output according to the checking result and the detection result. Therefore, the defects of the target software system are developed in advance through the starting log of the target software system, so that a developer can optimize the system in advance or solve the potential problem of the system, and the processing efficiency of the developer is effectively improved.
Further, in some embodiments, the checking each module class of the target software system according to the start log includes:
counting detail attribution items corresponding to each module category of the target software system;
and according to the starting log, executing each detail belonging item in sequence, and checking whether the detail belonging item with the execution failure exists.
In the implementation process, counting of the minutiae is performed for each module category, intelligent attribution is performed, and by automatically checking whether detail attribution items with execution failure exist or not, a developer is effectively helped to find out problems existing in a starting stage of the system.
Further, in some embodiments, the method further comprises:
and when detecting that the detail attribution item of the execution failure exists, outputting alarm prompt information.
In the implementation process, when the currently executed detail point fails to pass the inspection, the control console outputs alarm prompt information to remind a developer to repair the corresponding problem in time, so that the processing efficiency of the developer is improved.
Further, in some embodiments, the detecting the initialization class of the self-start of the target software system includes:
scanning an initialization class of the self-starting of the target software system, and analyzing whether the initialization class contains a conditional statement or a circulating statement;
if the analysis result is yes, detecting the times and time of executing the conditional statement or the loop statement.
In the implementation process, aiming at the initialization class containing the conditional statement or the cyclic statement, whether the initialization class is reasonable or not is judged through times and time, so that the initialization class which affects the time consumption of starting is accurately mined, and the problem of the current target software system in the aspect of self-starting is effectively discovered.
Further, in some embodiments, the detecting the initialization class of the self-start of the target software system further includes:
detecting whether the initialization class of the self-starting of the target software system contains a target class or not; the target class is the class to be optimized; the target class includes any one of the following:
a class of the read Apollo profile having a volume greater than a preset volume threshold;
and initializing failed implementation classes.
In the implementation process, the class with the volume of the read Apollo configuration file larger than the preset volume threshold and the implementation class with the failed initialization are determined as the class to be optimized, so that the excavation efficiency of the problems existing in the aspect of self-starting of the current target software system is improved.
Further, in some embodiments, the detecting the initialization class of the self-start of the target software system further includes:
monitoring whether the self-started initialization class of the target software system interacts with an external system or not;
if the monitoring result is yes, detecting whether the initialization class depends on the returned result of the external system.
In the implementation process, the initialization class which interacts with the external system and depends on the externally returned result is determined as the class to be optimized, which is beneficial to helping developers optimize the system in advance.
Further, in some embodiments, the target class further includes any one of:
a class associated with the initiated database query;
classes associated with output input operations and underlying services exist.
In the implementation process, from the aspect of memory consumption, the class associated with the initiated database query and the class associated with the output and input operation and the underlying service are also determined as the class to be optimized, so that the mining efficiency of the problems existing in the aspect of self-initiation of the current target software system can be further improved.
In a second aspect, the present application provides a software system detection device, including:
the acquisition module is used for acquiring a starting log based on a starting time point of the target software system;
the detection module is used for checking each module category of the target software system according to the starting log and detecting the self-starting initialization category of the target software system;
and the output module is used for outputting optimization information according to the checking result and the detection result, wherein the optimization information is used for indicating the module category which is failed to be checked and the category to be optimized.
In a third aspect, the present application provides an electronic device, including: a memory, a processor and a computer program stored in the memory and executable on the processor, the processor implementing the steps of the method according to any one of the first aspects when the computer program is executed.
In a fourth aspect, the present application provides a computer readable storage medium having instructions stored thereon which, when run on a computer, cause the computer to perform the method according to any of the first aspects.
In a fifth aspect, the present application provides a computer program product which, when run on a computer, causes the computer to perform the method according to any of the first aspects.
Additional features and advantages of the disclosure will be set forth in the description which follows, or in part will be obvious from the description, or may be learned by practice of the disclosure.
In order to make the above objects, features and advantages of the present application more comprehensible, preferred embodiments accompanied with figures are described in detail below.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the embodiments of the present application will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present application and should not be considered as limiting the scope, and other related drawings can be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flowchart of a software system detection method according to an embodiment of the present application;
FIG. 2 is a schematic diagram of a workflow of a software system self-initiated potential problem detection scheme according to an embodiment of the present application;
FIG. 3 is a block diagram of a software system detection device according to an embodiment of the present application;
fig. 4 is a block diagram of an electronic device according to an embodiment of the present application.
Detailed Description
The technical solutions in the embodiments of the present application will be described below with reference to the accompanying drawings in the embodiments of the present application.
It should be noted that: like reference numerals and letters denote like items in the following figures, and thus once an item is defined in one figure, no further definition or explanation thereof is necessary in the following figures. Meanwhile, in the description of the present application, the terms "first", "second", and the like are used only to distinguish the description, and are not to be construed as indicating or implying relative importance.
As described in the background art, the related art has a problem that a developer needs to spend a lot of time waiting for the system to start up when developing and processing the software system, and the processing efficiency is affected. Based on this, the embodiment of the application provides a software system detection scheme to solve the above problems.
The following describes embodiments of the present application:
as shown in fig. 1, fig. 1 is a flowchart of a software system detection method according to an embodiment of the present application, where the method may be applied to a terminal or a server. The terminal may be a variety of electronic devices including, but not limited to, smartphones, tablet computers, laptop portable computers, desktop computers, and the like; the server may be a single server or a distributed server cluster formed by a plurality of servers. The terminal or server provides an environment for running and analyzing the software system, and the environment comprises a software part and a hardware part, wherein the software part mainly comprises an operating system, such as Windows, linux, and the hardware part mainly comprises computing resources, storage resources, and the like, such as a CPU (Central Processing Unit ), a memory, a hard disk, and the like. It should be noted that the terminal/server may be implemented as a plurality of software or software modules, or may be implemented as a single software or software module, which is not limited by the present application.
The method comprises the following steps:
in step 101, collecting a starting log based on a starting time point of a target software system;
the target software system mentioned in this step may be a software system applied in the field of financial science and technology, such as a credit system, a customer service system, a financial insurance system, etc. Generally, software systems developed in the field of financial science and technology have a plurality of functions and complex service scenes, so that potential problems of system self-starting are more difficult to mine. Of course, the target software system may also be a software system applied to other fields, such as an e-commerce system, a book management system, etc., which is not limited by the present application.
In consideration of related log information of a project which is usually printed in a system starting process, such as a self-starting log of the system, a log added in a program, a log interacted with the outside and the like, in related technologies, a developer needs to wait for the system to be slowly started, including waiting for a console to print the log, but the embodiment of the application can mine potential problems of the system in advance by printing the log through starting time, so that the developer can optimize the system in advance or solve potential faults of the system and the like, and simultaneously shorten the starting time and improve the processing efficiency of the developer.
Specifically, the start log mentioned in this step is a log file for recording events occurring in the start stage of the software system, and in general, starting is time-sequential, so that corresponding logs are collected based on the starting time point of the target software system, and a foundation is laid for subsequent inspection and detection.
Step 102, checking each module class of the target software system according to the starting log, and detecting an initializing class of the self-starting of the target software system;
the module class mentioned in this step is obtained by classifying the modules of the target software system, that is, the code corresponding to the target software system is classified, where the module class may adopt different classification modes according to requirements of different scenes, for example, the module class may include a configuration class, an attribute class, an initialization class, a help class, a service class, and the like, or the module class may include a data layer class, a control layer class, and the like. And the defects of the system can be discovered by checking the corresponding modules according to the content of the log.
In some embodiments, checking the respective module class of the target software system according to the start log mentioned in this step may include: counting detail attribution items corresponding to each module category of the target software system; and according to the starting log, executing each detail belonging item in sequence, and checking whether the detail belonging item with the execution failure exists. That is, for each module class, statistics of minutiae can be performed, intelligent attribution can be performed, and then targeted detection is performed for minutiae attribution items of each module class, one point is performed, if the target software system is normal, all minutiae attribution items of all module classes should be checked to pass, so that by automatically checking whether minutiae attribution items with execution failure exist, a developer can be helped to find problems existing in the system in the starting stage.
Further, in some embodiments, when it is detected that there is a detail home item of the execution failure, an alert prompt is output. That is, when the currently executed detail point is not checked to pass, the control console can output alarm prompt information to remind the developer to repair the corresponding problem in time, so that the processing efficiency of the developer is improved. The alarm prompt information can be displayed in a font format with an alarm effect, such as red alarm prompt information. Of course, in other embodiments, other intelligent marking manners besides outputting the alarm prompt information may be adopted, which is not limited by the present application.
In this embodiment, the initialization Class of the self-start of the target software system is also detected based on the start log, and in the software development, class (Class) is the basis for implementing information encapsulation by Object-oriented programming (OOP, object-Oriented Programming), and each Class includes a function of a data description and a set of operation data or transfer messages. The initialization class mentioned in this step refers to a class that needs to be initialized during the self-starting process of the target software system. The initialization class is detected according to the starting log, and the class which affects the starting time consumption can be detected.
In some embodiments, the detecting the initialization class for the self-start of the target software system mentioned in this step may include: scanning an initialization class of the self-starting of the target software system, and analyzing whether the initialization class contains a conditional statement or a circulating statement; if the analysis result is yes, detecting the times and time of executing the conditional statement or the loop statement. That is, the system self-starting initialization class is monitored, code scanning is carried out on the initialization class, whether if conditional sentences for logic processing and cyclic processing or for cyclic sentences are contained is analyzed, if yes, whether the initialization class is reasonable is judged through the times and time, for example, when an initialization class containing cyclic sentences is analyzed, and the execution times of the cyclic sentences exceed a preset threshold, the fact that the initialization class occupies too much starting time is determined, and the system starting is slow is caused. Therefore, the initialization class which affects the time consumption of starting can be accurately mined, and the problems of the current target software system in the aspect of self-starting can be effectively discovered.
Further, in some embodiments, the detecting the initialization class for the self-start of the target software system mentioned in this step may further include: detecting whether the initialization class of the self-starting of the target software system contains a target class or not; the target class is the class to be optimized; the target class includes any one of the following: a class of the read Apollo profile having a volume greater than a preset volume threshold; and initializing failed implementation classes. That is, the content of the start log is utilized to analyze which initialization classes read the Apollo, which initialization classes read external parameters, static classes, code blocks and the like, and then determine whether the volume of the Apollo configuration file read by the initialization classes is larger than a preset volume threshold according to the initialization classes read by the Apollo, if so, the content is excessive or the content is excessive, and if so, the initialization classes are determined to be target classes, namely, the classes affecting the time-consuming performance of system start; meanwhile, the content of the starting log is utilized to analyze which realization classes needing to be initialized are not initialized, and the realization classes are also determined to be target classes. Thus, the mining efficiency of the problems existing in the self-starting aspect of the current target software system is improved. The preset volume threshold value can be set differently according to the requirements of different scenes, which is not limited by the present application.
In practical applications, the consumption of memory by the system self-starting initialization class may also affect the time consumption of system startup, and thus, in some embodiments, the target class may further include any one of the following: a class associated with the initiated database query; classes associated with output input operations and underlying services exist. That is, whether each initialization class relates to a initiated database query or to an Input/Output (i/o) operation and an underlying service is monitored, if so, it indicates that the corresponding initialization class consumes a large amount of memory, which may result in slow system initiation, and the corresponding initialization class is determined as a target class, thereby providing a developer with a direction of system optimization.
Still further, in some embodiments, detecting the initialization class for the self-start of the target software system mentioned in this step may further include: monitoring whether the self-started initialization class of the target software system interacts with an external system or not; if the monitoring result is yes, detecting whether the initialization class depends on the returned result of the external system. That is, if the monitoring is performed to determine whether the initialization class interacts with the external system or depends on the externally returned result, if the monitoring is performed to indicate that the corresponding initialization class may cause slow system start, the corresponding initialization class may be determined as the class to be optimized.
In step 103, according to the inspection result and the detection result, optimizing information is output, wherein the optimizing information is used for indicating the module category which fails the inspection and the category to be optimized.
In the scheme of the embodiment, the types of the modules which are failed to be checked and the types to be optimized are detected through the starting log of the system, so that optimization information is output, and a developer can optimize the system in advance or solve the potential Bug of the system, so that the working efficiency of the developer is effectively improved. The optimization information may be presented as a list, may be presented as a file, etc., and may be output through a system console, or may be output to a developer through other manners, such as mail, short message, etc., which is not limited in this embodiment; in addition, when all module types pass the inspection and the class to be optimized is not detected, the optimization information can be directly ignored without output, so that the system resources are saved.
According to the embodiment of the application, based on the starting time point of the target software system, a starting log is acquired, each module category of the target software system is checked according to the starting log, the starting log is utilized to detect the initialization of the system self-starting, and then the optimization information for indicating the module category which fails to be checked and the category to be optimized is output according to the checking result and the detection result. Therefore, the defects of the target software system are developed in advance through the starting log of the target software system, so that a developer can optimize the system in advance or solve the potential problem of the system, and the processing efficiency of the developer is effectively improved.
For a more detailed description of the solution of the application, a specific embodiment is described below:
the present embodiment relates to a software system development scenario for a bank. For the software systems of banks, such as credit systems, customer service systems, financial insurance systems and the like, because the related business scenes are complex, the system structure is correspondingly complex, each start usually takes more than ten minutes, and a developer needs to wait for the completion of the system start before carrying out subsequent processing, which results in that the developer needs to consume more time on waiting. Based on this, the present embodiment provides a solution for detecting a potential problem of the software system self-starting, so as to solve the above problem.
The workflow of this scheme is shown in fig. 2, which includes:
s201, respectively acquiring corresponding starting logs based on starting time points of a software system;
s202, sequentially executing detail attribution items of each module category of the software system according to the starting log;
specifically, classifying according to the modules of the software system, and counting the minutiae in each category to obtain the detail attribution of each module category; then, aiming at detail attribution items of each module category, executing the detail attribution items point by point according to the content of the log;
s203, judging whether the detail attribution item which is not checked to pass exists, if yes, executing S212, otherwise, executing S204;
s204, based on the starting log, scanning an initialization class of the self-starting of the software system, judging whether the initialization class contains if sentences or for loop mechanisms respectively used for logic processing and loop processing, if yes, executing S205, otherwise, executing S206;
s205, judging whether the number of times the initialization class executes the corresponding if statement or for circulation mechanism exceeds a preset number threshold or whether the time exceeds a preset time threshold, if so, executing S211, otherwise, executing S206;
s206, judging whether the initialization class reads an Apollo configuration file, if so, executing S207, otherwise, executing S208;
s207, judging whether the file volume of the Apollo configuration file read by the initialization class exceeds a preset volume threshold, if so, executing S211, otherwise, executing S208;
s208, monitoring whether the initialization class interacts with an external system, if so, executing S209, otherwise, executing S210;
s209, judging whether the initialization class depends on a result returned by an external system, if so, executing S211, otherwise, executing S210;
s210, judging whether the initialization class relates to the initiated database connection query or not, or relates to IO operation and underlying service, if yes, executing S211, otherwise, executing S213;
s211, determining the initialization class as a class to be optimized;
s212, outputting optimization information for indicating the detail attribution item which fails to pass the inspection and the class to be optimized;
specifically, aiming at the detail attribution item which fails to pass the inspection, the console performs intelligent marks, such as red alarm prompt information and the like, and aiming at the class to be optimized, the console displays the information of the corresponding class;
s213, ending the flow.
According to the scheme of the embodiment, the characteristic that log information is printed by the console in the starting process of the waiting system is utilized, and the reason for slow system starting is detected through the starting log of the system, so that a developer can optimize the system in advance or solve the potential problem of the system, the working efficiency of the developer is improved, and meanwhile, the starting time can be shortened.
Corresponding to the embodiments of the foregoing method, the present application further provides embodiments of the software system detection device and the terminal to which the software system detection device is applied:
as shown in fig. 3, fig. 3 is a block diagram of a software system detection device according to an embodiment of the present application, including:
the acquisition module 31 is used for acquiring a starting log based on a starting time point of the target software system;
the detection module 32 is configured to check each module class of the target software system according to the start log, and detect an initialization class of the target software system that is self-started;
and an output module 33, configured to output optimization information according to the inspection result and the detection result, where the optimization information is used to indicate a module class that fails the inspection and a class to be optimized.
In some embodiments, the detection module 32 includes an inspection sub-module for:
counting detail attribution items corresponding to each module category of the target software system;
and according to the starting log, executing each detail belonging item in sequence, and checking whether the detail belonging item with the execution failure exists.
In some embodiments, the output module 33 is further configured to:
and when detecting that the detail attribution item of the execution failure exists, outputting alarm prompt information.
In some embodiments, the detection module 32 includes a first detection sub-module for:
scanning an initialization class of the self-starting of the target software system, and analyzing whether the initialization class contains a conditional statement or a circulating statement;
if the analysis result is yes, detecting the times and time of executing the conditional statement or the loop statement.
In some embodiments, the detection module 32 includes a second detection sub-module for:
detecting whether the initialization class of the self-starting of the target software system contains a target class or not; the target class is the class to be optimized; the target class includes any one of the following:
a class of the read Apollo profile having a volume greater than a preset volume threshold;
and initializing failed implementation classes.
In some embodiments, the detection module 32 includes a third detection sub-module for:
monitoring whether the self-started initialization class of the target software system interacts with an external system or not;
if the monitoring result is yes, detecting whether the initialization class depends on the returned result of the external system.
In some embodiments, the target class further includes any one of the following:
a class associated with the initiated database query;
classes associated with output input operations and underlying services exist.
The implementation process of the functions and roles of each module in the above device is specifically shown in the implementation process of the corresponding steps in the above method, and will not be described herein again.
The application further provides an electronic device, please refer to fig. 4, and fig. 4 is a block diagram of an electronic device according to an embodiment of the application. The electronic device may include a processor 410, a communication interface 420, a memory 430, and at least one communication bus 440. Wherein the communication bus 440 is used to enable direct connection communication of these components. The communication interface 420 of the electronic device in the embodiment of the present application is used for performing signaling or data communication with other node devices. The processor 410 may be an integrated circuit chip with signal processing capabilities.
The processor 410 may be a general-purpose processor, including a central processing unit (CPU, central Processing Unit), a network processor (NP, network Processor), etc.; but may also be a Digital Signal Processor (DSP), application Specific Integrated Circuit (ASIC), an off-the-shelf programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components. The disclosed methods, steps, and logic blocks in the embodiments of the present application may be implemented or performed. A general purpose processor may be a microprocessor or the processor 410 may be any conventional processor or the like.
The Memory 430 may be, but is not limited to, random access Memory (RAM, random Access Memory), read Only Memory (ROM), programmable Read Only Memory (PROM, programmable Read-Only Memory), erasable Read Only Memory (EPROM, erasable Programmable Read-Only Memory), electrically erasable Read Only Memory (EEPROM, electric Erasable Programmable Read-Only Memory), and the like. The memory 430 has stored therein computer readable instructions which, when executed by the processor 410, can perform the steps described above in relation to the method embodiments of fig. 1 or fig. 2.
Optionally, the electronic device may further include a storage controller, an input-output unit.
The memory 430, the memory controller, the processor 410, the peripheral interface, and the input/output unit are electrically connected directly or indirectly to each other to realize data transmission or interaction. For example, the elements may be electrically coupled to each other via one or more communication buses 440. The processor 410 is configured to execute executable modules stored in the memory 430, such as software functional modules or computer programs included in the electronic device.
The input-output unit is used for providing the user with the creation task and creating the starting selectable period or the preset execution time for the task so as to realize the interaction between the user and the server. The input/output unit may be, but is not limited to, a mouse, a keyboard, and the like.
It will be appreciated that the configuration shown in fig. 4 is merely illustrative, and that the electronic device may also include more or fewer components than shown in fig. 4, or have a different configuration than shown in fig. 4. The components shown in fig. 4 may be implemented in hardware, software, or a combination thereof.
The embodiment of the application also provides a storage medium, wherein the storage medium stores instructions, and when the instructions run on a computer, the computer program is executed by a processor to implement the method described in the method embodiment, so that repetition is avoided, and no further description is provided here.
The application also provides a computer program product which, when run on a computer, causes the computer to perform the method according to the method embodiments.
In the several embodiments provided in the present application, it should be understood that the disclosed apparatus and method may be implemented in other manners. The apparatus embodiments described above are merely illustrative, for example, of the flowcharts and block diagrams in the figures that illustrate the architecture, functionality, and operation of possible implementations of apparatus, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
In addition, functional modules in the embodiments of the present application may be integrated together to form a single part, or each module may exist alone, or two or more modules may be integrated to form a single part.
The functions, if implemented in the form of software functional modules and sold or used as a stand-alone product, may be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art or in a part of the technical solution, in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a network device, etc.) to perform all or part of the steps of the method according to 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 random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
The above description is only an example of the present application and is not intended to limit the scope of the present application, and various modifications and variations will be apparent to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the protection scope of the present application. It should be noted that: like reference numerals and letters denote like items in the following figures, and thus once an item is defined in one figure, no further definition or explanation thereof is necessary in the following figures.
The foregoing is merely illustrative of the present application, and the present application is not limited thereto, and any person skilled in the art will readily recognize that variations or substitutions are within the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.
It is noted that relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, 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 the element.
Claims (10)
1. A method of software system detection, comprising:
collecting a starting log based on a starting time point of a target software system;
checking each module category of the target software system according to the starting log, and detecting an initializing category of the self-starting of the target software system;
and outputting optimization information according to the checking result and the detection result, wherein the optimization information is used for indicating the module category which fails to be checked and the category to be optimized.
2. The method of claim 1, wherein said checking each module class of said target software system based on said boot log comprises:
counting detail attribution items corresponding to each module category of the target software system;
and according to the starting log, executing each detail belonging item in sequence, and checking whether the detail belonging item with the execution failure exists.
3. The method according to claim 2, wherein the method further comprises:
and when detecting that the detail attribution item of the execution failure exists, outputting alarm prompt information.
4. The method of claim 1, wherein detecting the initialization class for the target software system to self-boot comprises:
scanning an initialization class of the self-starting of the target software system, and analyzing whether the initialization class contains a conditional statement or a circulating statement;
if the analysis result is yes, detecting the times and time of executing the conditional statement or the loop statement.
5. The method of claim 4, wherein detecting the initialization class for the target software system to self-boot, further comprises:
detecting whether the initialization class of the self-starting of the target software system contains a target class or not; the target class is the class to be optimized; the target class includes any one of the following:
a class of the read Apollo profile having a volume greater than a preset volume threshold;
and initializing failed implementation classes.
6. The method of claim 4, wherein detecting the initialization class for the target software system to self-boot, further comprises:
monitoring whether the self-started initialization class of the target software system interacts with an external system or not;
if the monitoring result is yes, detecting whether the initialization class depends on the returned result of the external system.
7. The method of claim 5, wherein the target class further comprises any one of:
a class associated with the initiated database query;
classes associated with output input operations and underlying services exist.
8. A software system detection device, comprising:
the acquisition module is used for acquiring a starting log based on a starting time point of the target software system;
the detection module is used for checking each module category of the target software system according to the starting log and detecting the self-starting initialization category of the target software system;
and the output module is used for outputting optimization information according to the checking result and the detection result, wherein the optimization information is used for indicating the module category which is failed to be checked and the category to be optimized.
9. A computer readable storage medium, characterized in that a computer program is stored thereon, which computer program, when being executed by a processor, implements the method according to any of claims 1 to 7.
10. An electronic device comprising a processor, a memory and a computer program stored on the memory and executable on the processor, wherein the processor implements the method of any one of claims 1 to 7 when the computer program is executed by the processor.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310682481.8A CN116820940A (en) | 2023-06-09 | 2023-06-09 | Software system detection method, device, storage medium and equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310682481.8A CN116820940A (en) | 2023-06-09 | 2023-06-09 | Software system detection method, device, storage medium and equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116820940A true CN116820940A (en) | 2023-09-29 |
Family
ID=88123383
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310682481.8A Pending CN116820940A (en) | 2023-06-09 | 2023-06-09 | Software system detection method, device, storage medium and equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116820940A (en) |
-
2023
- 2023-06-09 CN CN202310682481.8A patent/CN116820940A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110704304B (en) | Application program testing method and device, storage medium and server | |
| US11860721B2 (en) | Utilizing automatic labelling, prioritizing, and root cause analysis machine learning models and dependency graphs to determine recommendations for software products | |
| CN112308126A (en) | Fault recognition model training method, fault recognition device and electronic equipment | |
| CN114168222B (en) | Method and device for acquiring time consumption during starting, terminal equipment and storage medium | |
| CN111045927A (en) | Performance test evaluation method and device, computer equipment and readable storage medium | |
| CN111240876A (en) | Fault positioning method and device for microservice, storage medium and terminal | |
| CN105630656A (en) | Log model based system robustness analysis method and apparatus | |
| CN104715190A (en) | Method and system for monitoring program execution path on basis of deep learning | |
| CN112181430A (en) | Code change statistical method and device, electronic equipment and storage medium | |
| CN113127320B (en) | Application program abnormity detection method, device, equipment and system | |
| CN116820940A (en) | Software system detection method, device, storage medium and equipment | |
| CN107291614B (en) | File abnormity detection method and electronic equipment | |
| CN111193617B (en) | Webpage tampering identification method and device, electronic equipment and storage medium | |
| CN114637685A (en) | Performance test method, device, equipment and medium of application program in bank system | |
| CN112579475A (en) | Code testing method, device, equipment and readable storage medium | |
| CN111752600A (en) | Code anomaly detection method and device, computer equipment and storage medium | |
| CN111339063A (en) | Intelligent management method and device for hypothesis data and computer readable storage medium | |
| CN116483735B (en) | Method, device, storage medium and equipment for analyzing influence of code change | |
| CN115640236B (en) | Script quality detection method and computing device | |
| CN113076540B (en) | Attack detection method and device, electronic equipment and storage medium | |
| CN116467196A (en) | Data verification method, device, storage medium and equipment | |
| CN117032721A (en) | Method for android Gradle construction system | |
| CN116483353A (en) | Module runner generation method, page loading method and device and electronic equipment | |
| CN115510453A (en) | Software security vulnerability analysis method, device, equipment and medium based on cloud computing | |
| CN115878460A (en) | Regression testing method, device, computer equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |