Plug-in based development method, storage medium, and plug-in

Abstract

The application discloses a plug-in-based development method, a storage medium and a plug-in, relates to the technical field of software development, and discloses the plug-in-based development method, which comprises the following steps: a plug-in acquires a to-do task of a developer; the plug-in analyzes a stage of a project life cycle in which the to-do task is located, and obtains stage information; and the plug-in provides corresponding function services for the to-do task based on the stage information, obtains function service information after the developer processes the to-do task based on the function services, and enables an IDE to perform development configuration based on the function service information. Through the method, all operations and functions required to be executed by the integrated development task at each stage of the project life cycle are integrated into one end, the switching time loss of the developer between different platforms can be effectively reduced, and the technical effect of efficient development is provided for the developer.

Description

Technical Field

[0001] This application relates to the field of software development, and more specifically, to a method for developing a plugin, a storage medium, and a plugin. Background Technology

[0002] For front-end and back-end developers, the most frequent daily task is using an Integrated Development Environment (IDE). Their main job is to write code in the IDE.

[0003] However, throughout the entire software development project lifecycle, each stage has its corresponding platform system. For example, developers need to switch to a requirements and task management platform to perform tasks, a continuous integration platform to build code, and a service deployment platform to deploy services. Developers must switch between different platform systems at different stages of the project lifecycle. This means that developers need to frequently switch between different platforms during software development, thus impacting development efficiency.

[0004] Therefore, there is an urgent need to propose a solution that allows developers to develop directly throughout the entire project lifecycle without having to frequently switch between different platforms, in order to improve software development efficiency. Summary of the Invention

[0005] To solve the above problem, namely the technical issue of developers frequently switching between different platforms when each stage has its own corresponding platform system.

[0006] According to one aspect of this application, a plugin-based development method is provided, wherein the plugin is set in an integrated development environment (IDE), and the method includes:

[0007] The plugin retrieves the developer's pending tasks;

[0008] The plugin analyzes the stage of the project lifecycle in which the task is pending, obtaining stage information; and,

[0009] The plugin provides corresponding functional services for the pending tasks based on the stage information. After the developer processes the pending tasks based on the functional services, the functional service information is obtained, so that the IDE can perform development configuration based on the functional service information.

[0010] In a preferred embodiment of the method, the plug-in includes a user layer.

[0011] The plugin generates a user interface in the user layer based on Swing components. The user interface includes a tool window, which allows developers to perform operations such as registration, login, logout, or task processing.

[0012] The plugin obtains the developer's pending tasks, including: the plugin obtains the developer's pending tasks based on the user interface.

[0013] In a preferred embodiment of the method, the plugin acquires the developer's pending tasks, including:

[0014] The plugin receives the developer's login information and obtains the developer's pending tasks based on the login information.

[0015] The to-do task is one of several to-do tasks generated by the developer after creating a development task.

[0016] In a preferred embodiment of the method, the plug-in further includes a service layer.

[0017] The plugin generates service function modules and external function modules in the service layer based on Spring Boot components. The service function modules are used to provide functional services for each stage of the project lifecycle to the user layer, and the external function modules are used to connect to the external systems corresponding to each stage of the project lifecycle and provide functional service support for the service function modules.

[0018] The plugin provides corresponding functional services for the task to be done based on the stage information, including: the plugin provides corresponding functional services for the task to be done based on the service function module and the external function module according to the stage information.

[0019] In a preferred embodiment of the method, the project lifecycle includes any one or any combination of the following: project creation; project setup; project development; and project deployment.

[0020] In a preferred embodiment of the method, the plugin provides corresponding functional services for the task to be done based on the stage information, including:

[0021] If the stage information is project creation, then provide the function service of initial project scaffolding for the task to be done;

[0022] If the stage information is project settings, then a Maven private repository setup wizard is provided for the task to be completed.

[0023] If the stage information is project development, then code editing functionality is provided for the pending task;

[0024] If the stage information is project deployment, then the function of publishing third-party packages to the private server is provided for the task to be completed.

