A plug-in secondary development processing method, device, equipment and storage medium

Abstract

The present application discloses a method, device, equipment and storage medium for secondary development of plug-ins. According to the layer application object tree specification, the method supports the plug-in to carry out adjustment and enhanced function development on the basis of the application. In the coding, startup and operation stages, the method aims at the code syntax, code prompt, model fitting, loader extension and other methods of the plug-in to realize the function enhancement of the application plug-in, so as to achieve a certain balance among the core logic of the module application, personalized needs and industry needs, and solves the technical problems that the modular development is insufficient in supporting cross-industry products, which easily leads to the complexity and difficulty of configuring products, and the limited extensibility of the plug-in mechanism, and the inability to make fundamental adjustments to the benchmark functions.

Description

Technical Field

[0001] The present application relates to the field of software technology, and in particular to a plug-in secondary development processing method, device, equipment and storage medium. Background Art

[0002] In the field of software development, modular development has become the preferred strategy in a single project because it can divide modules according to business areas and promote collaboration between modules through standardized interfaces, thereby improving code clarity and development efficiency. However, in the context of cross-industry software development and long-term technology accumulation, modular development has encountered challenges. The differences in requirements and characteristics of different industries have forced developers to add a large number of compatibility configurations in a single module, which not only makes the module bloated, but also increases the complexity of configuration and the difficulty of maintenance.

[0003] On the other hand, in order to meet the flexibility and scalability requirements of tool software and frameworks, the industry generally adopts a plug-in mechanism based on specifications. This mechanism encourages third-party developers to innovate on the basis of existing functions by providing standardized extension interfaces, thereby enriching the software ecosystem. However, the plug-in mechanism also has its limitations: plug-in development can usually only slightly enhance the baseline functions, and it is difficult to achieve deep customization or reconstruction of the underlying logic, which limits the depth and breadth of technological innovation.

[0004] Therefore, these two development methods face the following problems:

[0005] Modular development is insufficient in supporting cross-industry products, which can easily lead to products becoming complex and difficult to configure;

[0006] The plugin mechanism has limited extensibility and cannot make fundamental adjustments to the benchmark functionality. Summary of the invention

[0007] The present application provides a method, device, equipment and storage medium for plug-in secondary development processing, which solves the technical problems that modular development is insufficient in cross-industry product support, which easily leads to products becoming complex and difficult to configure, as well as the limited extensibility of the plug-in mechanism and the inability to make fundamental adjustments to benchmark functions.

[0008] In view of this, the first aspect of the present application provides a plug-in secondary development processing method, the method comprising:

[0009] Step S1, determining an object tree of a target application, wherein the object tree includes a data dictionary, a screen structure, a menu interface, and a secondary development type;

[0010] Step S2: If the secondary development type is adjustment enhancement type, whether plug-in secondary development is supported is determined according to the type of the selected node;

[0011] Step S3: if supported, obtain the plug-in secondary development code for the selected node; otherwise, issue a restriction prompt;

[0012] Step S4, performing real-time code checking and prompting on the plug-in secondary development code, and filtering and displaying development elements corresponding to the plug-in secondary development code;

[0013] Step S5: aggregating the first application object model of the target application according to the secondary development type and the plug-in secondary development code to obtain a second application object model of the target application;

[0014] Step S6: Load the second application object model.

[0015] Optionally, the step S2 specifically includes:

[0016] If the secondary development type is adjustment enhancement type, determine whether the type of the selected node is any of the Enum type node, Table type node, Form type node, MenuItem type node, Menu type node or FormDataSource type node. If so, plug-in secondary development is supported, otherwise plug-in secondary development is not supported.

[0017] Optionally, after step S1, the following steps are further included:

[0018] If the secondary development type is incremental, a plug-in secondary development code for the target application is obtained.

[0019] Optionally, the step S4 specifically includes:

[0020] When the plug-in secondary development code contains a database query statement, determine whether the database query statement is a query reference to the corresponding data of the current plug-in. If so, the real-time code check passes, otherwise, a prompt is given that the reference is invalid;

[0021] The development elements corresponding to the current plug-in are filtered and displayed, and the development elements include class elements, method elements, and variable elements.

[0022] Optionally, the step S5 specifically includes:

