Component processing methods, systems, electronic devices, and storage media

Abstract

This application relates to a component processing method, system, electronic device, and storage medium, comprising: generating a component project for a target component; establishing an assembly for the target component; generating file paths for a component dynamic library, a view file, a first static resource file, and a second static resource file based on the assembly of the target component; wherein, the component dynamic library is located on a main site, the main site includes a common framework dynamic library, a common static resource folder, and a common view folder, the common framework dynamic library includes environment files required to run the target component; the view file and the first static resource file are both located in the common view folder, the view file references the file path of the second static resource file, and the second static resource file is stored in the common static resource folder. This application solves the problems of redundant site files and low maintenance efficiency in software development based on the MVC component-based development framework, achieving simplification of site files and improved maintenance efficiency.

Description

Technical Field

[0001] This application relates to the field of software development, and in particular to component processing methods, systems, electronic devices, and storage media. Background Technology

[0002] Modern software systems are complex, with numerous functional modules, requiring collaboration and joint development by multiple teams or individuals to complete. To optimize the software development process, improve efficiency, and reduce system coupling, component-based development frameworks are essential.

[0003] While related technologies have implemented component-based development, when creating software applications using existing component-based development frameworks, each component module has its own independent storage folder. This folder contains the corresponding dynamic libraries for each component, common framework dynamic libraries, view interfaces, and common front-end static resource files. When the application software includes multiple modules, multiple components must be created. As the number of application modules increases, the total size of the site files continues to grow. Furthermore, during software upgrades, the number of component folders that need to be upgraded and replaced, along with the numerous replacement steps, is excessive, hindering site upgrades and maintenance.

[0004] There is currently no effective solution to the problems of redundant site files and low maintenance efficiency when developing software based on the MVC component-based development framework. Summary of the Invention

[0005] This embodiment provides a component processing method, system, electronic device, and storage medium to solve the problems of redundant site files and low maintenance efficiency when developing software based on the MVC component-based development framework in related technologies.

[0006] Firstly, this embodiment provides a component processing method, including:

[0007] Generate the component project of the target component and establish the assembly of the target component;

[0008] The file paths for generating the component dynamic library, view file, first static resource file, and second static resource file are generated based on the assembly of the target component; wherein,

[0009] The component dynamic library is located on the main site, which includes a public framework dynamic library, a public static resource folder, and a public view folder. The public framework dynamic library includes the environment files required to run the target component.

[0010] Both the view file and the first static resource file are located in the public view folder. The view file references the file path of the second static resource file, which is stored in the public static resource folder.

[0011] In some embodiments, the assembly for building the target component includes:

[0012] In the component project, create the view, controller, and model of the target component;

[0013] The business logic of the target component is implemented through the view, the controller, and the model, and the assembly of the target component is generated.

[0014] In some embodiments, generating a component project for the target component includes:

[0015] Establish a component project for the target component according to the preset naming rules;

[0016] Set a first authorization deadline for the target component, wherein the target component is accessible to users within the first authorization deadline, and is prohibited from user access outside the first authorization deadline.

[0017] In some embodiments, after determining the authorization deadline for the component project, the method further includes:

[0018] Based on the first authorization expiration date, determine whether the target component allows user access;

[0019] If it is determined that the target component is restricted from user access, the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file are moved to a specified directory.

[0020] In some embodiments, after transferring the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file to a specified directory, the method further includes:

[0021] Set a second authorization expiration date for the target component;

[0022] Based on the second authorization expiration date, determine whether the target component allows user access;

[0023] If it is determined that the target component allows user access, restore the storage location of the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file.

[0024] In some embodiments, after generating the component project of the target component, the method further includes:

[0025] Upon receiving an access instruction for the target component, the view file, the component dynamic library, and the first static resource file of the target component are loaded in the public view folder, and the second static resource file is loaded according to the file path.

[0026] In some embodiments, loading the view file of the target component in the public view folder includes:

[0027] Locate the view file of the target component;

