Front-end and rear-end decoupling method based on distributed MVC

Abstract

The invention discloses a front-end and rear-end decoupling method based on a distributed MVC (model view controller), which adopts an improved distributed MVC architecture, uniformly places a controller and a model object at a rear end for processing, and completely decouples service logic and interface display through a lightweight communication protocol, so that the front end is only responsible for interface rendering and interaction event capture, and the rear end is only responsible for interaction event capture. And the back end centrally processes complex logic. According to the method, data synchronization of the front end and the rear end is optimized through a resource identification mechanism, data are transmitted in a JSON format, the transmission quantity is reduced, the analysis efficiency is improved, and the system performance and expansibility are remarkably improved. Meanwhile, through modular process separation design, UI logic and calculation tasks run independently, high responsiveness of an interface is ensured, and system stability is enhanced. The method is suitable for a high-interaction scene and a distributed system, and solves the problems of overweight front-end load, low front-end and rear-end communication efficiency, high module coupling degree and the like in a traditional architecture.

Description

Technical Field

[0001] The present invention relates to the field of software architecture design and front-end and back-end interaction technology, and in particular to a front-end and back-end decoupling method based on distributed MVC. Background Art

[0002] MVC (Model-View-Controller) is a classic software architecture pattern that separates data, user interface, and business logic to achieve modularity and clear responsibilities. It is widely used in Web development and distributed systems. However, with the increase in high interactivity and complex business scenarios, the traditional MVC architecture has gradually exposed the following problems:

[0003] 1. The front-end is overloaded, affecting performance: In the traditional MVC architecture, the front-end is not only responsible for interface rendering, but also needs to handle some business logic, which leads to a decrease in interface response speed, especially in complex interactive scenarios.

[0004] 2. Low communication efficiency between the front-end and back-end: Frequent interaction events require data to be transmitted between the front-end and back-end, which is limited by network latency and transmission efficiency, resulting in an unsmooth user experience.

[0005] 3. High module coupling and poor scalability: The Controller and View layers are closely related, which makes function expansion and code maintenance difficult, and even affects system stability.

[0006] In order to solve the above problems, existing technologies attempt to optimize system performance by enhancing backend logic, introducing process isolation and resource identification mechanisms. For example, frontend logic is weakened to reduce burden, or stability is improved by process separation. However, these solutions often only solve a single problem and it is difficult to provide comprehensive optimization in high-interaction, high-performance scenarios.

[0007] Therefore, how to achieve efficient decoupling of the front-end and back-end in a complex system, reduce complexity, and improve system response speed and scalability has become a technical problem to be solved by the present invention. Summary of the invention

[0008] The technical problem solved by the present invention is to provide a front-end and back-end decoupling method based on distributed MVC in response to the defects existing in the above-mentioned prior art, so as to solve the problems of heavy front-end burden, low front-end and back-end communication efficiency and high module coupling degree of the traditional MVC architecture proposed in the above-mentioned background technology in high interactivity scenarios.

[0009] In order to solve the above technical problems, the technical solution adopted by the present invention is as follows:

[0010] A front-end and back-end decoupling method based on distributed MVC includes the following steps:

[0011] Serializing the controller object and model object running thereon into a JSON data format including a controller object identifier, a model object identifier and associated logic through a modular processing unit of the backend, and transmitting the JSON data format to the frontend;

[0012] The front end parses the received JSON data format, binds the corresponding controller object and model object to the front end view object, and renders the user interface;

[0013] During the process of user interaction with the front-end interface, the front-end captures the interaction events and transmits the interaction events to the controller object of the back-end through the instruction-based communication protocol;

[0014] The controller object at the back end executes the corresponding business logic based on the interaction event, and notifies the front end of the processing result through the model object;

[0015] The front end dynamically updates the corresponding view object based on the updated data of the received model object to reflect the business logic processing results;

[0016] Among them, the modular processing unit of the backend includes a process model for coordinating the task allocation of controller objects and model objects. The process model includes a main process for processing user interaction logic and a working process for task scheduling. The working process is responsible for data storage and processing of model objects.

[0017] As a further solution of the present invention, the working process of the process model includes the following components:

[0018] Unified scheduling module, used to coordinate the task allocation of controller objects and model objects, and manage the communication between the front-end and back-end;