[0023] If the secondary development type is adjustment enhancement, taking entity content nodes as units, according to node types and breadth-first principle, fitting the incremental content in the plug-in secondary development code to the first application object model of the target application, to obtain the second application object model of the target application;

[0024] If the secondary development type is incremental, all contents in the plug-in secondary development code are merged into the first application object model of the target application in units of entity content nodes to obtain the second application object model of the target application.

[0025] Optionally, the step S6 specifically includes:

[0026] Pre-configure plugin class loaders based on parent delegation mechanism;

[0027] Based on the benchmark application loader, the plug-in class loader is expanded horizontally;

[0028] The second application object model is loaded by the base application loader and the plug-in class loader.

[0029] Optionally, after step S6, the following steps are further included:

[0030] Using bytecode enhancement technology to enhance the object instance of the Table type object in the second application object model;

[0031] An interception method is used to perform object instance enhancement on an object of the Form type in the second application object model.

[0032] A second aspect of the present application provides a plug-in secondary development processing device, the device comprising:

[0033] An object tree determination unit, used to determine an object tree of a target application, wherein the object tree includes a data dictionary, a screen structure, a menu interface, and a secondary development type;

[0034] A judging unit, configured to judge whether plug-in secondary development is supported according to the type of the selected node if the secondary development type is adjustment enhanced type;

[0035] A processing unit, configured to obtain the plug-in secondary development code for the selected node if supported, and to provide a restriction prompt otherwise;

[0036] A checking unit, used for performing real-time code checking and prompting on the plug-in secondary development code, and filtering and displaying development elements corresponding to the plug-in secondary development code;

[0037] an aggregation unit, configured to aggregate the first application object model of the target application according to the secondary development type and the plug-in secondary development code to obtain a second application object model of the target application;

[0038] A loading unit is used to load the second application object model.

[0039] A third aspect of the present application provides a plug-in secondary development processing device, the device comprising a processor and a memory:

[0040] The memory is used to store program code and transmit the program code to the processor;

[0041] The processor is used to execute the steps of the method for secondary development of plug-in as described in the first aspect according to the instructions in the program code.

[0042] A fourth aspect of the present application provides a computer-readable storage medium, wherein the computer-readable storage medium is used to store program code, and the program code is used to execute the method described in the first aspect above.

[0043] It can be seen from the above technical solutions that the embodiments of the present application have the following advantages:

[0044] In the present application, a method, apparatus, device and storage medium for secondary development of plug-ins are provided. According to the layer application object tree specification, the plug-in is supported to perform adjustment and enhanced function development based on the application. In the coding, startup and operation stages, the plug-in code syntax, code prompt, model fitting, loader extension and other methods are used to enhance the function of the application plug-in, so that a certain balance is achieved among the core logic of the module application, personalized needs and industry needs. The technical problems that modular development is insufficient in supporting cross-industry products, which easily leads to complex and difficult configuration of products, as well as the limited extensibility of the plug-in mechanism and the inability to make fundamental adjustments to the baseline functions are solved. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] Figure 1 A flowchart of the method for secondary development of plug-ins in an embodiment of the present application;

[0046] Figure 2 This is a schematic diagram of the structure of the plug-in secondary development processing device in the embodiment of the present application;

[0047] Figure 3 It is a structural diagram of the plug-in secondary development processing device in the embodiment of the present application. DETAILED DESCRIPTION

[0048] In order to enable those skilled in the art to better understand the solution of the present application, the technical solution in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of this application.

[0049] This application designs a plug-in secondary development processing method, device, equipment and storage medium, which solves the technical problems that modular development is insufficient in cross-industry product support, which easily leads to products becoming complex and difficult to configure, as well as the limited extensibility of the plug-in mechanism and the inability to make fundamental adjustments to benchmark functions.

[0050] For easier understanding, see Figure 1 , Figure 1 Flow chart of the method for secondary development of plug-in in the embodiment of the present application. Figure 1 As shown, specifically:

[0051] Step S1, determine the object tree of the target application, the object tree includes a data dictionary, a screen structure, a menu interface, and a secondary development type;

[0052] It should be noted that the technical solution of the present application is applied to the flexible design platform, using the development assistant of the flexible design platform Studio to create a new plug-in function in the plug-in management and create a plug-in for the specified application.