[0025] In a preferred embodiment of the method, the plugin analyzes the stage of the project lifecycle in which the task to be done is located, including:

[0026] The plugin analyzes the stage of the project lifecycle of the task based on its name.

[0027] According to another aspect of this application, a plugin-based development apparatus is provided, wherein the plugin is configured in an integrated development environment (IDE), and the apparatus includes:

[0028] The fetch unit is set to fetch the developer's to-do tasks;

[0029] The analysis unit is configured to analyze the stage of the project lifecycle in which the task to be done is located, and obtain stage information; and,

[0030] A service providing unit is configured to provide corresponding functional services for the pending task based on the stage information, and obtain functional service information so that the IDE can perform development configuration based on the functional service information.

[0031] According to another aspect of this application, a plug-in is provided, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to execute the plug-in-based development method via the computer program.

[0032] According to another aspect of this application, a computer-readable storage medium is provided, the computer-readable storage medium comprising a stored program, wherein the program executes the plug-in-based development method when it runs.

[0033] According to the plugin-based development method, storage medium, and plugin provided in this application, the plugin obtains the developer's pending tasks; the plugin analyzes the stage of the project lifecycle in which the pending tasks are located to obtain stage information; and the plugin provides corresponding functional services for the pending tasks based on the stage information. After the developer processes the pending tasks based on the functional services, functional service information is obtained, enabling the IDE to perform development configuration based on the functional service information. Through the above method, this application integrates all operations and functions that need to be performed at each stage of the project lifecycle into one end, effectively reducing the time loss of developers switching between different platforms and providing developers with a technical effect of efficient development. Attached Figure Description

[0034] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0035] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0036] Figure 1 This is a schematic diagram of a hardware environment for a plug-in-based development method according to an embodiment of this application;

[0037] Figure 2 A flowchart illustrating a plugin-based development method provided in this application embodiment;

[0038] Figure 3 A flowchart illustrating another plugin-based development method provided in this application embodiment;

[0039] Figure 4 This is one of the structural schematic diagrams of a plug-in provided in an embodiment of this application;

[0040] Figure 5a One of the schematic diagrams of the user interface provided in the embodiments of this application;

[0041] Figure 5b A second schematic diagram of the user interface provided in an embodiment of this application;

[0042] Figure 6 This is a schematic diagram illustrating the entire project lifecycle in the embodiments of this application;

[0043] Figure 7 A schematic diagram of a plug-in-based development device provided in an embodiment of this application;

[0044] Figure 8 This is a second schematic diagram of the structure of a plug-in provided in an embodiment of this application. Detailed Implementation

[0045] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of the present application.

[0046] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0047] Before introducing the embodiments of this application, the technical background of the embodiments of this application will be explained first: the IDE plugins in the related technologies have limited functions. Usually, each plugin can only provide support for a certain function in the project life cycle and is only compatible with one IDE. When developers need to develop for other project life cycles, they need to complete the development on another platform. In addition, the IDE plugins in the related technologies only provide a single, universal function for a certain programming language on a certain IDE, and cannot provide personalized support.

[0048] To address the aforementioned shortcomings and deficiencies, this application proposes a plugin-based development method, storage medium, and plugin. The plugin is improved to provide functional services throughout the development task's lifecycle, aiming to solve the problem of developers frequently switching between different platforms and to meet the needs of different types of developers, such as front-end and back-end developers, as well as developers using different programming languages. For example, it can be adapted to various IDEs within the IntelliJ family, providing functional support for each stage of the project lifecycle. Developers can customize corresponding functions according to their own development habits and needs.