[0028] If the view file is found, load the view file;

[0029] If the view file is not found, load the error message view.

[0030] Secondly, this embodiment provides a component processing system, including: a generation module and a display module, wherein the generation module is connected to the display module; wherein,

[0031] The generation module is used to execute the component processing method described in the first aspect above;

[0032] The display module is used to present the components processed by the generation module to the user.

[0033] Thirdly, this embodiment provides an electronic device including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the component processing method described in the first aspect above.

[0034] Fourthly, this embodiment provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the component processing method described in the first aspect above.

[0035] Compared with related technologies, the component processing method provided in this embodiment includes: generating a component project of the target component and establishing an assembly of the target component; generating file paths for a component dynamic library, a view file, a first static resource file, and a second static resource file based on the assembly of the target component; wherein, the component dynamic library is located on the main site, the main site includes a common framework dynamic library, a common static resource folder, and a common view folder, the common framework dynamic library includes environment files required to run the target component; the view file and the first static resource file are both located in the common view folder, the view file references the file path of the second static resource file, and the second static resource file is stored in the common static resource folder. This solves the problem of redundant site files and low maintenance efficiency when developing software based on the MVC component-based development framework, and achieves simplification of site files and improvement of maintenance efficiency.

[0036] Details of one or more embodiments of this application are set forth in the following drawings and description to make other features, objects and advantages of this application more readily apparent. Attached Figure Description

[0037] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0038] Figure 1 This is a hardware structure block diagram of a terminal for a component processing method according to an embodiment of this application;

[0039] Figure 2 This is a flowchart of a component processing method according to an embodiment of this application;

[0040] Figure 3 This is a flowchart of a component processing method in the MVC component-based development framework according to an embodiment of this application;

[0041] Figure 4 This is a structural diagram of a component processing system according to an embodiment of this application. Detailed Implementation

[0042] To better understand the purpose, technical solution, and advantages of this application, the application is described and illustrated below in conjunction with the accompanying drawings and embodiments.

[0043] Unless otherwise defined, the technical or scientific terms used in this application shall have the general meaning as understood by one of ordinary skill in the art to which this application pertains. Words such as “a,” “an,” “an,” “the,” “the,” and “these,” used in this application, do not indicate quantitative limitation and may be singular or plural. The terms “comprising,” “including,” “having,” and any variations thereof used in this application are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or device that comprises a series of steps or modules (units) is not limited to the listed steps or modules (units) but may include steps or modules (units) not listed, or may include other steps or modules (units) inherent to such processes, methods, products, or devices. The terms “connected,” “linked,” and “coupled,” used in this application, are not limited to physical or mechanical connections but may include electrical connections, whether direct or indirect. The term “multiple” used in this application refers to two or more. The "and / or" operator describes the relationship between related objects, indicating that three relationships can exist. For example, "A and / or B" can represent three cases: A alone, A and B simultaneously, and B alone. Typically, the character " / " indicates that the objects before and after it are in an "or" relationship. The terms "first," "second," and "third," etc., used in this application are merely for distinguishing similar objects and do not represent a specific ordering of the objects.

[0044] The method embodiments provided in this example can be executed on a terminal, computer, or similar computing device. For example, it can run on a terminal. Figure 1 This is a hardware structure block diagram of a terminal for a component processing method according to an embodiment of this application. For example... Figure 1 As shown, a terminal may include one or more ( Figure 1 Only one is shown in the diagram. A processor 102 and a memory 104 for storing data are also included. The processor 102 may be, but is not limited to, a microprocessor (MCU) or a programmable logic device (FPGA). The terminal may also include a transmission device 106 for communication functions and an input / output device 108. Those skilled in the art will understand that… Figure 1 The structure shown is for illustrative purposes only and does not limit the structure of the terminal described above. For example, the terminal may also include components that are larger than... Figure 1 The more or fewer components shown, or having the same Figure 1 The different configurations shown are illustrated.

[0045] The memory 104 can be used to store computer programs, such as application software programs and modules, like the computer program corresponding to the component processing method in this embodiment. The processor 102 executes various functional applications and data processing by running the computer program stored in the memory 104, thereby implementing the above-described method. The memory 104 may include high-speed random access memory and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 104 may further include memory remotely located relative to the processor 102, and these remote memories can be connected to the terminal via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0046] The transmission device 106 is used to receive or send data via a network. This network includes a wireless network provided by the terminal's communication provider. In one example, the transmission device 106 includes a Network Interface Controller (NIC), which can connect to other network devices via a base station to communicate with the Internet. In another example, the transmission device 106 can be a Radio Frequency (RF) module used for wireless communication with the Internet.