[0053] Use the flexible design platform designer to design the application object tree, including data dictionary, screen structure, menu interface and secondary development type.

[0054] The data dictionary is a collection of all data elements in the application, including database tables, fields, data types, lengths, and other information. It defines the structure and relationship of data and is the basis for database design and application development. In the flexible design platform, the design of the data dictionary allows developers to define and manage the data models used in the application.

[0055] Screen structure refers to the layout and composition of the user interface (UI). In the flexible design platform, developers can design and customize the user interface, including the layout of windows, dialog boxes, forms, etc. This involves the placement, size, style of controls, and the interaction logic between them.

[0056] The menu interface refers to the menu system in the application where users interact with the system, including the main menu, submenus, shortcut menus, etc. In the flexible design platform, developers can define menu items, menu structures, menu behaviors, and their associations with application functions.

[0057] In the flexible design platform, the designer provides a visual environment that allows developers to intuitively perform the above design work. This environment usually includes tools such as drag-and-drop interface, property editor, event handler, etc. to help developers build and customize the application object tree. In this way, developers can quickly build the framework of the application, and then further develop and customize it on this basis.

[0058] Step S2: If the secondary development type is adjustment enhancement type, determine whether plug-in secondary development is supported according to the type of the selected node;

[0059] Furthermore, step S2 specifically includes:

[0060] If the secondary development type is adjustment enhancement, determine whether the type of the selected node is any of the Enum type node, Table type node, Form type node, MenuItem type node, Menu type node or FormDataSource type node. If so, plug-in secondary development is supported, otherwise plug-in secondary development is not supported.

[0061] It should be noted that during the plug-in development process, based on the GOT (Guideline of Transformation) specification, the designer will determine whether adjustment and enhancement are supported based on the selected node type.

[0062] GOT specification refers to a set of rules and standards that should be followed in the development process of plug-ins. These specifications ensure the compatibility of plug-ins with the main application and define how plug-ins can extend or modify the functions of the main application.

[0063] Enum: An enumeration type node may allow plugin developers to add new enumeration values ​​or modify the definition of existing enumeration values ​​to suit specific business needs.

[0064] Table: A table type node may allow plugin developers to add new columns, modify the properties of existing columns, or adjust the behavior of the table.

[0065] Form: A form type node may allow plugin developers to add new input fields, modify the properties of existing fields, or adjust the form's layout and validation logic.

[0066] MenuItem: A menu item type node may allow plugin developers to add new menu items or modify the properties of existing menu items to extend the application's navigation structure.

[0067] Menu: Menu type nodes may allow plugin developers to add new menus or modify the structure of existing menus to suit different user interface requirements.

[0068] For the three types of nodes, Table, Form, and FormDataSource, the plug-in specification provides limited secondary development entry points, which means that developers can perform specific operations on these nodes, but these operations are limited to ensure that they do not undermine the stability and consistency of the main application.

[0069] For example, developers might be allowed to add new fields or modify the properties of existing fields, but not be allowed to change the database structure or affect the functionality of other plugins.

[0070] The plugin specification will clearly define which parts can be modified and which cannot be modified. This limited scope of openness ensures that plugin modifications will not cause unforeseen impacts on the main application, while also protecting the core functions of the main application from being destroyed.

[0071] The scope of opening may include customization of interface elements, expansion of business logic, enhancement of data processing, etc., but will not include modifications to the core system architecture.

[0072] Step S3: If supported, obtain the plug-in secondary development code for the selected node; otherwise, issue a restriction prompt;

[0073] Step S4: Perform real-time code checking and prompting on the plug-in secondary development code, and filter and display the development elements corresponding to the plug-in secondary development code;

[0074] Step S5: Aggregate the first application object model of the target application according to the secondary development type and the plug-in secondary development code to obtain a second application object model of the target application;

[0075] Step S6: Load the second application object model.

[0076] Furthermore, after step S1, the following steps are further included:

[0077] If the secondary development type is incremental, the plug-in secondary development code for the target application is obtained.

[0078] Furthermore, step S4 specifically includes:

[0079] When the plug-in secondary development code contains a database query statement, determine whether the database query statement is a query reference to the corresponding data of the current plug-in. If so, the real-time code check passes, otherwise, an invalid reference prompt is given;

[0080] Filter and display the development elements corresponding to the current plug-in, including class elements, method elements, and variable elements.

[0081] It should be noted that during the coding process, the development environment will provide code checking and prompting functions to help developers identify potential errors, irregular coding practices or performance issues. These prompts may include syntax errors, undefined variables, possible null pointer exceptions, etc.

[0082] Only query references to the current plugin related content are supported: This means that when writing database query statements, only data directly related to the current plugin can be queried. This is to ensure that the database operations of the plugin will not affect or interfere with the data of other plugins or systems, thereby maintaining the encapsulation and security of the data.

[0083] For example, if a plugin manages user information, it can only query database tables related to user information, but cannot access other data such as order information or product information.

[0084] Restrictions based on Java syntax: This means that when coding, you must follow the syntax rules of the Java language. The development environment may provide some tools or plug-ins to help developers follow these rules, such as code formatting tools, static code analysis tools, etc.

[0085] Filter the display of the current application plug-in: This means that the development environment will limit the developer's vision and only display the code elements such as classes, methods, variables, etc. related to the current plug-in. The purpose of this is to reduce interference, allowing developers to focus on the development of the current plug-in and avoid conflicts with other plug-ins or system components.

[0086] In the secondary development environment, code assistance tools are integrated, such as IntelliSense, code completion, refactoring tools, etc. These tools can help developers write code quickly while reducing errors.

[0087] These tools provide code hints based on the context of the current plugin. For example, when a developer starts writing a method call, IntelliSense displays a list of methods available in the current plugin instead of all possible methods, thereby improving development efficiency and accuracy.

[0088] Furthermore, step S5 specifically includes:

[0089] If the secondary development type is adjustment enhancement, the incremental content in the plug-in secondary development code is fitted into the first application object model of the target application based on the node type and breadth-first principle, taking the entity content node as the unit, to obtain the second application object model of the target application;

[0090] If the secondary development type is incremental, all contents in the plug-in secondary development code are merged into the first application object model of the target application in units of entity content nodes to obtain the second application object model of the target application.

[0091] It should be noted that adjustment-type aggregation involves modifying or optimizing certain parts of the existing application model. This type of aggregation takes the entity content node as the basic unit, and fits the incremental content of the plug-in into the application entity node according to the node type, breadth-first and other principles to form a complete application entity node. This means that in the aggregation process, it is not just about adding new content, but may also involve adjusting and optimizing existing content to ensure that new and old content can be seamlessly integrated to improve the overall performance of the application and user experience. This method is suitable for application scenarios that require optimization or adjustment of existing functions, such as improving the user interface or optimizing the data processing process.

[0092] Incremental aggregation refers to adding new functions or data to the application model without changing the structure of the existing model. This aggregation takes entity nodes as units and merges new plug-in content into the application object model. In simple terms, it is to add new functional modules or data nodes on the basis of the existing application model, so that the application model can support more functions or process more data without modifying the original model structure. This method is suitable for application scenarios that need to continuously expand new functions or add new data.

[0093] In summary, incremental aggregation focuses on the expansion of functions and the addition of new data, while adjustment aggregation focuses more on the optimization and adjustment of existing functions. These two aggregation methods work together to enable the application model to flexibly adapt to changing business needs and technological developments.

[0094] Furthermore, step S6 specifically includes:

[0095] Pre-configure plugin class loaders based on parent delegation mechanism;

[0096] Based on the benchmark application loader, the plug-in class loader is expanded horizontally;

[0097] The second application object model is loaded through the base application loader and the plug-in class loader.

[0098] It should be noted that in Java, the class loader is the component responsible for loading .class files into the JVM. In order to support dynamic loading of application plug-ins, we need to customize a class loader, which will be extended based on the traditional parent delegation mechanism.

[0099] Java's class loader architecture follows the Parent Delegation Model, which means that when a class loader tries to load a class, it first delegates the task to the parent class loader. If the parent class loader cannot complete the load (i.e., the class is not found), the child class loader will try to load it itself.