[0049] According to one aspect of the embodiments of this application, a plug-in-based development method is provided. This plug-in-based development method can be widely applied to development scenarios of whole-house intelligent digital control applications such as smart homes, smart home ecosystems, and intelligence house ecosystems. Optionally, in this embodiment, the above-mentioned plug-in-based development method can be applied to applications such as... Figure 1 The hardware environment shown consists of IDE 110 and external systems 120, 130, 140, and 150. Unlike related technologies, in this embodiment, IDE 110 has a plug-in 111 installed, such as... Figure 1As shown, the plugin 111 sets up interfaces to connect to external systems 120, 130, 140, and 150 via networks. Each external system can provide services (such as login and logout services) to the plugin or certain functional layers within the plugin. The networks mentioned above can include, but are not limited to, at least one of the following: wired network and wireless network. The wired network can include, but is not limited to, at least one of the following: wide area network (WAN), metropolitan area network (MAN), and local area network (LAN). The wireless network can include, but is not limited to, at least one of the following: Wi-Fi (Wireless Fidelity) and Bluetooth.

[0050] The above provides a brief illustration of the scenario of this application. The following section describes its application... Figure 1 Taking terminal device 111 as an example, this application provides a detailed explanation of the plugin-based development method.

[0051] Please refer to Figure 2 , Figure 2 According to one aspect of this application, a plugin-based development method is provided, wherein the plugin is set in an integrated development tool (IDE), and the method includes steps S201-S203.

[0052] In practical applications, in addition to improving the various functional steps of the plugin, the plugin can also be flexibly customized according to the developer's development habits, project characteristics, or functional structure. This embodiment takes the IntelliJ platform plugin as an example. After completing the customization of the IntelliJ platform plugin, the plugin is published to the JetBrains plugin marketplace. The plugin can be used after being installed in the local IDE. For example, the developer can directly download the plugin from the JetBrains plugin marketplace to the local IDE for use.

[0053] Understandably, the IntelliJ platform is an Operation Support Systems (OSS) platform developed by JetBrains for building IDEs and programming language-aware developer tools. Many platforms, including IntelliJ IDEA, Android Studio, CUBA Studio, and Cursive, use it. Built on Java, it provides a cross-platform approach to building tools for any language, regardless of whether the target is the Java Virtual Machine (JVM). It is provided under the Apache 2.0 license, allowing the creation of tax-free commercial and non-commercial products, including full-fledged IDEs and plugins.

[0054] Step S201: The plugin obtains the developer's pending tasks.

[0055] In related technologies, each plugin supports a specific function—that is, a specific function at a certain stage of the project lifecycle. During development, using the plugin is equivalent to performing development work. For example, if a developer is in the project creation stage, they directly use the relevant plugin for project creation. The plugin does not need to identify or obtain the developer's pending tasks, nor can it provide any other functional services besides its specific function. However, in this embodiment, because the plugin supports all stages of the project lifecycle, during development, the developer's pending tasks are first obtained, and in subsequent steps, the project lifecycle stage is identified for each pending task, providing specific services for the corresponding stage.

[0056] In practical applications, each stage has a corresponding platform system, and each platform system also has corresponding role operations for personnel with different identities. During the development process, the plugin retrieves the developer's to-do tasks by receiving the developer's login information. Therefore, in a preferred technical solution of this embodiment, the plugin obtains the developer's to-do tasks (step S201) by including the following steps:

[0057] The plugin receives the developer's login information and retrieves the developer's pending tasks based on the login information.

[0058] In this embodiment, a to-do task is one of several to-do tasks generated by the developer after creating a development task. It is understood that a development task may involve multiple developers each responsible for multiple to-do tasks.

[0059] In one implementation, the plugin's user layer provides a user interface through which developers can perform operations such as login, logout, and refresh. The plugin receives user operations based on the user interface and responds accordingly.

[0060] Step S202: The plugin analyzes the stage of the project lifecycle in which the task to be done is located and obtains stage information.

[0061] In one specific technical solution of this embodiment, the plugin analyzes the stage of the project lifecycle in which the task to be done is located (step S202), including the following steps:

[0062] The plugin analyzes the stage of the project lifecycle of the task based on its name.

[0063] In one example, the name of the task to be done can be the same as the phase corresponding to the project lifecycle. For example, if the project lifecycle is the project development phase, the name of the task to be done could be "Project Development" or "XX Project Development".

