CN117311838A - File processing method, device, equipment and storage medium based on dynamic plug-in - Google Patents
File processing method, device, equipment and storage medium based on dynamic plug-in Download PDFInfo
- Publication number
- CN117311838A CN117311838A CN202210731415.0A CN202210731415A CN117311838A CN 117311838 A CN117311838 A CN 117311838A CN 202210731415 A CN202210731415 A CN 202210731415A CN 117311838 A CN117311838 A CN 117311838A
- Authority
- CN
- China
- Prior art keywords
- plug
- target
- dynamic
- file
- address
- 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
- 238000003672 processing method Methods 0.000 title claims abstract description 28
- 238000011161 development Methods 0.000 claims abstract description 194
- 238000000034 method Methods 0.000 claims abstract description 76
- 238000012545 processing Methods 0.000 claims abstract description 71
- 230000008569 process Effects 0.000 claims abstract description 45
- 230000004044 response Effects 0.000 claims abstract description 10
- 230000007246 mechanism Effects 0.000 claims abstract description 9
- 230000006870 function Effects 0.000 claims description 48
- 238000012360 testing method Methods 0.000 claims description 47
- 238000011990 functional testing Methods 0.000 claims description 22
- 238000001514 detection method Methods 0.000 claims description 13
- 238000004590 computer program Methods 0.000 claims description 12
- 230000003068 static effect Effects 0.000 claims description 12
- 230000001960 triggered effect Effects 0.000 claims description 6
- 238000010586 diagram Methods 0.000 description 21
- 238000004891 communication Methods 0.000 description 5
- 230000006835 compression Effects 0.000 description 5
- 238000007906 compression Methods 0.000 description 5
- 230000003287 optical effect Effects 0.000 description 5
- 230000000694 effects Effects 0.000 description 4
- 230000008859 change Effects 0.000 description 3
- 239000004973 liquid crystal related substance Substances 0.000 description 2
- 239000013307 optical fiber Substances 0.000 description 2
- 230000000644 propagated effect Effects 0.000 description 2
- 239000004065 semiconductor Substances 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000003749 cleanliness Effects 0.000 description 1
- 125000004122 cyclic group Chemical group 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 238000001914 filtration Methods 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
- G06F9/44526—Plug-ins; Add-ons
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The embodiment of the disclosure provides a file processing method, device, equipment and storage medium based on dynamic plug-in, which detect a preset plug-in loading address in the running process of an integrated development tool; if the dynamic plugin is detected, displaying a plugin identifier corresponding to the dynamic plugin in an interface of the integrated development tool, wherein the dynamic plugin is loaded based on Java archive files; and calling the dynamic plug-in to process the target file in response to the triggering instruction aiming at the plug-in identification, and generating a processing result. The dynamic plug-in is arranged at the plug-in loading address, and the plug-in can be dynamically loaded through a Java archive file loading mechanism of Java, so that the dynamic plug-in can be called under the condition that an integrated development tool is not restarted, the processing of a target file is completed, the time consumption of the plug-in loading process is shortened, and the working efficiency of calling the plug-in for file processing in the integrated development tool is improved.
Description
Technical Field
The embodiment of the disclosure relates to the technical field of Internet, in particular to a file processing method, device and equipment based on dynamic plug-in, and a storage medium.
Background
An integrated development tool, also called an integrated development environment (Integrated Development Environment, IDE), is an application program for providing a program development environment, and is generally composed of a code editor, a debugger, a graphical user interface, and the like. The integrated development tool is operated based on the terminal equipment, and a series of functions such as code writing, analysis and compiling can be realized, so that the development of a software program is realized.
In the prior art, on the basis of an integrated development tool, various personalized requirements in the software development process can be realized by loading functional plug-ins, however, after the functional plug-ins in the prior art are loaded in the basic development tool, the integrated development tool needs to be restarted to be effective, so that the problems of long time consumption and low use efficiency of loading the functional plug-ins in the integrated development tool are caused.
Disclosure of Invention
The embodiment of the disclosure provides a file processing method, device, equipment and storage medium based on a dynamic plug-in, so as to solve the problem that the integrated development tool can be validated only by restarting the functional plug-in the prior art after the functional plug-in is loaded in a basic development tool.
In a first aspect, an embodiment of the present disclosure provides a method for processing a file based on a dynamic plug-in, including:
Detecting a preset plug-in loading address in the running process of the integrated development tool; if the dynamic plugin is detected, displaying a plugin identifier corresponding to the dynamic plugin in an interface of an integrated development tool, wherein the dynamic plugin is loaded based on Java archive files; and responding to a trigger instruction aiming at the plug-in identification, calling the dynamic plug-in to process the target file, and generating a processing result.
In a second aspect, an embodiment of the present disclosure provides a file processing apparatus based on a dynamic plug-in, including:
the detection module is used for detecting a preset plug-in loading address in the running process of the integrated development tool;
the display module is used for displaying a plug-in identifier corresponding to the dynamic plug-in an interface of the integrated development tool if the dynamic plug-in is detected, and the dynamic plug-in is loaded based on Java archive files;
and the processing module is used for calling the dynamic plug-in to process the target file in response to the triggering instruction aiming at the plug-in identification and generating a processing result.
In a third aspect, an embodiment of the present disclosure provides an electronic device, including:
a processor, and a memory communicatively coupled to the processor;
the memory stores computer-executable instructions;
The processor executes the computer-executable instructions stored in the memory to implement the dynamic plug-in based file processing method as described above in the first aspect and the various possible designs of the first aspect.
In a fourth aspect, embodiments of the present disclosure provide a computer readable storage medium having stored therein computer executable instructions that when executed by a processor implement a dynamic plug-in based file processing method as described in the first aspect and the various possible designs of the first aspect.
In a fifth aspect, embodiments of the present disclosure provide a computer program product comprising a computer program which, when executed by a processor, implements the dynamic plug-in based file processing method according to the first aspect and the various possible designs of the first aspect.
According to the file processing method, device, equipment and storage medium based on the dynamic plug-in, the preset plug-in loading address is detected in the running process of the integrated development tool; if the dynamic plugin is detected, displaying a plugin identifier corresponding to the dynamic plugin in an interface of an integrated development tool, wherein the dynamic plugin is loaded based on Java archive files; and responding to a trigger instruction aiming at the plug-in identification, calling the dynamic plug-in to process the target file, and generating a processing result. The dynamic plug-in is arranged at the plug-in loading address, and the plug-in can be dynamically loaded through a Java archive file loading mechanism of Java, so that the dynamic plug-in can be called under the condition that an integrated development tool is not restarted, the processing of a target file is completed, the time consumption of the plug-in loading process is shortened, and the working efficiency of calling the plug-in for file processing in the integrated development tool is improved.
Drawings
In order to more clearly illustrate the embodiments of the present disclosure or the solutions in the prior art, a brief description will be given below of the drawings that are needed in the embodiments or the description of the prior art, it being obvious that the drawings in the following description are some embodiments of the present disclosure, and that other drawings may be obtained from these drawings without inventive effort to a person of ordinary skill in the art.
FIG. 1 is an application scenario diagram of a dynamic plug-in based file processing method provided in an embodiment of the present disclosure;
FIG. 2 is a flowchart illustrating a method for processing a file based on a dynamic plug-in according to an embodiment of the present disclosure;
FIG. 3 is a flowchart of a specific implementation of step S101 in the embodiment shown in FIG. 2;
FIG. 4 is a schematic diagram of an interface of an integrated development tool provided by an embodiment of the present disclosure;
FIG. 5 is a schematic interface diagram of another integrated development tool provided by an embodiment of the present disclosure;
FIG. 6 is a flowchart of a specific implementation of step S103 in the embodiment shown in FIG. 2;
FIG. 7 is a second flow chart of a method for processing a file based on a dynamic plug-in according to an embodiment of the present disclosure;
FIG. 8 is a schematic diagram of a development project-based storage target plugin provided by an embodiment of the present disclosure;
FIG. 9 is a flowchart illustrating a method for processing a file based on a dynamic plug-in according to an embodiment of the present disclosure;
FIG. 10 is a schematic diagram of a display function test plug-in provided by an embodiment of the present disclosure;
FIG. 11 is a block diagram of a dynamic plug-in based file processing apparatus according to an embodiment of the present disclosure;
fig. 12 is a schematic structural diagram of an electronic device according to an embodiment of the disclosure;
fig. 13 is a schematic hardware structure of an electronic device according to an embodiment of the disclosure.
Detailed Description
For the purposes of making the objects, technical solutions and advantages of the embodiments of the present disclosure more apparent, the technical solutions of the embodiments of the present disclosure will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present disclosure, and it is apparent that the described embodiments are some embodiments of the present disclosure, but not all embodiments. All other embodiments, which can be made by one of ordinary skill in the art without inventive effort, based on the embodiments in this disclosure are intended to be within the scope of this disclosure.
The application scenario of the embodiments of the present disclosure is explained below:
fig. 1 is an application scenario diagram of a dynamic plug-in based file processing method provided by an embodiment of the present disclosure, where the dynamic plug-in based file processing method provided by the embodiment of the present disclosure may be applied to a scenario of application program development. More specifically, the method and the device can be applied to the application scene of distributed development of the application program. The method provided by the embodiment of the disclosure can be applied to terminal equipment, such as a personal computer. And the developer user performs program development on one functional module in the target application through an integrated development tool running in the terminal equipment, and uploads the code file and library file generated after development to a code warehouse in the cloud server. As shown in fig. 1, a developer user develops an a function module in a target application program based on terminal equipment a, and uploads a corresponding code file to a code warehouse of a server; the developer user develops the B function module in the target application program based on the terminal equipment B and uploads the corresponding code file to the code warehouse of the server, and the terminal equipment C develops the C function module in the target application program and uploads the corresponding library file to the code warehouse of the server. Based on the above process, a plurality of developer users commonly realize the development of the target application program.
Based on the above application scenario of distributed development, when the developer user develops the functional module through the integrated development tool, different developer users (based on the terminal device) correspond to the development tasks of different functional modules, for example, user a develops the image processing functional module in the target application through the integrated development tool, and user B develops the network communication functional module in the target application through the integrated development tool. Further, in the process of developing different functional modules, due to the difference of the functional modules, personalized development requirements are correspondingly generated, for example, in the process of developing the image processing functional modules, the function of image compression is required to be used for performing function implementation or function test; in the process of developing a network communication function module, a function of signal filtering is required to be used for performing function implementation or function test.
In the prior art, the personalized function requirement can be achieved by preloading the function plug-ins in the integrated development tool, however, after the function plug-ins in the prior art are loaded in the integrated development tool, the integrated development tool needs to be restarted to be effective, because the function plug-ins are loaded in the prior art in a static loading mode, namely, based on a preset loading address, all plug-ins under the loading address are preloaded when the integrated development tool is started. The preloaded plug-ins can then be invoked in the integrated development tool. However, when a new plug-in is required to be added, after the plug-in package is imported into the preset loading address, the integrated development tool does not detect the plug-in package and display the plug-in package, and the plug-in package must be restarted, and after the pre-loading process, the newly added plug-in package can be displayed and called as required. This results in the problems of long time consuming and inefficient use of the loading of functional plug-ins in the integrated development tool. The embodiment of the disclosure provides a file processing method based on a dynamic plug-in to solve the problems.
Referring to fig. 2, fig. 2 is a schematic flow chart of a file processing method based on dynamic plug-in according to an embodiment of the disclosure. The method of the embodiment can be applied to terminal equipment, and the file processing method based on the dynamic plug-in comprises the following steps:
step S101: and detecting a preset plug-in loading address in the running process of the integrated development tool.
An integrated development tool, also referred to as an integrated development environment, is an application program for providing a program development environment, for example. More specifically, for example, the basic development tool in this embodiment may display a graphical user interface of the integrated development tool for the IDEA terminal device after running the integrated development tool, and the developer user performs program development based on the integrated development tool through the operation terminal. After the integrated development tool operates, the terminal device scans the plug-in loading address in real time, so that a file under the plug-in loading address is detected. The plug-in loading address is a preset local storage address or network storage address, and the setting of the plug-in loading address can be realized through a configuration file or configuration information. In one possible implementation, as shown in fig. 3, the specific implementation of step S101 includes:
Step S1011: and loading configuration information, wherein the configuration information is used for indicating a target plug-in address for storing the target dynamic plug-in, and the target plug-in address is positioned at a first server communicated with the terminal equipment.
Step S1012: and detecting the target plug-in address according to the configuration information.
For example, in an application scenario of multi-terminal collaborative development, a developer user can develop a required dynamic plug-in, namely a target dynamic plug-in, in a targeted manner based on own development tasks. For example, for the development task of the image processing functional module, a developer user develops an image compression plug-in based on an integrated development tool; aiming at the development task of the video playing function module, a developer user develops a video plug-in based on an integrated development tool. The image compression plug-in (and other plug-ins belonging to the image processing functional module) corresponds to the plug-in address addr_1; video plug-in (and other plug-ins belonging to the video playing function module) corresponds to the plug-in address addr_2. The configuration information is information for indicating the plug-in address, that is, according to the configuration information, addr_1 or addr_2 may be selected as the target plug-in address, so as to detect a plug-in (an image compression plug-in or a video plug-in frame plug-in) under the target plug-in address.
In this embodiment, by loading configuration information and detecting the corresponding target plug-in address according to the configuration information, classified loading of dynamic plug-ins of different types can be achieved, so that corresponding dynamic plug-ins are loaded under different development tasks, accuracy of plug-in loading is improved, interface cleanliness of an integrated development tool is improved, and excessive unclassified plug-ins are prevented from being loaded, and the display effect of plug-in identification is prevented from being affected.
Step S102: and if the dynamic plugin is detected, displaying a plugin identifier corresponding to the dynamic plugin in an interface of the integrated development tool, wherein the dynamic plugin is loaded based on the Java archive file.
For example, after the plug-in loading address is detected, if the plug-in file exists under the plug-in loading address, the plug-in identifier corresponding to the dynamic plug-in is displayed on an interface (i.e. a graphical user interface) of the integrated development tool. The plug-in identifier may include at least one of a serial number, a text, and an icon, for example. The plug-in identifier corresponding to the dynamic plug-in may be a file name of a plug-in file corresponding to the dynamic plug-in, or a picture included in the plug-in file after the plug-in file is decompressed.
The plug-in file corresponding to the dynamic plug-in is a Java Archive (Jar), that is, a file with Jar as an extension (or a file with Zip as an extension). Java archive files are typically used to aggregate a large number of Java class files, associated metadata and resource (text, picture, etc.) files into one file in order to develop Java platform applications or libraries, in this embodiment, the functionality of the dynamic plug-ins is implemented by the corresponding Java archive files.
Further, in one possible implementation manner, the method for judging the detection of the dynamic plugin includes: if the file name of the file under the loading address of the plug-in is detected to meet the preset naming requirement, the dynamic plug-in is determined to be detected. Specifically, for example, if it is detected that a file (Jar package) with Jar as an extension is included under the plug-in loading address, the Jar package is determined to be a dynamic plug-in; in another possible implementation manner, the method for judging the detection of the dynamic plugin includes: if the file under the loading address of the plug-in is detected to meet the preset naming requirement, verifying the file content of the file, and if the file passes the verification, determining that the dynamic plug-in is detected.
Optionally, the interface of the integrated development tool includes a first plug-in area and a second plug-in area, wherein the first plug-in area is used for displaying preloaded static plug-ins, and the second plug-in area is used for displaying dynamic plug-ins.
Fig. 4 is an interface schematic diagram of an integrated development tool according to an embodiment of the present disclosure, where, as shown in fig. 4, an interface of the integrated development tool includes a first plug-in area and a second plug-in area that are located in different areas, and the first plug-in area and the second plug-in area can be simultaneously displayed in the interface of the integrated development tool. The first plug-in area is used for displaying a preloaded static plug-in, namely, plug-in identification, such as an icon, a plug-in name and the like, of the plug-in loaded by the integrated development tool in a traditional preloading mode. The static plug-in displayed in the first plug-in area is loaded when the integrated development tool is started, so that even if a new plug-in file is stored in a preset address corresponding to the static plug-in during the operation of the integrated development tool, the static plug-in displayed in the first plug-in area cannot be updated, and only after the integrated development tool is restarted, the static plug-in displayed in the first plug-in area can be updated. And the second plug-in area is used for displaying the dynamic plug-in, namely the plug-in corresponding to the plug-in loading address, and when the files in the plug-in loading address change, the corresponding real-time display of the dynamic plug-in is realized in the second plug-in area, for example, the plug-in identification is newly added and deleted, so that the dynamic display of the dynamic plug-in is realized.
FIG. 5 is a schematic diagram of an interface of another integrated development tool according to an embodiment of the present disclosure, where, as shown in FIG. 5, the interface of the integrated development tool includes a first plug-in area and a second plug-in area that are located in the same (or similar) area, and the first plug-in area and the second plug-in area may alternatively be displayed in the interface of the integrated development tool through, for example, a switching bar as exemplarily shown in the drawings. As shown in fig. 5, when the left side of the switching bar is clicked, a first plug-in area is displayed; when the right side of the switching bar is clicked (not shown in the figure), the second plug-in area is displayed at the same position, so that the static plug-in and the dynamic plug-in are respectively displayed. The specific functions of the first card area and the second card area are the same as those described in fig. 4, and will not be described herein.
Step S103: and calling the dynamic plug-in to process the target file in response to the triggering instruction aiming at the plug-in identification, and generating a processing result.
For example, referring to the interface schematic diagram of the integrated development tool shown in fig. 4 or fig. 5, after the plug-in identifier is displayed in the interface of the integrated development tool through the plug-in area, the user triggers the plug-in identifier through the man-machine interaction unit of the terminal device, such as a touch screen and a mouse, so as to generate a trigger instruction for the plug-in identifier. And then, responding to a triggering instruction aiming at the plug-in identification, calling an execution function corresponding to the dynamic plug-in to execute a corresponding method to process the target file, and generating a processing result. For example, the target file is a picture, and the dynamic plug-in is used for compressing the picture to generate a compressed picture.
In one possible implementation, as shown in fig. 6, the specific implementation of step S103 includes:
step S1031: and acquiring Java archive files corresponding to the dynamic plug-ins.
Step S1032: and loading the Java archive file to a Java virtual machine based on a Java class loading mechanism, and running the function class corresponding to the dynamic plug-in.
Step S1033: and processing the target file based on the function class corresponding to the dynamic plug-in, and generating a processing result.
After the plug-in identifier of the dynamic plug-in is displayed, the dynamic plug-in only displays (identifier) without loading and calling, then, a corresponding Jar package is obtained in response to a trigger instruction for the plug-in identifier corresponding to the dynamic plug-in, the Jar package is loaded to a virtual machine based on a Java class loading mechanism, a function class corresponding to the dynamic plug-in is operated based on the content in the Jar package, the method specifically comprises the steps of instantiating the function class and calling the corresponding instance, and the target file is processed as input in the process, so that the process of processing the target file through the dynamic plug-in is completed. The class instantiation based on Java and the corresponding instance method call may be set based on a specific function class, which will not be described herein.
In the embodiment, a preset plug-in loading address is detected in the running process of the integrated development tool; if the dynamic plugin is detected, displaying a plugin identifier corresponding to the dynamic plugin in an interface of the integrated development tool, wherein the dynamic plugin is loaded based on Java archive files; and calling the dynamic plug-in to process the target file in response to the triggering instruction aiming at the plug-in identification, and generating a processing result. The dynamic plug-in is arranged at the plug-in loading address, and the plug-in can be dynamically loaded through a Java archive file loading mechanism of Java, so that the dynamic plug-in can be called under the condition that an integrated development tool is not restarted, the processing of a target file is completed, the time consumption of the plug-in loading process is shortened, and the working efficiency of calling the plug-in for file processing in the integrated development tool is improved.
Referring to fig. 7, fig. 7 is a second flowchart of a file processing method based on a dynamic plug-in according to an embodiment of the disclosure. This embodiment describes in further detail the process of generating a dynamic plug-in and configuring the dynamic plug-in before step S101, based on the embodiment shown in fig. 2, and the file processing method based on the dynamic plug-in includes:
Step S201: a target plug-in is generated.
In this embodiment, the target plug-in is a plug-in with a special function generated by a developer user by inputting code instructions based on needs during the development task. Specifically, the implementation method for generating the target plugin comprises the following steps: the terminal equipment receives the code instruction and generates a code file for realizing the target function; and the terminal equipment receives the compression instruction, compresses at least one code file, generates a Java archive file and obtains a target plug-in.
Step S202: development project information is obtained, which characterizes development projects established through the integrated development tool.
Step S203: and storing the target plug-in to a plug-in loading position corresponding to the development project information.
After generating the target plugin, the target plugin is stored under a plugin loading address, and the terminal device detects the plugin loading address, so that a target plugin identifier corresponding to the target plugin is dynamically displayed. In this embodiment, the plug-in loading address is dynamically determined based on the development project information. Specifically, in the process of developing the target application through the integrated development tool, a development Project (Project) needs to be established first, then corresponding function development is performed for different development projects, and corresponding Project development files are stored under corresponding Project addresses. In different integrated development tools, the expression modes of the development projects may be different, but specific implementation of building the development projects and performing corresponding function development based on the development projects is the prior art, and will not be described herein.
Further, in this embodiment, after generating the target plugin, the terminal device reads development project information that characterizes the content of the development project, where the development project information includes, for example, a project address of the corresponding development project and description information related to the development project, and then stores the target plugin to a plugin loading location under the project address corresponding to one or more development projects therein based on the development project information. Fig. 8 is a schematic diagram of storing a target plug-in based on a development project according to an embodiment of the present disclosure, as shown in fig. 8, after the target plug-in is obtained, it is determined, through development project information, that a development project established through an integrated development tool includes a development project #1, a development project #2, and a development project #3. Then, based on a user instruction or on description information for each development project in the development project information, storing the target plug-in to a plug-in loading position addr_1 under a project address corresponding to the development project #1, and storing the target plug-in to a plug-in loading position addr_2 under a project address corresponding to the development project # 2.
In the embodiment, through development project information, the developed target plugin is stored to the plugin loading position under the corresponding project address, so that the binding of the target plugin and the matched development project is realized, different dynamic plugins can be correspondingly displayed in the interface of the integrated development tool when different development projects are operated in the subsequent process of loading the dynamic plugin, the accurate display of the dynamic plugin is realized, the problem of excessive plugins caused by indistinguishable display of the dynamic plugin in the interface of the integrated development tool is avoided, and the efficiency of the integrated development tool is improved.
Step S204: and in the running process of the integrated development tool, acquiring a target development project currently loaded by the integrated development tool.
Step S205: and determining a corresponding target plug-in address based on the target development project, and detecting the target plug-in address.
Step S206: and if the target plug-in is detected, displaying a target plug-in identifier corresponding to the target plug-in an interface of the integrated development tool.
Illustratively, referring to the schematic diagram of the storage target plugin shown in fig. 8, after the target plugin is generated, based on the development project information, binding between the target plugin and the development project is achieved, and different development projects correspond to different plugin addresses. In this embodiment, during the running process of the integrated development tool, the terminal device first obtains the currently loaded target development project, and then determines, based on the currently loaded target development project, a corresponding target plug-in address, that is, a plug-in loading address under the project address corresponding to the target development project. Further, the target plug-in address is used as a target, and the plug-in file under the address is detected in real time, namely whether a corresponding Jar packet exists or not.
In this embodiment, by acquiring the currently loaded target development project and detecting based on the target plug-in address corresponding to the target development project, on one hand, since each development project corresponds to a specific small amount of target plug-ins, plug-in retrieval is performed on the target development project only for current running, so that the detection speed can be effectively improved, and the consumption of computing resources caused by detecting dynamic plug-ins under the target plug-in address is reduced; on the other hand, the dynamic plug-in display with matching performance is carried out aiming at different target development projects, so that a large number of dynamic plug-ins irrelevant to the currently loaded target development projects are prevented from being displayed in an interface of the integrated development tool, the display effect of the dynamic plug-ins is improved, and the problem that the operation efficiency is influenced by excessive dynamic plug-ins is avoided.
Step S207: and responding to a trigger instruction aiming at the target plug-in identification, calling the target plug-in to process the target file, and generating a processing result.
In this embodiment, the implementation manner of step S207 is the same as the implementation manner of step S103 in the embodiment shown in fig. 2 of the present disclosure, and will not be described in detail here.
Referring to fig. 9, fig. 9 is a flowchart illustrating a dynamic plug-in-based file processing method according to an embodiment of the present disclosure. The embodiment adds a specific step of automatically generating the target plugin on the basis of the embodiment shown in fig. 2, and in the embodiment, the target plugin is a functional test plugin, and the file processing method based on the dynamic plugin includes:
step S301: in the running process of the integrated development tool, when the updating of the target code file is detected, at least one corresponding target test case file is generated based on the code structure of the target code file.
Step S302: based on the target test case file, generating or updating a functional test plug-in corresponding to the target code file, wherein the functional test plug-in is used for executing the target test case file after being triggered, and outputting a test result.
In an integrated development tool operation process, a terminal device detects a change of a code file through a preset code file detection service, generates at least one corresponding target test case file based on a code structure of the target code file when detecting an update of the target code file, specifically, for example, by analyzing the code structure, constructs a corresponding test case according to specific code content of a logic statement (such as a conditional statement, a cyclic statement), a numerical calculation statement, an assignment statement and the like in the target code file, and forms a file, namely a target test case file. The implementation manner of automatically generating the test case based on the code structure is in the prior art, and is not described herein.
And then, automatically generating a script program, namely a functional test plug-in, for testing the target code file based on the target test case file based on the obtained target test case file. After the function test plug-in is triggered, the terminal device tests the target code file based on the target test case file and outputs a test result (for example, whether an exception is captured or not).
Step S303: and detecting a preset plug-in loading address in real time.
Step S304: and if the generated or updated functional test plug-in is detected, displaying a plug-in identifier corresponding to the generated or updated functional test plug-in an interface of the integrated development tool.
Step S305: and responding to a trigger instruction aiming at the functional test plug-in, executing the target test case file and outputting a test result.
In this embodiment, the implementation manners of step 303 to step 305 are similar to the implementation manners of step S101 to step S103 in the embodiment shown in fig. 2 of the present disclosure, and specifically, refer to the related description in the embodiment shown in fig. 2, and are not described in detail herein.
Fig. 10 is a schematic diagram of a display function test plug-in provided in an embodiment of the present disclosure, as shown in fig. 10, based on the dynamic plug-in based file processing method improved in the embodiment shown in fig. 9, in a graphical interface of an integrated development tool, including an encoding area and a plug-in area, where, for example, as shown in fig. 10, the plug-in area may be displayed simultaneously with the encoding area. After a developer user modifies an object code file in an encoding area and clicks 'save', the terminal equipment automatically generates a corresponding test case file based on the change of the object code file, generates a functional test plug-in based on the test case file, stores the functional test plug-in a preset plug-in loading position, and then displays an icon corresponding to the functional test plug-in the plug-in area by detecting the plug-in loading position in real time. And then, the developer user clicks the icon corresponding to the function test plug-in through operating the terminal equipment, so that the unit test on the previously stored target code file can be realized.
The embodiment provides a quick unit testing method based on dynamic plug-in implementation, which is used for generating a plug-in for dynamically testing an object code file, namely a test function plug-in by detecting the update of the object code file in real time. The test function plugin is updated with the updating of the object code file, so that the dynamic test of the object code file can be realized. Meanwhile, the dynamic plug-in is utilized to dynamically display and load the integrated development tool without restarting the integrated development tool, so that the current target code file is dynamically tested by the dynamic plug-in the process of program development by the integrated development tool, the quick unit test is realized, the code development efficiency in the process of program development by the integrated development tool is improved, and the code error rate is reduced.
Corresponding to the dynamic plugin-based file processing method of the above embodiment, fig. 11 is a block diagram of a dynamic plugin-based file processing apparatus according to an embodiment of the present disclosure. For ease of illustration, only portions relevant to embodiments of the present disclosure are shown. Referring to fig. 11, the dynamic plug-in based file processing apparatus 4 includes:
The detection module 41 is configured to detect a preset plug-in loading address during an operation process of the integrated development tool;
the display module 42 is configured to display, in an interface of the integrated development tool, a plug-in identifier corresponding to the dynamic plug-in if the dynamic plug-in is detected, where the dynamic plug-in is loaded based on a Java archive file;
and the processing module 43 is used for calling the dynamic plug-in processing target file to generate a processing result in response to the triggering instruction aiming at the plug-in identification.
In one embodiment of the present disclosure, a first plug-in region and a second plug-in region are included within an interface of an integrated development tool; the first plug-in area is used for displaying preloaded static plug-ins, and the second plug-in area is used for displaying dynamic plug-ins.
In one embodiment of the present disclosure, the processing module 43 is specifically configured to: acquiring Java archive files corresponding to the dynamic plug-ins; a Java archive file is loaded to a Java virtual machine based on a Java class loading mechanism, and a function class corresponding to the dynamic plug-in is operated; and processing the target file based on the function class corresponding to the dynamic plug-in, and generating a processing result.
In one embodiment of the present disclosure, during operation of the integrated development tool, the detection module 41 is specifically configured to: loading configuration information, wherein the configuration information is used for indicating a target plug-in address for storing a target dynamic plug-in, and the target plug-in address is positioned at a first server communicated with terminal equipment; and detecting the target plug-in address according to the configuration information.
In one embodiment of the present disclosure, before detecting the preset plug-in loading address, the processing module 43 is further configured to: acquiring a target development project currently loaded by an integrated development tool; determining a corresponding target plug-in address based on the target development project; the detection module 41 is specifically configured to, when detecting a preset add-in loading address: the target plug-in address is detected.
In one embodiment of the present disclosure, the processing module 43 is further configured to, prior to detecting the preset add-in load address: generating a target dynamic plug-in; storing the target dynamic plug-in to a plug-in loading position.
In one embodiment of the present disclosure, the processing module 43 is specifically configured to, when storing the target dynamic plug-in to the plug-in loading location: acquiring development project information, wherein the development project information characterizes a development project established through an integrated development tool; and storing the target dynamic plug-in to a plug-in loading position corresponding to the development project information.
In one embodiment of the present disclosure, the target dynamic plugin is a functional test plugin, and the processing module 43 is specifically configured to, when generating the dynamic plugin: when the updating of the target code file is detected, generating at least one corresponding target test case file based on the code structure of the target code file; based on the target test case file, generating or updating a functional test plug-in corresponding to the target code file, wherein the functional test plug-in is used for executing the target test case file after being triggered, and outputting a test result.
The detection module 41, the display module 42, and the processing module 43 are sequentially connected. The file processing device 4 based on the dynamic plug-in unit provided in this embodiment may execute the technical solution of the foregoing method embodiment, and its implementation principle and technical effects are similar, which is not described herein again.
Fig. 12 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure, as shown in fig. 12, the electronic device 5 includes:
a processor 51 and a memory 52 communicatively connected to the processor 51;
memory 52 stores computer-executable instructions;
processor 51 executes computer-executable instructions stored in memory 52 to implement the dynamic plug-in based file processing method in the embodiments shown in fig. 2-10.
Wherein optionally processor 51 and memory 52 are connected by bus 53.
The relevant descriptions and effects corresponding to the steps in the embodiments corresponding to fig. 2 to fig. 10 may be understood correspondingly, and are not described in detail herein.
Referring to fig. 13, there is shown a schematic structural diagram of an electronic device 900 suitable for use in implementing embodiments of the present disclosure, where the electronic device 900 may be a terminal device or a server. The terminal device may include, but is not limited to, a mobile terminal such as a mobile phone, a notebook computer, a digital broadcast receiver, a personal digital assistant (Personal Digital Assistant, PDA for short), a tablet (Portable Android Device, PAD for short), a portable multimedia player (Portable Media Player, PMP for short), an in-vehicle terminal (e.g., an in-vehicle navigation terminal), and the like, and a fixed terminal such as a digital TV, a desktop computer, and the like. The electronic device shown in fig. 13 is merely an example and should not impose any limitations on the functionality and scope of use of embodiments of the present disclosure.
As shown in fig. 13, the electronic apparatus 900 may include a processing device (e.g., a central processor, a graphics processor, or the like) 901, which may perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 902 or a program loaded from a storage device 908 into a random access Memory (Random Access Memory, RAM) 903. In the RAM 903, various programs and data necessary for the operation of the electronic device 900 are also stored. The processing device 901, the ROM 902, and the RAM 903 are connected to each other through a bus 904. An input/output (I/O) interface 905 is also connected to the bus 904.
In general, the following devices may be connected to the I/O interface 905: input devices 906 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, and the like; an output device 907 including, for example, a liquid crystal display (Liquid Crystal Display, LCD for short), a speaker, a vibrator, and the like; storage 908 including, for example, magnetic tape, hard disk, etc.; and a communication device 909. The communication means 909 may allow the electronic device 900 to communicate wirelessly or by wire with other devices to exchange data. While fig. 13 shows an electronic device 900 having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead.
In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method shown in the flowcharts. In such an embodiment, the computer program may be downloaded and installed from a network via the communication device 909, or installed from the storage device 908, or installed from the ROM 902. When executed by the processing device 901, performs the above-described functions defined in the methods of the embodiments of the present disclosure.
It should be noted that the computer readable medium described in the present disclosure may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this disclosure, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.
The computer readable medium may be contained in the electronic device; or may exist alone without being incorporated into the electronic device.
The computer-readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to perform the methods shown in the above-described embodiments.
Computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, including an object oriented programming language such as Java, smalltalk, C ++ and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a local area network (Local Area Network, LAN for short) or a wide area network (Wide Area Network, WAN for short), or it may be connected to an external computer (e.g., connected via the internet using an internet service provider).
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. 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.
The units involved in the embodiments of the present disclosure may be implemented by means of software, or may be implemented by means of hardware. The name of the unit does not in any way constitute a limitation of the unit itself, for example the first acquisition unit may also be described as "unit acquiring at least two internet protocol addresses".
The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), an Application Specific Standard Product (ASSP), a system on a chip (SOC), a Complex Programmable Logic Device (CPLD), and the like.
In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
In a first aspect, according to one or more embodiments of the present disclosure, there is provided a method for processing a file based on a dynamic plug-in, including:
detecting a preset plug-in loading address in the running process of the integrated development tool; if the dynamic plugin is detected, displaying a plugin identifier corresponding to the dynamic plugin in an interface of an integrated development tool, wherein the dynamic plugin is loaded based on Java archive files; and responding to a trigger instruction aiming at the plug-in identification, calling the dynamic plug-in to process the target file, and generating a processing result.
In accordance with one or more embodiments of the present disclosure, the integrated development tool includes a first plug-in region and a second plug-in region within an interface; the first plug-in area is used for displaying preloaded static plug-ins, and the second plug-in area is used for displaying dynamic plug-ins.
According to one or more embodiments of the present disclosure, in response to a trigger instruction for the plug-in identification, invoking the dynamic plug-in processing target file to generate a processing result, including: acquiring Java archive files corresponding to the dynamic plug-ins; loading the Java archive file to a Java virtual machine based on a Java class loading mechanism, and running a function class corresponding to the dynamic plug-in; and processing the target file based on the function class corresponding to the dynamic plug-in, and generating the processing result.
According to one or more embodiments of the present disclosure, detecting a preset plug-in load address includes: loading configuration information, wherein the configuration information is used for indicating a target plug-in address for storing a target dynamic plug-in, and the target plug-in address is positioned in a first server communicated with terminal equipment; and detecting the target plug-in address according to the configuration information.
In accordance with one or more embodiments of the present disclosure, before the detecting the preset plug-in load address, the method further comprises: acquiring a target development project currently loaded by the integrated development tool; determining a corresponding target plug-in address based on the target development project; the detecting the preset plug-in loading address comprises the following steps: and detecting the target plug-in address.
In accordance with one or more embodiments of the present disclosure, before the detecting the preset plug-in load address, the method further comprises: generating a target dynamic plug-in; and storing the target dynamic plug-in to the plug-in loading position.
According to one or more embodiments of the present disclosure, the storing the target dynamic plug-in to the plug-in loading location includes: acquiring development project information, wherein the development project information characterizes a development project established through the integrated development tool; and storing the target dynamic plug-in to a plug-in loading position corresponding to the development project information.
According to one or more embodiments of the present disclosure, the target dynamic plugin is a functional test plugin, and the generating dynamic plugin includes: when the updating of the target code file is detected, generating at least one corresponding target test case file based on the code structure of the target code file; and generating or updating a functional test plug-in corresponding to the target code file based on the target test case file, wherein the functional test plug-in is used for executing the target test case file after being triggered, and outputting a test result.
In a second aspect, according to one or more embodiments of the present disclosure, there is provided a dynamic plugin-based file processing apparatus, including:
the detection module is used for detecting a preset plug-in loading address in the running process of the integrated development tool;
the display module is used for displaying a plug-in identifier corresponding to the dynamic plug-in the interface of the integrated development tool if the dynamic plug-in is detected, and the dynamic plug-in is loaded based on Java archive files;
and the processing module is used for calling the dynamic plug-in to process the target file in response to the triggering instruction aiming at the plug-in identification and generating a processing result.
In accordance with one or more embodiments of the present disclosure, the integrated development tool includes a first plug-in region and a second plug-in region within an interface; the first plug-in area is used for displaying preloaded static plug-ins, and the second plug-in area is used for displaying dynamic plug-ins.
According to one or more embodiments of the present disclosure, the processing module is specifically configured to: acquiring Java archive files corresponding to the dynamic plug-ins; loading the Java archive file to a Java virtual machine based on a Java class loading mechanism, and running a function class corresponding to the dynamic plug-in; and processing the target file based on the function class corresponding to the dynamic plug-in, and generating the processing result.
In accordance with one or more embodiments of the present disclosure, during operation of the integrated development tool, the detection module is specifically configured to: loading configuration information, wherein the configuration information is used for indicating a target plug-in address for storing a target dynamic plug-in, and the target plug-in address is positioned in a first server communicated with terminal equipment; and detecting the target plug-in address according to the configuration information.
According to one or more embodiments of the present disclosure, before the detecting the preset plug-in loading address, the processing module is further configured to: acquiring a target development project currently loaded by the integrated development tool; determining a corresponding target plug-in address based on the target development project; the detection module is specifically configured to, when detecting a preset plug-in loading address: and detecting the target plug-in address.
In accordance with one or more embodiments of the present disclosure, the processing module is further configured, prior to the detecting the preset plug-in loading address, to: generating a target dynamic plug-in; and storing the target dynamic plug-in to the plug-in loading position.
In accordance with one or more embodiments of the present disclosure, the processing module, when storing the target dynamic plug-in to the plug-in loading location, is specifically configured to: acquiring development project information, wherein the development project information characterizes a development project established through the integrated development tool; and storing the target dynamic plug-in to a plug-in loading position corresponding to the development project information.
According to one or more embodiments of the present disclosure, the target dynamic plugin is a functional test plugin, and the processing module is specifically configured to, when generating the dynamic plugin: when the updating of the target code file is detected, generating at least one corresponding target test case file based on the code structure of the target code file; and generating or updating a functional test plug-in corresponding to the target code file based on the target test case file, wherein the functional test plug-in is used for executing the target test case file after being triggered, and outputting a test result.
In a third aspect, according to one or more embodiments of the present disclosure, there is provided an electronic device comprising: a processor, and a memory communicatively coupled to the processor;
the memory stores computer-executable instructions;
the processor executes the computer-executable instructions stored in the memory to implement the dynamic plug-in based file processing method as described above in the first aspect and the various possible designs of the first aspect.
In a fourth aspect, according to one or more embodiments of the present disclosure, there is provided a computer-readable storage medium having stored therein computer-executable instructions which, when executed by a processor, implement the dynamic plug-in based file processing method as described above in the first aspect and the various possible designs of the first aspect.
In a fifth aspect, embodiments of the present disclosure provide a computer program product comprising a computer program which, when executed by a processor, implements the dynamic plug-in based file processing method according to the first aspect and the various possible designs of the first aspect.
The foregoing description is only of the preferred embodiments of the present disclosure and description of the principles of the technology being employed. It will be appreciated by persons skilled in the art that the scope of the disclosure referred to in this disclosure is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or equivalents thereof without departing from the spirit of the disclosure. Such as those described above, are mutually substituted with the technical features having similar functions disclosed in the present disclosure (but not limited thereto).
Moreover, although operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. In certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are example forms of implementing the claims.
Claims (12)
1. A method for processing a file based on a dynamic plug-in, comprising:
detecting a preset plug-in loading address in the running process of the integrated development tool;
If the dynamic plugin is detected, displaying a plugin identifier corresponding to the dynamic plugin in an interface of the integrated development tool, wherein the dynamic plugin is loaded based on Java archive files;
and responding to a trigger instruction aiming at the plug-in identification, calling the dynamic plug-in to process the target file, and generating a processing result.
2. The method of claim 1, wherein the integrated development tool interface includes a first plug-in area and a second plug-in area therein;
the first plug-in area is used for displaying preloaded static plug-ins, and the second plug-in area is used for displaying dynamic plug-ins.
3. The method of claim 1, wherein invoking the dynamic plug-in processing target file in response to a trigger instruction for the plug-in identification, generating a processing result, comprises:
acquiring Java archive files corresponding to the dynamic plug-ins;
loading the Java archive file to a Java virtual machine based on a Java class loading mechanism, and running a function class corresponding to the dynamic plug-in;
and processing the target file based on the function class corresponding to the dynamic plug-in, and generating the processing result.
4. The method of claim 1, wherein detecting a preset plug-in load address comprises:
Loading configuration information, wherein the configuration information is used for indicating a target plug-in address for storing a target dynamic plug-in, and the target plug-in address is positioned in a first server communicated with terminal equipment;
and detecting the target plug-in address according to the configuration information.
5. The method of claim 1, wherein prior to said detecting a preset plug-in load address, the method further comprises:
acquiring a target development project currently loaded by the integrated development tool;
determining a corresponding target plug-in address based on the target development project;
the detecting the preset plug-in loading address comprises the following steps:
and detecting the target plug-in address.
6. The method of claim 1, wherein prior to said detecting a preset plug-in load address, the method further comprises:
generating a target dynamic plug-in;
and storing the target dynamic plug-in to the plug-in loading position.
7. The method of claim 6, wherein the storing the target dynamic plug-in to the plug-in loading location comprises:
acquiring development project information, wherein the development project information characterizes a development project established through the integrated development tool;
And storing the target dynamic plug-in to a plug-in loading position corresponding to the development project information.
8. The method of claim 6, wherein the target dynamic plug-in is a functional test plug-in, the generating the dynamic plug-in comprising:
when the updating of the target code file is detected, generating at least one corresponding target test case file based on the code structure of the target code file;
and generating or updating a functional test plug-in corresponding to the target code file based on the target test case file, wherein the functional test plug-in is used for executing the target test case file after being triggered, and outputting a test result.
9. A dynamic plug-in based file processing apparatus, comprising:
the detection module is used for detecting a preset plug-in loading address in the running process of the integrated development tool;
the display module is used for displaying a plug-in identifier corresponding to the dynamic plug-in the interface of the integrated development tool if the dynamic plug-in is detected, and the dynamic plug-in is loaded based on Java archive files;
and the processing module is used for calling the dynamic plug-in to process the target file in response to the triggering instruction aiming at the plug-in identification and generating a processing result.
10. An electronic device, comprising: a processor, and a memory communicatively coupled to the processor;
the memory stores computer-executable instructions;
the processor executes computer-executable instructions stored in the memory to implement the dynamic plug-in based file processing method of any one of claims 1 to 8.
11. A computer readable storage medium having stored therein computer executable instructions which, when executed by a processor, implement the dynamic plug-in based file processing method of any of claims 1 to 8.
12. A computer program product comprising a computer program which, when executed by a processor, implements the dynamic plug-in based file processing method of any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210731415.0A CN117311838A (en) | 2022-06-24 | 2022-06-24 | File processing method, device, equipment and storage medium based on dynamic plug-in |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210731415.0A CN117311838A (en) | 2022-06-24 | 2022-06-24 | File processing method, device, equipment and storage medium based on dynamic plug-in |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117311838A true CN117311838A (en) | 2023-12-29 |
Family
ID=89241375
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210731415.0A Pending CN117311838A (en) | 2022-06-24 | 2022-06-24 | File processing method, device, equipment and storage medium based on dynamic plug-in |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117311838A (en) |
-
2022
- 2022-06-24 CN CN202210731415.0A patent/CN117311838A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110489101B (en) | Interface simulation method, system, medium and electronic equipment | |
| CN111897740B (en) | User interface testing method and device, electronic equipment and computer readable medium | |
| CN110489179B (en) | Method, device, medium and equipment for acquiring call stack frame function signature | |
| CN113377366B (en) | Control editing method, device, equipment, readable storage medium and product | |
| CN110764941B (en) | Method, device, medium and equipment for acquiring call stack frame instruction offset | |
| CN113835992B (en) | Memory leakage processing method and device, electronic equipment and computer storage medium | |
| CN111813465B (en) | Information acquisition method, device, medium and equipment | |
| CN113806212A (en) | Application program exception positioning method and device and electronic equipment | |
| CN110489165B (en) | Method, device, medium and equipment for acquiring call stack frame instruction offset | |
| CN111625291B (en) | Automatic iteration method and device for data processing model and electronic equipment | |
| CN110941549B (en) | Memory leak detection method, device, medium and electronic equipment | |
| CN112527302B (en) | Error detection method and device, terminal and storage medium | |
| CN110489164B (en) | Acquisition method, device, medium and equipment of hidden assertion information | |
| CN110908882A (en) | Performance analysis method and device of application program, terminal equipment and medium | |
| CN113377365B (en) | Code display method, apparatus, device, computer readable storage medium and product | |
| CN111382017A (en) | Fault query method, device, server and storage medium | |
| CN112379967B (en) | Simulator detection method, device, equipment and medium | |
| CN111258797B (en) | Memory leak detection method, device, medium and electronic equipment | |
| CN111309323B (en) | Parameter initialization method and device and electronic equipment | |
| CN117311838A (en) | File processing method, device, equipment and storage medium based on dynamic plug-in | |
| CN111381813B (en) | Front-end page debugging method and device, computer equipment and storage medium | |
| CN110727480A (en) | Method, device, medium and equipment for acquiring call stack frame instruction offset | |
| CN114398233B (en) | Load abnormality detection method and device, server and storage medium | |
| CN116932068A (en) | IDEA-based plug-in class loading method, device and equipment | |
| CN114168466A (en) | Unit testing method, device, system 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 |