[0019] The data storage module is used to handle disk IO operations and data persistence related to model objects to reduce the direct coupling between the front end and the task logic;

[0020] The resource management module is used to parse the resource identifier sent by the front end, load the corresponding resources and synchronize the resource data to the front end.

[0021] As a further solution of the present invention, the instruction-based communication protocol includes the following contents:

[0022] The specific method name to be called;

[0023] The corresponding callback event identifier;

[0024] A collection of parameters required for user interaction events to be passed.

[0025] As a further solution of the present invention, the updated data of the model object is transmitted to the front end in JSON format, and the JSON format includes the unique identifier of the model object, data structure description and data content, which is used for the front end to dynamically update the view object.

[0026] As a further solution of the present invention, the method realizes data synchronization between the front-end and the back-end through a resource identification mechanism. The resource identification is used to describe the images, icons or prompts required by the interface components. The front-end loads the corresponding resources according to the resource identification to complete the interface rendering.

[0027] As a further solution of the present invention, the view object receives the JSON data format transmitted by the backend through a unified API interface, and the API interface supports the rendering of multiple view components, including menu bars, toolbars, project trees, outlines and panels.

[0028] As a further solution of the present invention, the design of the process model follows the UI node separation principle, and runs the interface presentation part and the computationally intensive task processing part in independent processes to improve the interface response speed and enhance the system stability.

[0029] As a further solution of the present invention, the back-end controller object dynamically selects a business logic processing path based on the type of user interaction event, and after completing the processing, notifies the front-end view object of the updated data through the model object.

[0030] Compared with the prior art, the present invention has the following beneficial effects:

[0031] 1. The business logic of controller objects and model objects is all centralized in the backend for processing, making the frontend "lightweight" and making it only responsible for rendering views and capturing interactive events. This backend-driven design pattern greatly reduces the computing burden of the frontend and significantly improves the response speed of the interface, especially in highly interactive application scenarios, where the user experience is significantly optimized.

[0032] 2. A modular process model is adopted to run UI interaction logic and computationally intensive tasks in independent processes. The main process focuses on user interaction, and the working process focuses on task scheduling and data processing. This design reduces the interference of task processing on interface interaction through functional isolation, significantly improves system stability, and provides a good foundation for the independent expansion of functional modules.

[0033] 3. The complexity of front-end and back-end data synchronization is simplified through the resource identification mechanism. The back-end describes the resource information such as images and prompts required by the interface components in the form of resource identification, and the front-end dynamically loads resources according to the identification. This mechanism effectively reduces the amount of data transmission, while supporting rapid switching of multi-language internationalization, enhancing the flexibility and practicality of the system; and using JSON format to serialize and transmit controller objects and model objects. Compared with traditional complex data structures, the JSON format is lightweight and efficient to parse, which significantly improves the efficiency of data transmission and front-end parsing, and further improves the overall performance of the system.

[0034] Additional aspects and advantages of the present invention will be given in part in the following description and in part will be obvious from the following description, or will be learned through practice of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0035] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

[0036] Figure 1 It is the basic structure of the traditional MVC design pattern.

[0037] Figure 2 This is the MVC flow chart of the present invention.

[0038] Figure 3 A process is created for the tree-shaped project of the present invention.

[0039] Figure 4 This is the front-end and back-end interaction process of the present invention.

[0040] Figure 5 It is a flowchart of the toolbar operation of the present invention. DETAILED DESCRIPTION

[0041] The technical solutions in the embodiments of the present invention are described clearly and completely below. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of them. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0042] See also Figure 1 —5. In an embodiment of the present invention, a front-end and back-end decoupling method based on distributed MVC includes the following steps:

[0043] The controller object and model object running on it are serialized into a JSON data format containing a controller object identifier, a model object identifier and associated logic through the modular processing unit of the back end, and the JSON data format is transmitted to the front end; the front end parses the received JSON data format, binds the corresponding controller object and model object to the view object of the front end, and renders the user interface;

[0044] During the process of user interaction with the front-end interface, the front-end captures the interaction event and transmits the interaction event to the controller object of the back-end through the instruction-based communication protocol; the controller object of the back-end executes the corresponding business logic based on the interaction event and notifies the front-end of the processing result through the model object;