[0064] Step S203: The plugin provides corresponding functional services for the pending task based on the stage information. After the developer processes the pending task based on the functional services, the functional service information is obtained, so that the IDE can perform development configuration based on the functional service information.

[0065] In one implementation, the plugin is configured with multiple external interfaces, which are connected to corresponding external systems. These external systems are platform systems that developers rely on at each stage of the project lifecycle. The plugin opens the corresponding external interfaces according to the stage information and interacts with the corresponding platform systems. In practical applications, developers can customize the plugin according to the specific development project and its lifecycle, such as the number of external interfaces and the connection method.

[0066] Based on the above solution in this embodiment, by integrating all operations and functions that developers need to perform at each stage of the project lifecycle into one end, when a task is obtained, by analyzing the project lifecycle stage and providing corresponding functional services for the corresponding stage, the time loss of developers switching between different platforms can be effectively reduced, and functions that support efficient development can be provided to developers.

[0067] Please refer to Figure 3 and Figure 4 , Figure 3 This is a flowchart illustrating another plugin-based development method provided in this embodiment. Figure 4 This is one of the structural diagrams of the plugin in this embodiment. Based on the previous embodiment, this embodiment further illustrates different functional layers of the plugin, and provides corresponding functional services for pending tasks by generating user interfaces and corresponding functional modules in different functional layers, thereby further improving development efficiency. Specifically, as shown... Figure 3 As shown, before the plugin obtains the developer's to-do tasks (step S201), the method further includes steps S301 and S302, and further divides step S201 into step S201a, and further divides step S203 into step S203a.

[0068] It should be noted that the above sequence of steps is only an example of this embodiment. In some embodiments, step S302 may be after step S201, rather than being a limitation of this embodiment.

[0069] Before introducing the method provided in this embodiment, the plug-in structure of this embodiment will be explained first, such as... Figure 4 As shown, the plugin includes a user layer 410 and a service layer 420.

[0070] User layer 410 is responsible for the design and implementation of the plugin's front-end interface. In this embodiment, the plugin is based on the IntelliJ Platform Plugin. The plugin can build an environment using the Gradle open-source tool for automated project building. Leveraging the open capabilities of the IntelliJ platform, it allows for extended functional development on top of the IntelliJ platform to meet the functional needs of developers throughout the project lifecycle. Gradle is an open-source tool for automated project building based on the concepts of Apache Ant and Apache Maven.

[0071] In this embodiment, the user interface required for the plugin functionality is developed using custom Swing components. These components include Tool Windows, Menus and toolbars, Dialogs, Popups, and Notifications. This embodiment can generate a user interface including Tool Windows and a Mainmenu based on the aforementioned functions of these components. Users can perform Actions or Configurations within the user interface. In one possible implementation, products based on the IntelliJ platform can be modified and adjusted for customization purposes by adding IntelliJ platform plugins.

[0072] The plugin in this embodiment can be applied to different IDEs, such as the JetBrains suite. The JetBrains suite is a commercial software provider of programming tools. The JetBrains suite refers to JetBrains' IDE suite, which has Windows, Linux and macOS versions, including IntelliJ IDEA (an integrated environment for Java development), WebStorm (a web front-end development tool), Goland (an integrated environment for Go development), DataGrip (a cross-platform database tool), etc.

[0073] The Service layer 420 is the backend service for the plugin. The plugin service is a microservice based on Spring Boot. By generating service function modules and external function modules, it provides backend service function support for various function modules such as login and logout, task collaboration, project creation, and project development to the plugin, and connects to various peripheral systems that developers need to rely on in the project lifecycle.

[0074] In this embodiment, the service layer 420 includes two parts: plug-in services and peripheral systems. The plug-in services correspond to multiple service function modules, such as login / logout, project creation, project settings, branch management, task collaboration, project development, project deployment, code submission, and other function modules. The peripheral systems correspond to multiple external function modules, such as front-end system A (which can be an external interface), front-end system B, front-end system C, and front-end system D. These multiple external function modules are connected to external systems 120-150, respectively.