[0100] We extend the plugin class loader horizontally on top of the base application loader, which means that our custom class loader is not a layer in the parent delegation hierarchy, but parallel to the application class loader. This way, we can load plugin classes that are not part of the base application class path.

[0101] Our custom class loader supports lateral loading of bytecode-related data types and data of application plugins. This means that it can load plugin bytecode in parallel with the main application, rather than loading from top to bottom or bottom to top through a parent delegation mechanism.

[0102] The role of the class loader is to load the bytecode file into the JVM and generate the corresponding Class object, which serves as the access entry for various data of this class in the method area.

[0103] In actual applications, hot loading of jar packages can be achieved through the addURL method of URLClassLoader, which means dynamically adding new jar packages to the class loading path without restarting the application.

[0104] Through the above steps, we can effectively aggregate application plug-ins into a single application model when aggregating application models during the system startup phase, while maintaining the integrity of the parent delegation mechanism and the independence of application plug-ins. This design not only ensures the flexibility of the application, but also maintains the stability and security of the system.

[0105] Furthermore, after step S6, the following steps are further included:

[0106] Using bytecode enhancement technology to enhance the object instance of the Table type object in the second application object model;

[0107] The object instance enhancement is performed on the object of the Form type in the second application object model by using the interception method.

[0108] It should be noted that object instance enhancement refers to dynamically adding additional properties or behaviors to an existing class at runtime without modifying the original class code. This practice is often used in plugin systems, allowing plugins to add new functionality to the host program's classes.

[0109] For objects of type Table, bytecode enhancement is used. Bytecode enhancement involves dynamically modifying the bytecode of a class at class loading time or runtime. In this case, enhancement may involve adding new fields (attributes) or methods to the Table object.

[0110] Incremental field fitting: This means that new fields defined in the plugin are added to the instance of the Table object. For example, if the plugin needs to add additional data columns to the data table, these columns are fitted as incremental fields to the existing Table object instance, thereby extending its functionality.

[0111] For objects of type Form, enhancement is achieved by intercepting method execution, which is a dynamic proxy technology that allows intervention and modification of method call behavior without changing the original class code.

[0112] Method execution is dispatched to the plugin: This means that when a method of the Form object is called, the call is first intercepted and then redirected to the corresponding implementation in the plugin. This allows you to add new logic processing or modify existing logic without modifying the original Form class.

[0113] Enhancement technology enables plug-ins to add new functions to the Table and Form objects of the host program without changing the original code of these objects. This provides a high degree of scalability and customization for the host program while maintaining the stability and security of the main program.

[0114] See also Figure 2 , Figure 2 Schematic diagram of the structure of the plug-in secondary development processing device in the embodiment of the present application, such as Figure 2 As shown, specifically:

[0115] The object tree determination unit 201 is used to determine the object tree of the target application, the object tree includes a data dictionary, a screen structure, a menu interface and a secondary development type;

[0116] The judging unit 202 is used to judge whether the plug-in secondary development is supported according to the type of the selected node if the secondary development type is the adjustment enhanced type;

[0117] The processing unit 203 is used to obtain the plug-in secondary development code for the selected node if supported, otherwise, to issue a restriction prompt;

[0118] The checking unit 204 is used to perform real-time code checking and prompting on the plug-in secondary development code, and filter and display the development elements corresponding to the plug-in secondary development code;

[0119] Aggregation unit 205, configured to aggregate the first application object model of the target application according to the secondary development type and the plug-in secondary development code to obtain a second application object model of the target application;

[0120] The loading unit 206 is configured to load the second application object model.

[0121] The present application embodiment also provides another plug-in secondary development processing code upgrade device, such as Figure 3 As shown, the device 10 includes:

[0122] One or more processors 110 and memory 120, Figure 3 A processor 110 is used as an example for description. The processor 110 and the memory 120 may be connected via a bus or other means. Figure 3 The example of connecting through bus is taken in the following.

[0123] The processor 110 is used to complete various control logics of the device 10, and it can be a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA), a single-chip microcomputer, an ARM (Acorn RISCMachine) or other programmable logic device, a discrete gate or transistor logic, a discrete hardware component, or any combination of these components. In addition, the processor 110 can also be any traditional processor, microprocessor or state machine. The processor 110 can also be implemented as a combination of computing devices, for example, a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors combined with a DSP and / or any other such configuration.