[0045] The front end dynamically updates the corresponding view object to reflect the business logic processing results based on the updated data of the model object received; wherein the modular processing unit of the back end includes a process model for coordinating the task allocation of controller objects and model objects, and the process model includes a main process for processing user interaction logic and a working process for task scheduling, and the working process is responsible for the data storage and processing of the model objects.

[0046] As a further solution of the present invention, the working process of the process model includes the following components:

[0047] The unified scheduling module is used to coordinate the task allocation of controller objects and model objects, and manage the communication between the front and back ends; the data storage module is used to handle disk IO operations and data persistence related to model objects to reduce the direct coupling between the front end and the task logic; the resource management module is used to parse the resource identifier sent by the front end, load the corresponding resources and synchronize the resource data to the front end.

[0048] As a further solution of the present invention, the instruction-based communication protocol includes the following contents: the specific method name to be called; the corresponding callback event identifier; and the parameter set required for the user interaction event transmission.

[0049] As a further solution of the present invention, the update data of the model object is transmitted to the front end in JSON format, and the JSON format includes the unique identifier of the model object, the data structure description and the data content, which is used for the front end to dynamically update the view object. The method realizes data synchronization between the front end and the back end through a resource identification mechanism, and the resource identification is used to describe the image, icon or prompt required by the interface component. The front end loads the corresponding resource according to the resource identification to complete the interface rendering.

[0050] As a further solution of the present invention, the view object receives the JSON data format transmitted by the back end through a unified API interface, and the API interface supports the rendering of multiple view components, including menu bars, toolbars, project trees, outlines and panels; the design of the process model follows the UI node separation principle, and the interface presentation part and the computationally intensive task processing part are run in independent processes to improve the interface response speed and enhance the system stability; the back-end controller object dynamically selects the business logic processing path based on the type of user interaction event, and after completing the processing, notifies the front-end view object of the updated data through the model object.

[0051] like Figure 1 The figure shows the basic structure of the traditional MVC design pattern. The view is responsible for interface display and user interaction, the model provides data and rule support, and the controller is responsible for transferring and processing logic between the two. However, the coupling degree between the view and the controller in the traditional model is high, resulting in excessive front-end load and difficulty in meeting the needs of highly interactive systems.

[0052] like Figure 2 As shown, the MVC design pattern process of the present invention is described. The back end serializes the controller object (Widget) and the model object into JSON data format through the Vim node (Vim Peers) and transmits it to the front end. The front end receives and binds these data to complete the interface rendering. During the user interaction process, the front end passes the event to the back end through Vim call (VimCall). The back end controller processes the business logic according to the event and saves the change results to the model, and notifies the front end to dynamically update the interface again. This design simplifies the logic of the front end into rendering and event capture, which greatly improves the response speed.

[0053] like Figure 3 The figure below illustrates the creation process of tree items. Tree items can be created by the front-end or back-end. All project data is managed uniformly in the back-end, and the front-end renders the interface. This realizes centralized data processing and dynamic interface updates.

[0054] like Figure 4 As shown in the figure, the communication mechanism between the front-end and back-end is shown. The view layer (browser) interacts with the back-end OSE module through the Internet. The front-end task is limited to interface display and user input, while the back-end assumes the main responsibility for data logic processing to significantly reduce the communication bottleneck.

[0055] like Figure 5The figure shows the sequential flow of toolbar operations. When a user opens a project, the front-end is initialized and requests toolbar data from the back-end. The back-end creates a toolbar model and fills in data before returning it to the front-end. The front-end renders the toolbar interface based on the model. When a user clicks a toolbar button, the front-end converts the event into a Vim call and passes it to the back-end, which executes the corresponding operation logic. This design of separation of responsibilities between the front-end and the back-end ensures efficient rendering and dynamic response of the toolbar.

[0056] Embodiment 1:

[0057] In order to better illustrate the technical solution of the present invention, a specific application scenario of a highly interactive distributed integrated development environment (IDE) is taken as an example to demonstrate the implementation method of the present invention and the technical effects achieved thereby.