[0047] This embodiment provides a component processing method. Figure 2 This is a flowchart of the component processing method in this embodiment, such as... Figure 2 As shown, the process includes the following steps:

[0048] Step S201: Generate the component project of the target component and establish the assembly of the target component;

[0049] Create a new project based on the MVC component-based development framework, and create different view, controller, model and other files in the component project to obtain the assembly of the target component.

[0050] Step S202: Generate the file paths of the component dynamic library, view file, first static resource file, and second static resource file based on the assembly of the target component; wherein,

[0051] The component dynamic library is located on the main site, which includes a common framework dynamic library, a common static resource folder, and a common view folder. The common framework dynamic library includes the environment files required to run the target component. The view file and the first static resource file are both located in the common view folder. The view file references the file path of the second static resource file, which is stored in the common static resource folder.

[0052] The main site refers to the common modules or runtime environment required for the software to run the target component. The common framework dynamic library under the main site includes a series of program files that provide the basic environment for component operation; the common static resource folder under the main site contains common static resources. Placing the common framework dynamic library and common static resource folder under the main site facilitates loading the common environment required for the main site and component projects to run.

[0053] The assembly of the target component is compiled, yielding the file paths of the component's dynamic library, view file, first static resource file, and second static resource file. The component's dynamic library, containing all the dynamic libraries required for the target component to run, is output to the main site. The file paths of the view file, first static resource file, and second static resource file are also output to the common view folder on the main site. The common view folder contains the target component's view file and first static resource file. The first static resource file is unique to the target component, and the view file references the file path of the second static resource file, which is a static resource file required for the target component to run within the common static resource folder. By reducing the number of files required for a single component project and the overall number of files required for a multi-component system, the system's compilation efficiency is improved.

[0054] Through the above steps, the common framework dynamic library and common static resource folder are stored under the main site. When the target component is generated, there is no need to repeatedly generate the common framework dynamic library and common static resource files, simplifying the number of site files and optimizing the project compilation logic. Only the component-specific component dynamic library, the first static resource file, and the view file are generated. Furthermore, the view file references the second static resource file in the common static resource file through file paths, further reducing the number of files generated when building the component and improving the component compilation efficiency. Since the common framework dynamic library and common static resource files are only located in one place, when the main site needs maintenance or upgrades, the number of files that need to be replaced or modified is reduced, and the steps required for maintenance and upgrades are reduced, improving the efficiency of main site maintenance and upgrades. This solves the problems of site file redundancy and low maintenance efficiency, achieving site file simplification and improved site maintenance efficiency.

[0055] In some embodiments, building the target component's assembly includes: creating the target component's view, controller, and model in the component project; implementing the target component's business logic through the view, controller, and model, and generating the target component's assembly. Different view, controller, and model files are created in the component project to obtain the target component's assembly. A layered structure is achieved by creating a common class library, thereby implementing the target component's business logic. Optionally, the first layer is the view layer, used to display the interface on the front end; the second layer is the data model layer, including various data models; and the third layer is the business logic layer, which assembles the data, implements the component's business logic, and returns it to the view layer. Corresponding business logic is implemented in different business logic layers.