[0124] The memory 120 is a non-volatile computer-readable storage medium that can be used to store non-volatile software programs, non-volatile computer executable programs and modules, such as program instructions corresponding to the method for constructing a multilingual phoneme representation model in the embodiment of the present invention. The processor 110 executes various functional applications and data processing of the device 10 by running the non-volatile software programs, instructions and units stored in the memory 120, that is, implements the method for constructing a multilingual phoneme representation model in the above method embodiment.

[0125] The memory 120 may include a program storage area and a data storage area, wherein the program storage area may store an operating system and applications required for at least one function; the data storage area may store data created according to the use of the device 10, etc. In addition, the memory 120 may include a high-speed random access memory, and may also include a non-volatile memory, such as at least one disk storage device, a flash memory device, or other non-volatile solid-state storage device. In some embodiments, the memory 120 may optionally include a memory remotely arranged relative to the processor 110, and these remote memories may be connected to the device 10 via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0126] One or more units are stored in the memory 120, and when executed by one or more processors 110, the following steps are implemented:

[0127] Step S1, determine the object tree of the target application, the object tree includes a data dictionary, a screen structure, a menu interface, and a secondary development type;

[0128] Step S2: If the secondary development type is adjustment enhancement type, determine whether plug-in secondary development is supported according to the type of the selected node;

[0129] Step S3: If supported, obtain the plug-in secondary development code for the selected node; otherwise, issue a restriction prompt;

[0130] Step S4: Perform real-time code checking and prompting on the plug-in secondary development code, and filter and display the development elements corresponding to the plug-in secondary development code;

[0131] Step S5: Aggregate the first application object model of the target application according to the secondary development type and the plug-in secondary development code to obtain a second application object model of the target application;

[0132] Step S6: Load the second application object model.

[0133] The embodiment of the present application also provides a computer-readable storage medium for storing program code, wherein the program code is used to execute any one of the implementation methods of a plug-in secondary development processing method described in the aforementioned embodiments.

[0134] In the embodiments of the present application, a method, apparatus, device and storage medium for secondary development of a plug-in are provided. According to the layer application object tree specification, the plug-in is supported to develop adjustment and enhanced functions based on the application. In the coding, startup and operation stages, the plug-in code syntax, code prompts, model fitting, loader extension and other methods are used to enhance the function of the application plug-in, so that a certain balance is achieved among the core logic of the module application, personalized needs and industry needs. The technical problems that modular development is insufficient in supporting cross-industry products, which easily leads to complex and difficult configuration products, as well as the limited extensibility of the plug-in mechanism and the inability to make fundamental adjustments to the baseline functions are solved.

[0135] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0136] The terms "first", "second", "third", "fourth", etc. (if any) in the specification of the present application and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments of the present application described herein can be implemented in an order other than those illustrated or described herein, for example. In addition, the terms "including" and "having" and any of their variations are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units that are clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0137] It should be understood that in this application, "at least one (item)" means one or more, and "plurality" means two or more. "And / or" is used to describe the association relationship of associated objects, indicating that three relationships may exist. For example, "A and / or B" can mean: only A exists, only B exists, and A and B exist at the same time, where A and B can be singular or plural. The character " / " generally indicates that the objects associated before and after are in an "or" relationship. "At least one of the following" or similar expressions refers to any combination of these items, including any combination of single or plural items. For example, at least one of a, b or c can mean: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", where a, b, c can be single or multiple.

[0138] In the several embodiments provided in the present application, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be an indirect coupling or communication connection through some interfaces, devices or units, which can be electrical, mechanical or other forms.