[0058] In modern distributed IDEs, users need to manage multiple projects at the same time and frequently perform operations such as code editing, file operations, project structure viewing, and compilation. These operations place extremely high demands on the real-time responsiveness of the interface and the overall performance of the system. However, in the traditional MVC architecture, the front end needs to handle a large number of business logic-related operations (such as file creation, parsing of compilation results, etc.), resulting in slow interface response and poor user experience. In addition, frequent data interactions between the front and back ends further slow down the system when network latency is high or the amount of data is large. For example, during the dynamic update of the file tree (ProjectTree), the front end needs to obtain data from the back end and render it in real time based on the user's operations. This communication bottleneck is particularly prominent in complex scenarios.

[0059] The specific application of the front-end and back-end decoupling method based on distributed MVC of the present invention in this scenario is as follows:

[0060] First, in the scenario where the file tree is dynamically updated, when the user clicks on a directory node to expand the folder content, the front-end captures the user's click event and sends the event to the back-end controller object through a lightweight communication protocol (such as the VimCall command). The controller object determines the logical requirements of the user's operation based on the event type, for example, the user wants to obtain all the file information under the directory. The back-end controller object extracts data related to the directory from the model by calling the model object, including the file name, file type, and hierarchical structure. These data are serialized into a unified JSON format and then transmitted to the front-end through the back-end modular processing unit.

[0061] On the front end, data in JSON format is parsed by the view object and bound to the corresponding UI component (i.e., the node of the file tree). The rendering logic of the file tree is completely data-driven, and there is no need to write additional business logic on the front end, thus achieving "lightweight" front-end code. At the same time, since the controller objects and model objects are centrally processed on the back end, the status update speed of the file tree is significantly improved, and the interface can respond to user interactions in real time, maintaining efficient performance even in complex projects with a large number of files and deep levels.

[0062] Secondly, in response to the user's possible multilingual needs, the present invention further improves the collaboration efficiency between the front-end and back-end through a resource identification mechanism. For example, in the nodes of the file tree, the display name and corresponding icon information of each file or folder are uniformly provided by the back-end through resource identification. The front-end dynamically loads the corresponding image resources and language prompt information according to the identification, thereby realizing localization support and multilingual switching of the interface. This design reduces the amount of data transmitted between the front-end and back-end, while improving the flexibility and adaptability of interface rendering.

[0063] Taking the code editing function as an example, when the user enters code in the editor, the front end is only responsible for capturing the user's keyboard input and displaying the content in real time, while the back end is responsible for processing complex logic related to the code through the controller object, such as syntax highlighting parsing, error prompts, and code completion suggestions. These operation results are returned to the front end in the form of model objects, and the display status of the editor is dynamically updated. For example, when the back end detects a syntax error, the model object will package the error information (such as error type, line number, etc.) into JSON data and transmit it to the front end. The front end renders a red underline or pops up an error prompt box based on this data. This processing method minimizes the complexity of the front end while making full use of the computing power of the back end.

[0064] In addition, in terms of system stability and scalability, the present invention solves many pain points in traditional architectures through a modular process model design. For example, in the above-mentioned file tree update scenario, the UI logic runs in the main process, and the background controller and model objects run in independent working processes (such as Lifter Peer). The main process focuses on capturing user interaction events and updating the interface, while the background process is responsible for processing data requests and complex computing tasks. This process isolation design not only improves the real-time responsiveness of the interface, but also avoids the interference of background tasks on the operation of the front-end interface. Even if the user performs complex operations (such as batch file operations) under high load conditions, the system can still maintain a smooth user experience.

[0065] Through the above implementation methods, the present invention achieves comprehensive technical effects that cannot be achieved by the traditional MVC architecture, such as the "lightweight" design of the front-end greatly improves the interface response speed and significantly improves the user interaction experience; the modular process model ensures the high stability and scalability of the system; the resource identification mechanism and JSON data format optimize the collaboration efficiency of the front-end and back-end, reduce communication overhead, and enhance the flexibility of the system.

[0066] Embodiment 2:

[0067] In order to more clearly demonstrate the technical solution and application effects of the present invention, the following takes an application scenario of a distributed collaborative office system as an example to specifically illustrate how the new MVC model of the present invention solves the problems in traditional technologies and achieves technical effects.

[0068] In a distributed collaborative office system, users need to complete a variety of complex operations through the front-end interface, such as real-time editing of documents, multi-person collaborative management, version record viewing, and permission allocation, etc. These operations place extremely high demands on the dynamics and real-time nature of the interface and the complexity of the back-end business logic.