[0056] Generating the component project for the target component includes: creating the component project for the target component according to preset naming rules; setting the first authorization deadline for the target component, where users are allowed to access the target component within the first authorization deadline, and users are prohibited from accessing the component project outside the first authorization deadline. After creating a new project, enter the component project name according to the preset naming rules to create the component project for the target component. The preset naming rules include: class names must begin with an uppercase letter; class variable names must begin with a lowercase letter, and if the variable name contains multiple words, the first letter of the second and subsequent words must be uppercase; method names must begin with a lowercase letter, and if the method name contains multiple words, the first letter of the second and subsequent words must be uppercase; all letters in constants must be uppercase, and if the constant contains multiple words, the words must be separated by "_". Setting the first authorization deadline for the target component includes receiving the first authorization deadline log input by the user and converting the first authorization deadline into encrypted data for storage.

[0057] After determining the authorization deadline for the component project, the method further includes: determining whether the target component allows user access based on the first authorization deadline; if it is determined that the target component prohibits user access, transferring the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file to a specified directory. After transferring the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file to the specified directory, the method further includes: setting a second authorization deadline for the target component; determining whether the target component allows user access based on the second authorization deadline; if it is determined that the target component allows user access, restoring the storage location of the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file.

[0058] The first authorization expiration date, stored in encrypted form, is decrypted, and the current date is used to determine whether the target component allows user access. Optionally, if user access to the target component is prohibited, the expiration time of the target component is checked: if the expiration time is not greater than a preset time, the target component is not loaded and user access is prohibited; if the expiration time is greater than the preset time, user access is prohibited, and the file paths of the target component's dynamic library, view files, first static resource file, and second static resource file are moved to a specified directory. For expired target components, a second authorization expiration date is set. After the target component is re-authorized, the relevant files of the target component are restored from the specified directory to the main site. Setting authorization periods and moving component-related files achieves reasonable utilization of storage space, which is beneficial to improving the maintenance efficiency of the main site.

[0059] In some embodiments, after generating the component project of the target component, the method further includes: upon receiving an access instruction for the target component, loading the target component's view file, component dynamic library, and first static resource file in a public view folder, and loading a second static resource file according to a file path. Loading the target component's view file in the public view folder includes: locating the target component's view file; if the view file is found, loading the view file; if the view file is not found, loading an error message view.

[0060] Upon receiving an access command from the target component, the UI rendering engine searches for the corresponding view file in the public view folder. If the view file is found, it is presented to the user; otherwise, an error message view is displayed. The error message view indicates that the view file does not exist. After the view file is found, the dynamic libraries and static resource files required for the target component to run are loaded.

[0061] In some of these embodiments, Figure 3 This is a flowchart of a component processing method based on the MVC component-based development framework, such as... Figure 3 As shown, the component processing method in this embodiment includes a component development stage, a project / component compilation stage, a system startup stage, and an interface rendering stage.

[0062] During the component development phase, after installing the project template required by the MVC component-based development framework and creating a new project, if the development framework itself has a license expiration date, that expiration date is read; otherwise, if a separate license expiration date needs to be determined for a component, that expiration date is entered. Based on the business logic required by the component, different view, controller, and model files are created in the component project. A layered structure is implemented by creating a common class library, including a view layer, a data model layer, and a business logic layer. The corresponding business logic is implemented in each business logic layer. The development tool automatically creates the software front-end interface and back-end service files based on the files included in the component project. The back-end service files provide data for the front-end interface.

[0063] During the project / component compilation phase, a common framework dynamic library, a common static resource folder, and a common view folder are generated under the main site. The common framework dynamic library is a series of program files that provide the basic environment for the software system to run. Specifically, when compiling the project, the common framework dynamic library is placed in a common folder under the main site to facilitate loading the common environment required for the main site and component projects to run, and to optimize the business logic required during project compilation. The common static resource folder is used to store common static resource files. During program pre-release, the project is compiled to obtain the compiled assembly. The compiled assembly includes dynamic libraries (DLLs), executable programs (EXEs), configuration files (web.config), and view files (xxx.cshtml).