[0139] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0140] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0141] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or the part that contributes to the prior art or all or part of the technical solution can be embodied in the form of a software product. The computer software product is stored in a storage medium, including several instructions to enable a computer device (which can be a personal computer, server, or network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (full name in English: Read-Only Memory, English abbreviation: ROM), random access memory (full name in English: Random Access Memory, English abbreviation: RAM), disk or optical disk and other media that can store program codes.

[0142] As described above, the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A plug-in secondary development processing method, characterized in that: include: Step S1, determining an object tree of a target application, wherein the object tree includes a data dictionary, a screen structure, a menu interface, and a secondary development type, wherein the secondary development type includes an adjustment enhancement type and an incremental type; Step S2: if the secondary development type is adjustment enhanced, determine whether the type of the selected node is any one of an Enum type node, a Table type node, a Form type node, a MenuItem type node, a Menu type node or a FormDataSource type node; if so, plug-in secondary development is supported; otherwise, plug-in secondary development is not supported; Step S3: if supported, obtain the plug-in secondary development code for the selected node; otherwise, issue a restriction prompt; Step S4: when the plug-in secondary development code contains a database query statement, determine whether the database query statement is a query reference to the corresponding data of the current plug-in, if so, the real-time code check passes, otherwise, a prompt is given that the reference is invalid; filter and display the development elements corresponding to the current plug-in, the development elements include class elements, method elements and variable elements; Step S5: aggregating the first application object model of the target application according to the secondary development type and the plug-in secondary development code to obtain the second application object model of the target application: if the secondary development type is the adjustment enhancement type, taking the entity content node as a unit, according to the node type and the breadth-first principle, fitting the incremental content in the plug-in secondary development code to the first application object model of the target application to obtain the second application object model of the target application; if the secondary development type is the incremental type, taking the entity content node as a unit, merging all the contents in the plug-in secondary development code to the first application object model of the target application to obtain the second application object model of the target application; Step S6: Load the second application object model.

2. The plug-in secondary development processing method according to claim 1, characterized in that: After step S1, the following steps are also included: If the secondary development type is incremental, a plug-in secondary development code for the target application is obtained.

3. The plug-in secondary development processing method according to claim 1, characterized in that: The step S6 specifically includes: Pre-configure plugin class loaders based on parent delegation mechanism; Based on the benchmark application loader, the plug-in class loader is expanded horizontally; The second application object model is loaded by the base application loader and the plug-in class loader.

4. The plug-in secondary development processing method according to claim 1, characterized in that: After step S6, the following steps are also included: S7. Perform object instance enhancement on the Table type object in the second application object model using bytecode enhancement technology; S8. Using an interception method to perform object instance enhancement on an object of the Form type in the second application object model.

5. A plug-in secondary development processing device, characterized in that: include: An object tree determination unit, used to determine an object tree of a target application, wherein the object tree includes a data dictionary, a screen structure, a menu interface, and a secondary development type, wherein the secondary development type includes an adjustment enhancement type and an incremental type; a judgment unit, for judging whether the type of the selected node is any one of an Enum type node, a Table type node, a Form type node, a MenuItem type node, a Menu type node or a FormDataSource type node if the secondary development type is an adjustment enhanced type, and if so, supporting plug-in secondary development, otherwise not supporting plug-in secondary development; A processing unit, configured to obtain the plug-in secondary development code for the selected node if supported, and to provide a restriction prompt otherwise; The checking unit is used to determine whether the database query statement is a query reference to the corresponding data of the current plug-in when the plug-in secondary development code contains a database query statement. If so, the real-time code check passes, otherwise, a prompt is given that the reference is invalid; filter and display the development elements corresponding to the current plug-in, the development elements including class elements, method elements and variable elements; an aggregation unit, configured to aggregate the first application object model of the target application according to the secondary development type and the plug-in secondary development code to obtain the second application object model of the target application: if the secondary development type is the adjustment enhancement type, then taking the entity content node as a unit, according to the node type and the breadth-first principle, the incremental content in the plug-in secondary development code is fitted into the first application object model of the target application to obtain the second application object model of the target application; if the secondary development type is the incremental type, then taking the entity content node as a unit, all the contents in the plug-in secondary development code are merged into the first application object model of the target application to obtain the second application object model of the target application; A loading unit is used to load the second application object model.

6. A plug-in secondary development processing device, characterized in that: The device comprises a processor and a memory: The memory is used to store program code and transmit the program code to the processor; The processor is used to execute the plug-in secondary development processing method according to any one of claims 1 to 4 according to the instructions in the program code.

7. A computer-readable storage medium, characterized in that: The computer-readable storage medium is used to store program codes, and the program codes are used to execute the plug-in secondary development processing method according to any one of claims 1 to 4.

Images