[0069] In the traditional MVC architecture, these scenarios usually encounter the following problems:

[0070] 1. Front-end load is too high: In multi-person collaboration, the front-end needs to monitor other users' operations in real time and update the document interface, while processing the logic of permission allocation and version switching. As the number of users and the frequency of operations increase, the front-end load continues to increase, resulting in interface freezes and delays.

[0071] 2. Front-end and back-end communication bottleneck: For example, when a user adds a comment or modifies a document, the traditional architecture needs to send a large amount of operation details (including modified content, location, user information, etc.) from the front-end to the back-end for processing, and return the updated data for front-end rendering. This high-frequency, large-volume data transmission will seriously affect the efficiency of the system when network conditions are poor.

[0072] 3. High coupling between modules and insufficient scalability: In traditional architectures, permission management modules, version record modules, and document editing modules are often interdependent, requiring data synchronization between multiple modules, which increases the complexity of system expansion and makes it difficult to adapt to changing business needs.

[0073] In view of the above problems, the application of the new MVC mode proposed by the present invention in this scenario is as follows:

[0074] In the collaborative office system, each document is represented as a "model object" and is managed uniformly by the backend. For example, a document model object will contain the document's content data, version information, permission configuration, etc. In the backend, the controller object is specifically responsible for processing various user operation requests for documents, including content editing, version switching, permission modification, etc.

[0075] When a user opens a document, the front-end requests the back-end to obtain the model object data of the document through a lightweight communication protocol (such as the VimCall command). The back-end serializes the model object into JSON format and transmits the data containing the document content, permission configuration, and version information to the front-end. After parsing the JSON data, the front-end renders the document interface through a binding mechanism, such as displaying the document content, marking read-only areas or editable areas, and loading optional version switching options. In this way, the front-end only needs to focus on interface display and user interaction, avoiding heavy logic processing, thus achieving a "lightweight" design.

[0076] In a multi-person collaboration scenario, when a user modifies a document, such as adding a comment to a paragraph, this operation will be captured by the front-end and sent to the controller object on the back-end in the form of a VimCall. The controller object updates the document's model object based on the type of operation, such as adding a new record to the comment data structure. The changes to the model object are then serialized into JSON data and broadcast to the front-end interfaces of all users participating in the collaboration. Each user's front-end automatically updates the interface based on the received data, such as displaying the new comment content under the corresponding paragraph. This approach uniformly processes business logic through the back-end, avoiding complex operation synchronization logic on the front-end, and significantly improving system performance and collaboration efficiency.

[0077] For permission management functions, for example, if a user wants to change the permission of a certain paragraph of text to "view only", this operation is also captured by the front-end and sent to the back-end for processing. The controller object on the back-end will update the model object according to the permission rules, and return the latest permission information to the front-end through JSON data. The front-end will dynamically adjust the interface display accordingly, such as marking the paragraph of text in gray to indicate that it is in read-only state. This method of driving the front-end interface update by the back-end avoids the front-end directly participating in complex permission logic judgments, significantly reducing the complexity of the front-end code.

[0078] In the version management function, the present invention optimizes the data interaction between the front-end and the back-end by using the resource identification mechanism. For example, when the user switches the document version, the front-end does not directly load the complete version data, but requests the back-end to load the corresponding version of the resource by sending the resource identification. The back-end returns the simplified data of the version content according to the resource identification, for example, only the content differences different from the current version, and the front-end quickly updates the interface accordingly. This design not only reduces the amount of data transmission between the front-end and the back-end, but also significantly improves the response speed of version switching, especially when processing large-scale documents.

[0079] In addition, the system further improves overall stability through modular process model design. For example, the UI process is responsible for real-time rendering of the interface and processing user operation events, while document content processing and permission verification logic run in independent background work processes. This process isolation design ensures high responsiveness of the user interface, and will not affect the smoothness of the interface even if the background processes complex requests from multiple users at the same time.

[0080] Through the above implementation modes, the effects achieved by the application of the technical solution of the present invention in a distributed collaborative office system are as follows: performance improvement: the business logic and model objects are uniformly managed by the back-end, and the front-end is only responsible for rendering the interface, which greatly reduces the computing burden of the front-end and significantly improves the response speed of the interface; collaboration efficiency is improved: the data consistency and real-time update of the interface during multi-user collaboration are ensured through unified management and real-time synchronization of model objects; communication optimization: the use of lightweight communication protocols and resource identification mechanisms reduces the amount of data transmission between the front-end and back-end, and optimizes the efficiency of network resource utilization; scalability is enhanced: the modular process model design and low-coupling module structure enable the system to flexibly adapt to diverse functional requirements and facilitate maintenance and expansion.