[0064] Based on the compiled assembly, a folder named after the component project is generated under the main site. This folder contains the component's dynamic libraries, which are dynamic libraries specific to the component project and serve a particular functional module of the component. Simultaneously, view files for the component are generated, named after the current component project and stored in the common view folder. The view files reference the file paths of common static files in the common static resource folder.

[0065] During system startup, the common framework dynamic library is loaded to provide a common environment for the main site and component projects. Components within the authorized period are loaded according to the framework's license period. Components without authorization or with expired licenses are not loaded until their license period is reset and authorization is obtained. Components with expired licenses can be selected and restored using the restore function in the main framework after re-authorization. If the license period has expired by 30 days, the corresponding files for that component are automatically backed up to a specified directory, and files in the original path are removed. For components within the authorized period, the corresponding application module is accessed, and the component's view files are located. The access periods for different components or modules within the software system are categorized and stored according to the license period, making efficient use of storage space.

[0066] If the view file exists, it is displayed to the user in the browser; otherwise, a user-friendly message is displayed in the user interface. Since the component's view files are stored in the main site's public view folder, centralized management of the corresponding views for the component project is achieved, improving the efficiency of view lookup and rendering.

[0067] During the UI rendering phase, the UI rendering engine dynamically loads the resource files required for component operation, including component-specific resource files and public resource files. The resource files are program files, including dynamic libraries, CSS (style sheets) files, and JS (script) files.

[0068] The component processing method in this embodiment generates only the component's own dynamic library during compilation, while the common framework dynamic library adopts the main site's common framework dynamic library. This simplifies the compilation method for component-based development, reduces the number of common dynamic libraries to one location, lowers the site file size, facilitates site maintenance, and reduces the risk of incomplete file replacement during site maintenance. Dynamically generating component view files and static resource files under the main site enables centralized management of component view files and static resource files, improving the rendering engine's efficiency. This solves the problems of redundant site files and low maintenance efficiency in software development based on the MVC component-based development framework, achieving both site file simplification and improved maintenance efficiency.

[0069] It should be noted that the steps shown in the above process or in the flowchart of the accompanying figures can be executed in a computer system such as a set of computer-executable instructions, and although a logical order is shown in the flowchart, in some cases the steps shown or described may be executed in a different order than that shown here.

[0070] This embodiment also provides a component processing system for implementing the above embodiments and preferred embodiments; details already described will not be repeated. The terms "module," "unit," "subunit," etc., used below refer to combinations of software and / or hardware that perform a predetermined function. Although the apparatus described in the following embodiments is preferably implemented in software, hardware implementation, or a combination of software and hardware, is also possible and contemplated.

[0071] Figure 4 This is a structural diagram of the component processing system in this embodiment, as shown below. Figure 4 As shown, the component processing system includes: a generation module and a display module, wherein the generation module is connected to the display module; wherein,

[0072] The generation module is used to execute the component processing method described in the first aspect above;

[0073] The display module is used to present the components processed by the generation module to the user.

[0074] It should be noted that the above modules can be functional modules or program modules, and can be implemented through software or hardware. For modules implemented through hardware, the above modules can reside in the same processor; or the above modules can be located in different processors in any combination.

[0075] This embodiment also provides an electronic device including a memory and a processor, the memory storing a computer program and the processor being configured to run the computer program to perform the steps in any of the above method embodiments.

[0076] Optionally, the electronic device may further include a transmission device and an input / output device, wherein the transmission device is connected to the processor and the input / output device is connected to the processor.

[0077] Optionally, in this embodiment, the processor can be configured to perform the following steps via a computer program:

[0078] Step S201: Generate the component project of the target component and establish the assembly of the target component;

[0079] Step S202: Generate the file paths of the component dynamic library, view file, first static resource file, and second static resource file based on the assembly of the target component; wherein,