[0075] Step S301: The plugin generates a user interface in the user layer based on the Swing component. The user interface includes a tool window, which allows developers to perform operations based on the tool window. The operations include registration, login, logout, or task processing.

[0076] Step S201a: The plugin obtains the developer's pending tasks based on the user interface.

[0077] Combination Figure 5a and Figure 5b As shown, Figure 5a and Figure 5b These are schematic diagrams of the user interface in this embodiment, such as... Figure 5a As shown, in one possible implementation, the tool window's attributes are first declared in the manifest file plugin.xml, inheriting from SimpleToolWindowPanel. The window is registered in ToolWindowFactory, and the interface with the external system is established at the service layer based on the tool window's operations to retrieve the corresponding pending task data. Developers can then register operations (Actions) such as settings, unregistration, refresh, and task processing in the tool window. In this embodiment, the tool window corresponds to... Figure 5a The essential window in the middle, corresponding to the developer Figure 5a User X in the system.

[0078] like Figure 5b As shown, in one possible implementation, the Menus-related Actions are declared in plugin.xml, and corresponding functional logic is designed and implemented for different Actions. The window is registered in ToolWindowFactory; and the left-side function tree and right-side function details interface are implemented using the OnePixelSplitter class. Then, the plugin backend service is called to obtain the list of available functions and render it onto the plugin interface.

[0079] Step S302: The plugin generates service function modules and external function modules in the service layer based on Spring Boot components. The service function modules are used to provide functional services for each stage of the project lifecycle to the user layer. The external function modules are used to connect to the external systems corresponding to each stage of the project lifecycle and provide functional service support for the service function modules.

[0080] Step S203a: The plugin provides corresponding functional services for the pending task based on the service function module and the external function module according to the stage information. After the developer processes the pending task based on the functional service, the functional service information is obtained, so that the IDE can perform development configuration based on the functional service information.

[0081] In one example, the service function modules may include login / logout, project creation, project settings, branch management, task collaboration, project development, project deployment, code submission, and other function modules. The external function modules connect to various external systems. It is understood that generating multiple function service modules based on Spring Boot components is an existing technology, and this embodiment will not elaborate on it. Regarding the generation of external function modules, in one implementation, Spring Boot components can generate external function modules by generating external interface documentation.

[0082] In a preferred embodiment, the project lifecycle includes any one or any combination of the following: project creation; project setup; project development; and project deployment.

[0083] In a preferred embodiment of the method, the plugin provides corresponding functional services for the task to be done based on the stage information, including:

[0084] If the stage information is project creation, then provide the function service of initial project scaffolding for the task to be done;

[0085] If the stage information is project settings, then a Maven private repository setup wizard is provided for the task to be completed.

[0086] If the stage information is project development, then code editing functionality is provided for the pending task;

[0087] If the stage information is project deployment, then the function of publishing third-party packages to the private server is provided for the task to be completed.

[0088] It is understandable that the above stage information mainly corresponds to the development process stages. In some examples, in addition to the above stages, other development stages may also be included. Functional services of other stages can be supported by customizing the plugin.

[0089] In some implementations, the project lifecycle (essentials) may include stages such as login and to-do lists in addition to the development process stages mentioned above. For example... Figure 6 As shown, Figure 6 This illustrates the various stages and tasks of the project lifecycle, and the plugin provided in this embodiment can provide corresponding functional services at each stage. To facilitate understanding of this embodiment, this application provides an exemplary embodiment, including the following process:

[0090] a. Developers install the plugin in the JetBrains suite of IDEs;

[0091] b. By logging in, the plugin obtains the developer's identity;

[0092] c. The plugin display tool window helps developers retrieve the current pending tasks and provides corresponding functional services based on the project lifecycle stage of the pending tasks in subsequent steps.