[0081] In the present invention, unless otherwise clearly stipulated and limited, the terms such as "installation", "setting", "connection", "fixation" and "screw-on" should be understood in a broad sense. For example, it can be a fixed connection, a detachable connection, or an integral one; it can be a mechanical connection or an electrical connection; it can be a direct connection or an indirect connection through an intermediate medium; it can be the internal connection of two elements or the interaction relationship between two elements. Unless otherwise clearly defined, ordinary technicians in this field can understand the specific meanings of the above terms in the present invention according to the specific circumstances.

[0082] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above and that the present invention can be implemented in other specific forms without departing from the spirit or essential features of the present invention. Therefore, the embodiments should be considered exemplary and non-restrictive in all respects, and the scope of the present invention is defined by the appended claims rather than the above description, and it is intended that all changes falling within the meaning and scope of the equivalent elements of the claims be included in the present invention.

Claims

1. A front-end and back-end decoupling method based on distributed MVC, characterized in that: The following steps are involved: Serializing the controller object and model object running thereon into a JSON data format including a controller object identifier, a model object identifier and associated logic through a modular processing unit of the backend, and transmitting the JSON data format to the frontend; The front end parses the received JSON data format, binds the corresponding controller object and model object to the front end view object, and renders the user interface; During the process of user interaction with the front-end interface, the front-end captures the interaction events and transmits the interaction events to the controller object of the back-end through the instruction-based communication protocol; The controller object at the back end executes the corresponding business logic based on the interaction event, and notifies the front end of the processing result through the model object; The front end dynamically updates the corresponding view object based on the updated data of the received model object to reflect the business logic processing results; Among them, the modular processing unit of the backend includes a process model for coordinating the task allocation of controller objects and model objects. The process model includes a main process for processing user interaction logic and a working process for task scheduling. The working process is responsible for data storage and processing of model objects.

2. According to the method of decoupling the front-end and the back-end based on distributed MVC according to claim 1, it is characterized in that: The working process of the process model includes the following components: Unified scheduling module, used to coordinate the task allocation of controller objects and model objects, and manage the communication between the front-end and back-end; The data storage module is used to handle disk IO operations and data persistence related to model objects to reduce the direct coupling between the front end and the task logic; The resource management module is used to parse the resource identifier sent by the front end, load the corresponding resources and synchronize the resource data to the front end.

3. A front-end and back-end decoupling method based on distributed MVC according to claim 1, characterized in that: The command-based communication protocol includes the following: The specific method name to be called; The corresponding callback event identifier; A collection of parameters required for user interaction events to be passed.

4. A front-end and back-end decoupling method based on distributed MVC according to claim 1, characterized in that: The updated data of the model object is transmitted to the front end in JSON format, and the JSON format includes the unique identifier of the model object, a data structure description, and data content for the front end to dynamically update the view object.

5. A front-end and back-end decoupling method based on distributed MVC according to claim 1, characterized in that: The method realizes data synchronization between the front-end and the back-end through a resource identification mechanism. The resource identification is used to describe the image, icon or prompt required by the interface component. The front-end loads the corresponding resource according to the resource identification to complete the interface rendering.

6. A front-end and back-end decoupling method based on distributed MVC according to claim 1, characterized in that: The view object receives the JSON data format transmitted by the backend through a unified API interface, and the API interface supports the rendering of multiple view components, including menu bars, toolbars, project trees, outlines and panels.

7. A front-end and back-end decoupling method based on distributed MVC according to claim 1, characterized in that: The design of the process model follows the UI node separation principle, and runs the interface presentation part and the computationally intensive task processing part in independent processes to improve the interface response speed and enhance the system stability.

8. A front-end and back-end decoupling method based on distributed MVC according to claim 1, characterized in that: The controller object at the back end dynamically selects a business logic processing path based on the type of user interaction event, and after completing the processing, notifies the view object at the front end of the updated data through the model object.

Images