[0080] The component dynamic library is located on the main site, which includes a common framework dynamic library, a common static resource folder, and a common view folder. The common framework dynamic library includes the environment files required to run the target component. The view file and the first static resource file are both located in the common view folder. The view file references the file path of the second static resource file, which is stored in the common static resource folder.

[0081] It should be noted that the specific examples in this embodiment can refer to the examples described in the above embodiments and optional implementations, and will not be repeated in this embodiment.

[0082] Furthermore, in conjunction with the component processing methods provided in the above embodiments, this embodiment can also provide a storage medium for implementation. The storage medium stores a computer program; when executed by a processor, the computer program implements any of the component processing methods in the above embodiments.

[0083] It should be understood that the specific embodiments described herein are merely illustrative of the application and not intended to limit it. All other embodiments derived by those skilled in the art based on the embodiments provided in this application without inventive effort are within the scope of protection of this application.

[0084] Obviously, the accompanying drawings are merely some examples or embodiments of this application. Those skilled in the art can apply this application to other similar situations based on these drawings without any creative effort. Furthermore, it is understood that although the work done in this development process may be complex and lengthy, for those skilled in the art, certain design, manufacturing, or production modifications made based on the technical content disclosed in this application are merely conventional technical means and should not be considered as insufficient disclosure of this application.

[0085] The term "embodiment" in this application refers to a specific feature, structure, or characteristic described in connection with an embodiment that may be included in at least one embodiment of this application. The appearance of this phrase in various places in the specification does not necessarily imply the same embodiment, nor does it imply that it is mutually exclusive with or independent of other embodiments. It will be clearly or implicitly understood by those skilled in the art that the embodiments described in this application may be combined with other embodiments without conflict.

[0086] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of patent protection. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the appended claims.

Claims

1. A component processing method, characterized in that, include: Create a component project for the target component according to the preset naming rules; Set a first authorization deadline for the target component, wherein users are allowed to access the target component within the first authorization deadline, and users are prohibited from accessing the component project outside the first authorization deadline; In the component project, the view, controller, and model of the target component are established; the business logic of the target component is implemented through the view, the controller, and the model, and the assembly of the target component is generated; The file paths for generating the component dynamic library, view file, first static resource file, and second static resource file are generated based on the assembly of the target component; wherein, The component dynamic library is located on the main site, which includes a public framework dynamic library, a public static resource folder, and a public view folder. The main site contains the public modules or runtime environment required for the software to run the target component. The public framework dynamic library includes the environment files required to run the target component. Both the view file and the first static resource file are located in the public view folder. The first static resource file is a static resource file unique to the target component. The view file references the file path of the second static resource file. The second static resource file is stored in the public static resource folder, which includes public static resources. The second static resource file is a static resource file required for the target component to run. The method further includes: determining whether the target component allows user access based on the first authorization expiration date; if it is determined that the target component prohibits user access, transferring the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file to a specified directory; Set a second authorization expiration date for the target component; determine whether the target component allows user access based on the second authorization expiration date; if it is determined that the target component allows user access, restore the storage location of the file paths of the target component's component dynamic library, view file, first static resource file, and second static resource file.

2. The component processing method according to claim 1, characterized in that, After generating the component project of the target component, the method further includes: Upon receiving an access instruction for the target component, the view file, the component dynamic library, and the first static resource file of the target component are loaded in the public view folder, and the second static resource file is loaded according to the file path.

3. The component processing method according to claim 2, characterized in that, Load the view file of the target component in the public view folder, including: Locate the view file of the target component; If the view file is found, load the view file; If the view file is not found, load the error message view.

4. A component processing system, characterized in that, include: The system includes a generation module and a display module, with the generation module connected to the display module; wherein... The generation module is used to execute the component processing method according to any one of claims 1 to 3; The display module is used to present the components processed by the generation module to the user.

5. An electronic device comprising a memory and a processor, characterized in that, The memory stores a computer program, and the processor is configured to run the computer program to perform the component processing method according to any one of claims 1 to 3.

6. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the component processing method according to any one of claims 1 to 3.

Images