[0093] d. During the project creation phase, provide developers with initial project scaffolding for project types such as backend services, gateway services, and scheduled tasks;

[0094] e. During the project setup phase, provide developers with a Maven private repository setup wizard;

[0095] f. During the project development phase, provide developers with convenient functions such as code generation, code inspection, and code submission;

[0096] g. During the project deployment phase, provide developers with the ability to publish third-party packages to private servers.

[0097] It should be noted that the above-mentioned functional services are only one example of this embodiment and are not intended to limit this application. In some embodiments, other functional services can be provided according to different project lifecycle stages of the task to be completed. For example, in the project deployment stage, in addition to providing developers with the functional service of publishing third-party packages to private servers, they can also be provided with functional services such as pipeline continuous integration and application service deployment.

[0098] According to another aspect of this application, embodiments of this application also provide a plugin-based development apparatus, wherein the plugin is configured in an integrated development environment (IDE), such as... Figure 7 As shown, the device includes an acquisition unit 71, an analysis unit 72, and a service provision unit 73, wherein...

[0099] Get Unit 71, which is set to retrieve the developer's to-do tasks;

[0100] Analysis unit 72 is configured to analyze the stage of the project lifecycle in which the task to be done is located, and obtain stage information; and,

[0101] The service providing unit 73 is configured to provide corresponding functional services for the pending task based on the stage information, and obtain functional service information so that the IDE can perform development configuration based on the functional service information.

[0102] In a preferred embodiment of the device, the plug-in includes a user layer, and the device further includes:

[0103] The first generation unit is configured to generate a user interface in the user layer based on Swing components. The user interface includes a tool window, which allows developers to perform operations based on the tool window. The operations include registration, login, logout, or task processing.

[0104] The acquisition unit 71 is specifically configured such that the plugin acquires the developer's to-do tasks based on the user interface.

[0105] In a preferred embodiment of the device, the acquisition unit 71 includes:

[0106] A receiving element, configured to receive the developer's login information; and an obtaining element, configured to obtain the developer's to-do tasks based on the login information;

[0107] The to-do task is one of several to-do tasks generated by the developer after creating a development task.

[0108] In a preferred embodiment of the device, the plug-in further includes a service layer, and the device further includes:

[0109] The second generation unit is configured to generate service function modules and external function modules in the service layer based on Spring Boot components. The service function modules are used to provide functional services for each stage of the project lifecycle to the user layer, and the external function modules are used to connect to the external systems corresponding to each stage of the project lifecycle and provide functional service support for the service function modules.

[0110] The service providing unit 73 is specifically configured to provide corresponding functional services for the pending task based on the service function module and the external function module according to the stage information.

[0111] In a preferred embodiment of the device, the project lifecycle includes any one or any combination of the following: project creation; project setup; project development; and project deployment.

[0112] In a preferred embodiment of the device, the service providing unit 73 is specifically configured as follows:

[0113] When the stage information is project creation, the function service provides an initial project scaffolding for the pending tasks;

[0114] When the stage information is project settings, a Maven private repository setup wizard is provided for the task to be completed.

[0115] When the stage information is project development, code editing functionality is provided for the tasks to be done.

[0116] When the stage information is project deployment, the function service of publishing third-party packages to the private server is provided for the pending tasks.

[0117] In a preferred embodiment of the device, the analysis unit 72 is specifically configured to analyze the stage of the project lifecycle of the task to be done based on the name of the task.

[0118] According to another aspect of this application, a plugin is provided, such as Figure 8 As shown, the plug-in includes a memory 81 and a processor 82. The memory 81 stores a computer program, and the processor 82 is configured to execute the plug-in-based development method through the computer program.

[0119] According to another aspect of this application, a computer-readable storage medium is provided, the computer-readable storage medium comprising a stored program, wherein the program executes the plug-in-based development method when it runs.

[0120] Those skilled in the art will understand that all or some of the steps, systems, and apparatuses disclosed above, and their functional modules / units, can be implemented as software, firmware, hardware, or suitable combinations thereof. In hardware implementations, the division between functional modules / units mentioned above does not necessarily correspond to the division of physical components; for example, a physical component may have multiple functions, or a function or step may be performed collaboratively by several physical components. Some or all physical components may be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application-specific integrated circuit (ASIC). Such software can be distributed on a computer-readable medium, which may include computer storage media (or non-transitory media) and communication media (or transient media).

[0121] As is known to those skilled in the art, the term computer storage medium includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information (such as computer-readable instructions, data structures, program modules or other data). Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROM, digital versatile disc (DVD) or other optical disc storage, magnetic cartridges, magnetic tape, disk storage or other magnetic storage devices, or any other medium that can be used to store desired information and is accessible to a computer.

[0122] Furthermore, as is known to those skilled in the art, communication media typically contain computer-readable instructions, data structures, program modules, or other data in modulated data signals such as carrier waves or other transmission mechanisms, and may include any information delivery medium.

[0123] In the description of the embodiments of this application, the term "and / or" merely indicates a relationship describing the associated objects, meaning that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Additionally, the term "at least one" indicates any combination of at least two of a plurality of options, for example, including at least one of A, B, and C, which can represent any one or more elements selected from a set including communication between A, B, and C. Furthermore, the term "multiple" means two or more, unless otherwise precisely specified.

[0124] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A plug-in based development method, characterized by, The plugin is configured within an integrated development environment (IDE), and includes a user layer and a service layer. The method includes: The plugin generates a user interface in the user layer based on Swing components. The user interface includes a tool window, which allows developers to perform operations such as registration, login, logout, or task processing. The plugin receives the developer's login information; and obtains the developer's pending tasks based on the login information, wherein the pending tasks are one of several pending tasks generated by the developer after creating a development task; The plugin analyzes the stage of the project lifecycle in which the task is pending, obtaining stage information; and, The plugin generates service function modules and external function modules in the service layer based on Spring Boot components. The service function modules are used to provide functional services for each stage of the project lifecycle to the user layer, and the external function modules are used to connect to the external systems corresponding to each stage of the project lifecycle and provide functional service support for the service function modules. The plugin provides corresponding functional services for the pending tasks based on the service function module and external function module according to the stage information. After the developer processes the pending tasks based on the functional services, the functional service information is obtained, so that the IDE can perform development configuration based on the functional service information.

2. The method of claim 1, wherein, The project lifecycle includes any one or any combination of the following: project creation; project setup; project development; and project deployment.

3. The method of claim 2, wherein, The plugin provides corresponding functional services for the pending tasks based on the stage information, including: If the stage information is project creation, then provide the function service of initial project scaffolding for the task to be done; If the stage information is project settings, then a Maven private repository setup wizard is provided for the task to be completed. If the stage information is project development, then code editing functionality is provided for the pending task; If the stage information is project deployment, then the function of publishing third-party packages to the private server is provided for the task to be completed.

4. The method of claim 1, wherein, The plugin analyzes the stage of the project lifecycle in which the task is pending, including: The plugin analyzes the stage of the project lifecycle of the task based on its name.

5. A plug-in based development apparatus, characterized by comprising: The plugin is configured in an integrated development environment (IDE), and the device is used to implement the plugin-based development method according to any one of claims 1-4, the device comprising: The fetch unit is set to fetch the developer's to-do tasks; The analysis unit is configured to analyze the stage of the project lifecycle in which the task to be done is located, and obtain stage information; and, A service providing unit is configured to provide corresponding functional services for the pending task based on the stage information, and obtain functional service information so that the IDE can perform development configuration based on the functional service information.

6. A plugin, characterized in that, The invention includes a memory and a processor, characterized in that the memory stores a computer program, and the processor is configured to execute the plug-in-based development method of any one of claims 1 to 4 through the computer program.

7. A computer-readable storage medium, characterized in that, The computer-readable storage medium includes a stored program, wherein the program, when executed, performs the plug-in-based development method according to any one of claims 1 to 4.

Images