A data processing system and method based on a Java low-code platform

Abstract

The embodiment of the application discloses a data processing system and method based on a Java low code platform; the system comprises: a presentation layer for providing a Web-based online IDE client; a service layer for providing an online development service engine; a data layer for providing a code version library, a compilation product library and a release configuration library; a running layer for data interaction with the presentation layer, the service layer and the data layer, for providing a Java-based lightweight runtime container, and realizing online development of front-end and back-end codes, real-time code compilation and hot deployment, online debugging and one-key release based on the container. The application has the following advantages: unified online development environment, reduced development threshold; collaborative development of front-end and back-end codes, improved development efficiency; real-time debugging capability, shortened problem positioning time; hot deployment technology, instant effect; one-key release, simplified deployment process.

Description

Technical Field

[0001] This invention relates to the field of code development technology, and specifically to a data processing system and method based on the Java low-code platform. Background Technology

[0002] Low-code development platforms are development environments that allow for rapid application building through visual modeling and minimal code writing. In recent years, with the acceleration of enterprise digital transformation, low-code platforms have demonstrated significant value in improving development efficiency and lowering technical barriers. Existing low-code platforms primarily employ the following technical approaches:

[0003] 1. Visual drag-and-drop development: Adopting a model-driven architecture, pre-built components are dragged and dropped through a graphical interface to automatically generate underlying code;

[0004] 2. Code-generated development: The platform automatically generates source code in Java, JavaScript, etc., based on the business logic and data model configured by the user, and developers can perform secondary development on the basis of the generated code;

[0005] 3. Template-based rapid development: Provides a rich library of business templates and components, allowing users to configure parameters and perform simple customizations based on the templates.

[0006] While existing low-code platforms have made significant progress in simplifying the development process, they suffer from the following technical shortcomings in practical applications:

[0007] (1) Fragmentation of front-end and back-end development environments for secondary development modules: Existing low-code platforms typically separate front-end visual configuration and back-end logic configuration into different functional modules. Front-end modules requiring secondary development require developers to write and debug JavaScript / Vue / React code in a local IDE (such as VS Code, WebStorm), and back-end modules requiring secondary development similarly require developers to write and debug Java code in a local IDE (such as IntelliJ IDEA, Eclipse). This fragmentation leads to complex development environment configuration, requiring the installation of multiple development tools and dependent environments; front-end and back-end code cannot be collaboratively edited and debugged in the same view; code version management is difficult, and front-end and back-end code are scattered in different code repositories or different directory structures.

[0008] (2) Lack of online debugging capabilities: Most existing low-code platforms only support the "configuration-preview" mode, that is, after the user completes the page and logic configuration, they can view the running effect through the preview function. This mode has the following problems: it is not possible to set breakpoints, single-step execution, and view variable values ​​like a traditional IDE; runtime errors can only be located by relying on log output, resulting in low debugging efficiency; for the generated Java backend code, there is a lack of online debugging interfaces and debugging proxy mechanisms, making it impossible to directly debug business logic within the platform.

[0009] (3) The release process is cumbersome and lacks hot deployment capability: The release process of existing low-code platforms usually requires exporting the configuration as a deployment package; manually or through the CI / CD pipeline on the target server; the application service needs to be restarted during the deployment process, resulting in business interruption; there is no mechanism for immediate effect of code modifications, and every minor change requires a complete rebuild and deployment process. Summary of the Invention

[0010] To address the technical shortcomings of existing low-code development platforms in online development, real-time debugging, and rapid deployment of front-end and back-end code for secondary development modules, the present invention aims to provide a data processing system and method based on a Java low-code platform to achieve the following:

[0011] 1. In a unified web-based online IDE environment, it simultaneously supports online editing, syntax checking, and intelligent code suggestions for both front-end (JavaScript / TypeScript / Vue / React) and back-end (Java) code;

[0012] 2. Provides online real-time debugging capabilities for front-end and back-end code, including breakpoint setting, single-step execution, variable viewing, call stack tracing, etc.;

[0013] 3. Enables instant hot deployment and hot update of modified code, allowing code changes to take effect without restarting the service;

[0014] 4. Supports one-click deployment, automatically synchronizing code that has passed verification in the development environment to the testing and production environments.

[0015] To achieve the above objectives, in a first aspect, embodiments of the present invention provide a data processing system based on a Java low-code platform, comprising:

[0016] The presentation layer is used to provide a web-based online IDE client;

[0017] The service layer is used to provide an online development service engine;

[0018] The data layer provides code version control, compilation artifacts, and release configuration.

[0019] The runtime layer interacts with the presentation layer, service layer, and data layer to provide a lightweight Java-based runtime container, and enables online development of front-end and back-end code, real-time code compilation and hot deployment, online debugging, and one-click deployment based on the container.

[0020] As one specific implementation of this application, the runtime layer includes:

[0021] The front-end and back-end code online development module is used to receive online editing requests sent by users through an online IDE client, and to edit the front-end code files or back-end code files online based on the online editing requests;

[0022] The online real-time debugging module is used to perform source code-level breakpoint debugging based on front-end or back-end breakpoints; the front-end and back-end breakpoints are set by the user in the IDE client;

[0023] The hot deployment module is used to trigger an incremental compilation process to generate a new .class file when the file change listener detects code modifications, and then completes the hot deployment of the new .class file; the file change listener is set in the container;

[0024] The one-click publishing module is used to receive publishing requests sent by users through the online IDE client and complete the one-click publishing of code based on the publishing requests.

[0025] Furthermore, as a specific implementation of this application, the online front-end and back-end code development module includes a front-end code online development unit, used for:

[0026] Provides a web code editor built on Monaco Editor; the web code editor is used to support syntax highlighting, intelligent prompting, and error checking of front-end technology stacks; the front-end technology stack includes JavaScript, TypeScript, Vue single-file components, and React JSX;

[0027] Provides a real-time front-end code preview engine; the real-time front-end code preview engine is used to load the front-end application through iframe sandbox technology and supports instant refresh after code modification;

[0028] Provides front-end resource building services; the front-end resource building services are used to build the front-end source code into browser-executable JavaScript and CSS resources in real time based on the cloud building capabilities of Vite or Webpack.

[0029] Furthermore, as a specific implementation of this application, the online front-end and back-end code development module includes a back-end Java online development unit, used for:

[0030] Provides an online Java code editor built on Monaco Editor; the online Java code editor is used to provide Java syntax highlighting, code completion, refactoring suggestions and real-time error detection;

[0031] An incremental compilation engine is provided; the incremental compilation engine is used to quickly compile modified Java source files using the incremental compilation mode of ECJ or javac to generate .class bytecode files.

[0032] Furthermore, as a specific implementation of this application, the online front-end and back-end code development module includes a front-end and back-end code collaborative editing unit, used for:

[0033] Provide a unified project workspace; the unified project workspace is used to map the front-end src directory and the back-end src directory to the same project tree view, and supports cross-directory file navigation and search;

[0034] Automatically generate front-end and back-end API call code using OpenAPI / Swagger specifications to achieve front-end and back-end API contract management;

[0035] Real-time collaborative editing is achieved based on OT or CRDT algorithms.

[0036] As one specific implementation of this application, the online real-time debugging module includes:

[0037] The backend Java code online debugging unit is used to implement debugging proxy injection, breakpoint management, debugging time handling, and dynamic evaluation of Java expressions based on JDWP technology.

[0038] The front-end code online debugging unit is used to implement CDP connections based on CDP technology, view and modify the page DOM structure and CSS styles in a web IDE, set breakpoints in TypeScript / Vue / React source code, and assist in locating interface problems between the front-end and back-end;

[0039] The front-end and back-end integration unit is used for unified debugging of the session manager, cross-short call chain tracing, and shared variable observation area.

[0040] As one specific implementation of this application, the hot deployment module includes:

[0041] The backend Java hot deployment unit is used to hot deploy modified backend code based on class hot replacement engine, incremental class loader, Spring context hot refresh technology and method-level hot update technology.

[0042] The front-end hot update unit is used to implement hot updates of front-end code based on HMR, hot style injection, and hot update between components.

[0043] As a specific implementation of this application, the one-click release module is used to implement one-click code release based on the release pipeline orchestrator, code difference analyzer, environment configuration manager and canary release controller;

[0044] The one-click publish module is also used to provide a publish rollback mechanism.

[0045] Secondly, embodiments of this application also provide a data processing method based on a Java low-code platform, which is implemented based on the system described in the first aspect above, including:

[0046] Receive user access requests for the Java low-code platform and initialize the online development environment based on the access requests;

[0047] Receive online editing requests sent by users through online IDE clients, and perform online editing of front-end code files or back-end code files based on the online editing requests;

[0048] When the file change listener detects code modifications, it triggers an incremental compilation process to generate a new .class file and completes the hot deployment of the new .class file; the file change listener is set in the container;

[0049] Enables online real-time debugging at the source code level based on front-end or back-end breakpoints; the front-end and back-end breakpoints are set by the user in the IDE client;

[0050] Receive release requests sent by users through online IDE clients, and complete one-click code release based on the release requests.

[0051] Implementing the embodiments of the present invention has the following beneficial effects:

[0052] (1) Unified online development environment, lowering the development threshold: This invention provides complete IDE functionality through a browser. Developers do not need to install and configure complex development environments (JDK, Node.js, Maven, IDE, etc.) locally. They can start front-end and back-end code development simply by accessing the platform through a browser. This significantly reduces the time cost and technical threshold of setting up the development environment, enabling business personnel to participate in code-level custom development.

[0053] (2) Collaborative development between front-end and back-end code improves development efficiency: Through a unified project workspace and interface contract management, front-end and back-end developers can collaborate on the same platform, view each other's code changes and interface definitions in real time, and reduce communication costs and rework caused by interface inconsistencies. The front-end and back-end joint debugging function makes cross-platform problem localization more efficient.

[0054] (3) Real-time debugging capability, shortening problem location time: Traditional low-code platforms lack debugging capabilities, and developers can only locate problems through log output. The online breakpoint debugging function provided by this invention enables developers to view variable status and execution flow in real time during code execution, improving problem location efficiency several times. The front-end and back-end integration debugging function further reduces the troubleshooting time for cross-platform problems from hours to minutes.

[0055] (4) Hot deployment technology enables immediate effect: Through Java class hot replacement and front-end HMR technology, code modifications can take effect immediately without restarting the service, shortening the development-testing-verification iteration cycle from minutes to seconds. This is especially important for scenarios that require frequent adjustments to business logic and interface styles.

[0056] (5) One-click release, simplifying the deployment process: The traditional release process involves multiple manual steps such as code packaging, uploading, deployment, and restarting, which are prone to errors and time-consuming. The one-click release function of this invention automates the release process and achieves rapid and secure code deployment while ensuring system stability through incremental release and canary release strategies. Attached Figure Description

[0057] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the accompanying drawings used in the description of the specific embodiments or the prior art will be briefly introduced below.

[0058] Figure 1 This is a data processing system architecture diagram based on the Java low-code platform provided in an embodiment of the present invention;

[0059] Figure 2 This is a flowchart of a data processing method based on a Java low-code platform provided in an embodiment of the present invention. Detailed Implementation

[0060] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0061] It should be understood that, when used in this specification and the appended claims, the terms "comprising" and "including" indicate the presence of the described features, integrals, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.

[0062] Please refer to Figure 1 This is a data processing system architecture based on the Java low-code platform provided in this embodiment of the invention, comprising:

[0063] The presentation layer provides a web-based online IDE client, using Monaco Editor (the core editor of VS Code) as the code editing component to offer an IDE-like editing experience.

[0064] The service layer provides an online development service engine, including code parsing services, compilation services, debugging proxy services, and release orchestration services.

[0065] The data layer provides code version control, compilation artifacts, and release configuration.

[0066] The runtime layer interacts with the presentation layer, service layer, and data layer to provide a lightweight Java-based runtime container, and enables online development of front-end and back-end code, real-time code compilation and hot deployment, online debugging, and one-click deployment based on the container.

[0067] In this specific implementation, the runtime layer includes:

[0068] The front-end and back-end code online development module is used to receive online editing requests sent by users through an online IDE client, and to edit the front-end code files or back-end code files online based on the online editing requests;

[0069] The online real-time debugging module is used to perform source code-level breakpoint debugging based on front-end or back-end breakpoints; the front-end and back-end breakpoints are set by the user in the IDE client;

[0070] The hot deployment module is used to trigger an incremental compilation process to generate a new .class file when the file change listener detects code modifications, and then completes the hot deployment of the new .class file; the file change listener is set in the container;

[0071] The one-click publishing module is used to receive publishing requests sent by users through the online IDE client and complete the one-click publishing of code based on the publishing requests.

[0072] The following will provide a detailed introduction to each module.

[0073] (a) Online development module for front-end and back-end code

[0074] This module is mainly used for unified online development of front-end and back-end, and can include an online front-end code development unit, an online back-end Java code development unit, and a collaborative editing unit for front-end and back-end code.

[0075] The online front-end code development unit mainly includes:

[0076] A web code editor built on Monaco Editor, supporting syntax highlighting, intelligent suggestions, and error checking for front-end technology stacks such as JavaScript, TypeScript, Vue single-file components (SFC), and React JSX;

[0077] A real-time front-end code preview engine that loads the front-end application using iframe sandbox technology and supports instant refresh after code modification (Live Reload).

[0078] Front-end resource building service, based on the cloud building capabilities of Vite or Webpack, compiles front-end source code into browser-executable JavaScript and CSS resources in real time.

[0079] Furthermore, the backend Java online development unit mainly includes:

[0080] This online Java code editor, built on Monaco Editor, provides Java syntax highlighting, code completion, refactoring suggestions, and real-time error detection.

[0081] The incremental compilation engine uses the incremental compilation mode of Eclipse Compiler for Java (ECJ) or javac to quickly compile modified Java source files and generate .class bytecode files.

[0082] Furthermore, the front-end and back-end code collaborative editing unit mainly implements the following functions:

[0083] The unified project workspace maps the front-end src directory and the back-end src directory to the same project tree view, supporting cross-directory file navigation and searching;

[0084] Front-end and back-end interface contract management: Automatically generate front-end and back-end interface call code according to OpenAPI / Swagger specifications to ensure interface consistency;

[0085] Real-time collaborative editing, based on Operational Transformation (OT) or CRDT algorithms, supports multiple users editing the same code file simultaneously.

[0086] (ii) Online Real-time Debugging Module

[0087] This module mainly includes an online debugging unit for backend Java code, an online debugging unit for frontend code, and a frontend-backend integration debugging unit.

[0088] The backend Java code online debugging unit uses Java Debug Wire Protocol (JDWP) technology to achieve the following functions:

[0089] The debug agent injector injects a debug agent through the Java Agent mechanism when the Java runtime (JVM) starts or during runtime.

[0090] The breakpoint manager receives breakpoint setting requests from the Web IDE and registers breakpoint information with the target JVM's debugging interface via the JDWP protocol.

[0091] The debug event handler listens for JVM debug events (such as breakpoint hits, single-step execution, and exception throwing) and pushes the debug status (current line number, variable value, and call stack) to the Web IDE in real time.

[0092] An expression evaluator that supports dynamic evaluation of Java expressions during debugging, allowing you to view the properties and method return values ​​of complex objects.

[0093] Furthermore, the online debugging of front-end code is based on the Chrome DevTools Protocol (CDP) and implements the following functions:

[0094] A browser debugging bridge that establishes a CDP connection between the online IDE and the browser runtime in the preview iframe;

[0095] DOM and style debugger, allowing you to view and modify the page's DOM structure and CSS styles within a web IDE;

[0096] A JavaScript breakpoint debugger that supports setting breakpoints in the TypeScript / Vue / React source code (via Source Map mapping) to achieve source code-level debugging;

[0097] A network request monitor that captures and displays HTTP request and response data between the front-end and back-end APIs to help locate interface problems.

[0098] Furthermore, the front-end and back-end integration unit mainly performs the following functions:

[0099] A unified debugging session manager creates joint debugging sessions that include front-end and back-end debugging targets;

[0100] Cross-platform call chain tracing automatically associates the front-end and back-end debugging contexts when an API request initiated from the front-end triggers a back-end breakpoint, displaying the complete request processing chain.

[0101] The shared variable observation area displays the state variables of the front-end page and the state of the back-end business objects in a unified view, which is convenient for comparative analysis.

[0102] (III) Hot Deployment Module

[0103] This module mainly includes a backend Java hot deployment unit and a frontend hot update unit.

[0104] The backend Java hot deployment unit uses the following technology to ensure that code changes take effect immediately:

[0105] The class hot-swapping engine, based on the Java Instrumentation API and the JRebel / HotSwapAgent open-source framework, dynamically replaces loaded class definitions at JVM runtime without requiring an application restart;

[0106] An incremental class loader monitors modification events of Java source files, triggers incremental compilation, and loads new class bytecode through a custom ClassLoader to replace the old version of the class.

[0107] Spring context hot refresh enables backend applications based on the Spring framework to automatically refresh the Spring ApplicationContext after a class is replaced, re-injecting dependencies and initializing beans.

[0108] Method-level hot updates allow for the immediate replacement of method bytecode for modifications to the method body via DCEVM (Dynamic Code Evolution VM) or the JVM's RedefineClasses feature.

[0109] Furthermore, the front-end hot update unit is implemented based on the following technologies:

[0110] Hot Module Replacement (HMR) uses the HMR plugin of Vite or Webpack to replace only the changed modules after detecting changes in the front-end source code, thus keeping the application state intact.

[0111] Hot style injection allows for real-time updates of page styles without page refreshes when modifications are made to CSS / SCSS / Less files, via style-loader or Vite's CSSHMR mechanism.

[0112] Component-level hot reloading allows for modifications to Vue / React components, updating the component implementation while preserving the component's state through framework-specific HMR APIs (such as react-refresh and vue-hot-reload-api).

[0113] (iv) One-click publishing module

[0114] In this embodiment, the one-click publishing module mainly implements the following functions:

[0115] Release pipeline orchestrator, defining a multi-stage release process from development environment to testing environment to production environment;

[0116] The code diff analyzer compares the differences between the code in the current workspace and the code in the target environment, and generates incremental release packages.

[0117] The environment configuration manager manages configuration parameters such as database connections, service addresses, and function switches for different environments (development, testing, and production), and automatically injects the target environment configuration during deployment.

[0118] The canary release controller supports canary releases based on user proportions, regions, or business dimensions, gradually pushing new version code to the production environment;

[0119] The release rollback mechanism records a snapshot of the code for each release, and supports one-click rollback to the previous stable version in case of release errors.

[0120] Based on the same inventive concept, embodiments of the present invention provide a data processing method based on a Java low-code platform, and based on the aforementioned system implementation. For example... Figure 2 As shown, the method mainly includes:

[0121] S1, Online Development Environment Initialization: Receives user access requests for the Java low-code platform and completes the initialization of the online development environment based on the request.

[0122] In practice, when a user accesses the low-code platform through a browser, the system performs the following initialization operations:

[0123] (1) Container resource allocation: The platform requests a new Pod from the Kubernetes cluster based on the project template selected by the user (such as Spring Boot + Vue3, Spring Boot + React, etc.).

[0124] (2) Project structure initialization: After the container starts, the platform automatically generates a standardized front-end and back-end project structure based on the template.

[0125] (3) Language Server Startup: The platform starts a Language Server Protocol (LSP) service instance for the corresponding programming language within the container, including:

[0126] Java Language Server: Based on Eclipse JDT Language Server, listening on port 1044, it provides functions such as syntax analysis, type inference, code completion, and refactoring suggestions for Java code.

[0127] TypeScript Language Server: Based on TypeScript Language Server, listening on port 1045, it provides type checking, intelligent code completion, and error diagnosis for TypeScript / JavaScript / Vue code.

[0128] The Web IDE client establishes a connection with the aforementioned LSP service via WebSocket, synchronizing the code content in the editor to the language server to obtain real-time code suggestions and error checking feedback.

[0129] (4) Startup of the front-end development server. The platform starts the Vite development server in the container. The server pushes HMR update messages to the front-end preview iframe through the WebSocket channel to realize real-time hot updates after the front-end code is modified.

[0130] (5) Backend service startup and debugging agent injection: The platform starts the Spring Boot application in the container and injects the debugging agent at the same time.

[0131] At this point, the online development environment initialization is complete, and users can begin online development of front-end and back-end code in the Web IDE.

[0132] S2, Online Front-end and Back-end Code Editing: Receives online editing requests from users via online IDE clients and performs online editing of front-end or back-end code files based on these requests.

[0133] In practice, users open and edit front-end or back-end code files in a Web IDE. The editor communicates with the back-end language server via LSP to obtain intelligent suggestions such as code completion, syntax checking, and refactoring recommendations. Code modifications are automatically saved to the container's file system, triggering file change events. A more detailed description of the process is as follows:

[0134] (1) Unified Project Workspace Mapping. The Web IDE client maps the front-end and back-end code directories to a unified project tree view. The project tree is abstracted using a Virtual File System (VFS). When a user clicks a file node in the project tree, the Web IDE requests the file content from the service layer and opens the corresponding editor tab in Monaco Editor upon receiving the response. The editor automatically selects the language mode based on the file extension (e.g., .java files use Java mode, .vue files use Vue mode) and loads the corresponding syntax highlighting rules and code completion configuration.

[0135] (2) Intelligent code suggestion and syntax checking. Taking Java code editing as an example, when a user enters code in the editor, Monaco Editor sends a textDocument / completion request to the Java language server through the LSP client. The Java language server, based on the Eclipse JDT code completion engine, analyzes the AST context of the current cursor position and returns a list of candidate completion items, including class names, method names, field names, keywords, etc. The completion items are sorted by relevance and frequency of use, prioritizing the display of classes defined in the current project and commonly used JDK classes.

[0136] For syntax errors, the language server performs a textDocument / publishDiagnostics push when the file is saved or idle, sending error information (including error location, error type, and repair suggestions) to the WebIDE. The Monaco Editor then displays a red wavy line error marker on the corresponding line of code.

[0137] (3) Automatic generation of front-end and back-end interface contracts: The platform maintains the front-end and back-end interface contracts through the OpenAPI specification file ( / workspace / openapi / api-spec.yaml). When a user modifies the OpenAPI specification, the platform automatically generates the front-end and back-end interface call code, and the generated interface code is automatically synchronized to the front-end and back-end projects to ensure the consistency of interface definitions. When the back-end developer modifies the interface parameter type or path, the interface call code in the front-end project is updated synchronously, and type mismatch issues can be detected during compilation.

[0138] (4) Real-time collaborative editing. The platform enables real-time collaborative editing by multiple users based on the Operational Transformation (OT) algorithm. Each opened code file corresponds to an OT document instance, and the document state is maintained by the operation sequence:

[0139] class OTDocument { private revision: number = 0; private operations: Operation[] = []; applyLocalOperation(op: Operation): void { this.operations.push(op); this.revision++; this.broadcastOperation(op); } applyRemoteOperation(op: Operation): void { const transformedOp = this.transform(op, this.pendingOperations); this.operations.push(transformedOp); this.revision++; this.updateEditorContent(transformedOp); } }

[0140] When user A inserts the character "hello" on line 10 of a file, the platform broadcasts the operation {type: 'insert', position: {line: 10, char: 5}, text: 'hello'} to all users B and C who are editing the file. Upon receiving the operation, users B and C adjust their local cursor positions according to the OT transformation rules and apply the changes, achieving conflict-free real-time collaborative editing.

[0141] S3, Real-time Code Compilation and Hot Deployment: When the file change listener detects code modifications, it triggers an incremental compilation process to generate new .class files and completes the hot deployment of the new .class files.

[0142] In practice, the file watcher detects code modifications and triggers an incremental compilation process. For Java code, the ECJ incremental compiler is called to compile the modified source files, generating new .class files. The hot deployment agent detects the new .class files and injects the new class definition into the running JVM via the Instrumentation API. For front-end code, the Vite build server detects module changes and pushes an HMR update message to the browser via WebSocket. Upon receiving the HMR message, the browser only replaces the changed modules, maintaining the application's running state. A more detailed flowchart follows:

[0143] (1) Java incremental compilation. The platform runs a file change listener (WatchService based on Java NIO) inside the container to monitor file change events in the / workspace / backend / src directory.

[0144] When the incremental compilation engine (based on ECJ) receives the path to the changed file, it executes the following compilation logic: parses the AST of the changed file to determine the set of classes it directly depends on; compiles the changed file and its dependent files; and outputs the generated .class file to the / workspace / backend / target / classes directory, overwriting the old version.

[0145] (2) Hot replacement of backend classes. After HotSwapAgent detects a new .class file in the / workspace / backend / target / classes directory, it performs hot replacement of the class through the Java Instrumentation API.

[0146] For modifications to the method body (such as changing business logic or adjusting variable assignments), the JVM's RedefineClasses feature can directly replace the method bytecode without reloading the class object, and the Spring Bean's dependencies remain unchanged.

[0147] For scenarios involving changes to class structure (such as adding fields or modifying method signatures), HotSwapAgent handles them through the following mechanisms: loading the new version of the class definition using a custom ClassLoader; traversing all Bean instances in the SpringApplicationContext; for Beans whose types have changed, destroying the old instance and creating a new one; and re-executing dependency injection and initialization callbacks (@PostConstruct methods).

[0148] (3) Hot Replacement (HMR) of Front-end Modules. After the front-end code is modified, the Vite development server detects the change through the file listener (chokidar library) and executes the following HMR process: Taking the modification of the Vue single-file component / workspace / frontend / src / components / UserForm.vue as an example:

[0149] Change detection: The Vite server detected a modification to the UserForm.vue file, parsed the SFC file, and compiled it accordingly. <template> 、 <script>、<style>块；

[0150] 依赖分析：Vite构建模块图（Module Graph），确定UserForm.vue的依赖链：App.vue →UserForm.vue；

[0151] HMR边界确定：UserForm.vue导出组件定义，自身可作为HMR边界。Vite向浏览器发送HMR更新消息；

[0152] 客户端热更新：浏览器中的Vite HMR客户端接收消息，通过import()动态导入新模块，调用vue-hot-reload-api的reload方法，在保留组件状态（data、computed缓存）的前提下，替换组件的渲染函数和生命周期钩子，页面即时展示更新后的UI，无需刷新。

[0153] （4）样式热注入。对于CSS / SCSS文件的修改，Vite通过以下方式实现即时更新：Vite服务器将编译后的CSS内容通过WebSocket推送至浏览器，浏览器中的HMR客户端创建或更新<style>标签的textContent，页面样式即时生效，无需刷新页面，组件状态完全保留。

[0154] S4，在线调试：基于前端断点或后端断点完成源码级在线实时调试。

[0155] 具体实现时，用户在Web IDE中为前端或后端代码设置断点；对于后端断点，WebIDE通过调试服务将断点信息转换为JDWP命令，发送至JVM调试代理；当程序执行到断点位置时，JVM暂停执行线程，将当前执行上下文（行号、变量值、调用栈）返回给Web IDE展示；用户执行单步执行（Step Over / Into / Out）、继续执行（Resume）等调试操作，调试服务将相应命令转发至JVM；对于前端断点，Web IDE通过CDP协议与浏览器调试运行时通信，实现源码级断点调试。

[0156] 可理解地，步骤S4包括后端Java代码在线调试、前端代码在线调试以及前后端联调三部分。

[0157] （1）后端Java代码在线调试

[0158] 该步骤包括：

[0159] ①调试代理初始化。平台在JVM启动时通过-agentlib:jdwp参数开启JDWP调试接口。调试代理服务（Debug Proxy Service）作为Web IDE与JVM之间的中间层，负责协议转换和状态管理。

[0160] ②断点设置与注册。用户在Web IDE中为Java代码设置断点时，Monaco Editor捕获点击行号事件，向调试代理服务发送断点设置请求。调试代理服务将请求转换为JDWP命令序列：通过VirtualMachine.classesByName()查询目标类的ReferenceType；通过ReferenceType.locationsOfLine(42)获取第42行对应的Location列表；通过EventRequestManager.createBreakpointRequest(location)创建断点请求；设置断点条件（如存在）；启用断点请求。JVM在目标类加载到方法区后，将断点位置的字节码指令替换为breakpoint陷阱指令（操作码0xCA）。当执行流到达该位置时，JVM触发BreakpointEvent。

[0161] ③断点命中与状态同步。当程序执行到断点位置时，JVM暂停目标线程，通过JDWP事件通道向调试代理服务发送BreakpointEvent。Web IDE接收调试状态后，在编辑器中高亮显示当前执行行（黄色背景），在调试侧边栏展示变量值和调用栈。

[0162] ④单步执行控制。用户点击"单步跳过"（Step Over）按钮时，Web IDE发送stepOver命令。调试代理服务执行以下操作：清除当前断点（防止重复命中）；创建StepRequest；启用步进请求并恢复线程执行；监听StepEvent，当步进完成时，再次暂停线程并同步新的执行状态。

[0163] ⑤表达式动态求值。用户在调试控制台输入表达式时，调试代理服务通过JDI（Java Debug Interface）的ObjectReference.invokeMethod()机制执行表达式求值。求值结果通过JSON序列化后返回Web IDE展示。

[0164] （2）前端代码在线调试

[0165] 该步骤主要包括：

[0166] ①CDP连接建立。Web IDE中的预览区域通过iframe加载前端应用，URL为http: / / localhost:3000（通过平台反向代理映射到用户可访问的域名）。平台在iframe中注入CDP桥接脚本，与Web IDE建立WebSocket连接。

[0167] ②码级断点调试。用户在TypeScript源代码中设置断点时，Web IDE通过SourceMap将TypeScript行号映射为JavaScript行号。Web IDE通过CDP发送Debugger.setBreakpointByUrl命令，浏览器DevTools Runtime在对应位置设置断点。当JavaScript执行到该位置时，Runtime暂停执行，通过CDP发送Debugger.paused事件，WebIDE解析后在TypeScript源代码视图中高亮显示断点行，在调试面板中展示局部变量。

[0168] ③DOM与样式调试。用户点击Web IDE中的"元素检查"按钮后，选择预览iframe中的某个DOM元素。CDP桥接器发送DOM.querySelector和CSS.getMatchedStylesForNode命令获取选中元素的计算样式。用户在样式面板中修改样式后，Web IDE通过CDP发送CSS.setStyleTexts命令，浏览器即时更新元素样式，预览iframe中的UI实时变化。

[0169] （3）前后端联调

[0170] 该步骤主要包括：

[0171] ①统一调试会话管理。当用户同时开启前端调试和后端调试时，平台创建联合调试会话。

[0172] ②跨端调用链追踪。当前端代码调用API时，平台通过以下机制实现跨端追踪：

[0173] 请求拦截：前端CDP桥接器通过Network.requestWillBeSent事件捕获请求，生成唯一traceId，注入到请求头X-Debug-Trace-Id中；

[0174] 后端接收：后端Spring Boot应用通过过滤器读取X-Debug-Trace-Id，存入MDC（Mapped Diagnostic Context）线程本地变量；

[0175] 断点关联：当后端执行到断点时，调试代理服务从MDC获取traceId，查询对应的前端请求上下文，建立关联关系；

[0176] 链路展示：Web IDE在"调用链”面板中展示完整链路，包括前端发起请求位置、HTTP请求信息、后端处理位置等。

[0177] ③共享变量观察区。Web IDE在调试面板中设置"跨端变量”标签页，同时展示前端状态变量和后端业务对象，开发者可直观对比前后端同名变量的值是否一致，快速定位数据转换或序列化问题。

[0178] S5，一键发布：接收用户通过在线IDE客户端发送的发布请求，并基于该请求完成代码的一键发布。

[0179] 具体实现时，用户在Web IDE中点击”发布”按钮，选择目标环境（测试环境或生产环境）；发布服务对比当前代码与目标环境代码，生成包含变更文件的增量发布包；对发布包进行自动化测试（单元测试、集成测试），测试通过后进入部署流程；根据目标环境的部署策略（全量发布或灰度发布），将发布包分发到目标服务器集群；对于Java后端，在目标服务器上通过热部署机制加载新的类定义，或在必要时滚动重启服务实例；对于前端，将构建后的静态资源上传至CDN或Web服务器，并刷新CDN缓存；发布完成后，记录发布日志和代码快照，支持回滚操作。更为具体的流程如下：

[0180] ①代码差异分析。用户在Web IDE中点击"发布”按钮，选择目标环境（如"生产环境"）。发布编排服务执行代码差异分析：获取当前工作区代码的Git Commit ID；获取目标环境当前运行的代码版本；执行git diff获取变更文件列表。

[0181] ②增量发布包生成。发布服务根据差异文件列表生成增量发布包。

[0182] ③自动化测试。发布包生成后，平台自动触发测试流水线：单元测试→集成测试→安全扫描。

[0183] 其中，单元测试指的是在隔离容器中运行JUnit测试用例，覆盖变更文件关联的测试类；集成测试指的是启动临时数据库（Testcontainers管理的MySQL容器），执行API接口测试；安全扫描：使用SonarQube扫描变更代码，检查是否存在SQL注入、XSS等安全漏洞。

[0184] 测试全部通过后，发布包进入待部署状态。

[0185] ④环境配置注入。发布服务根据目标环境，从发布配置库读取对应配置并注入发布包。

[0186] 需要说明的是，敏感配置（如数据库密码）通过Kubernetes Secret或HashiCorpVault动态注入，不存储于代码仓库。

[0187] ⑤灰度发布。平台支持按用户比例进行灰度发布。以将新版本发布给5%的用户为例：

[0188] 流量切分：在API网关层（如Spring Cloud Gateway）配置权重路由规则，新版本权重5%，旧版本权重95%；

[0189] 金丝雀监控：平台收集新版本实例的指标（错误率、响应时间、CPU使用率），与旧版本对比。若错误率超过阈值（如0.1%），自动触发回滚；

[0190] 逐步放量：监控指标正常后，按10% → 30% → 70% → 100%的比例逐步扩大新版本流量，每个阶段持续观察15分钟。

[0191] ⑥全量发布与CDN刷新。灰度验证通过后，执行全量发布：

[0192] 后端部署：将增量.class文件分发至所有生产服务器，通过热部署机制加载新类定义。对于涉及数据库Schema变更的版本，采用滚动重启策略（一次重启一个Pod，确保服务不中断）；

[0193] 前端部署：将构建后的静态资源上传至对象存储（如阿里云OSS），并刷新CDN缓存；

[0194] 版本标记：在Git仓库中打标签release-v2.3.1，记录发布版本。

[0195] 此外，本发明的发布回滚机制描述如下：

[0196] 若发布后监控发现异常，用户可在Web IDE中点击"一键回滚"按钮。平台执行以下回滚操作：

[0197] 从manifest.json读取rollbackSnapshot路径；

[0198] 将上一版本的.class文件和前端静态资源恢复至生产环境；

[0199] 对于已执行的数据库变更，通过Flyway的undo迁移脚本回滚Schema；

[0200] 刷新CDN缓存，确保用户获取旧版本前端资源；

[0201] 发送告警通知至运维团队。

[0202] 回滚完成后，系统恢复到发布前的稳定状态，用户可在开发环境修复问题后重新发布。

[0203] 各模块在使用时，仅在得到用户的充分授权，以及符合相关法律法规的前提下进行用户信息的收集和存储，并保护用户数据的安全性和隐私性，严禁非授权访； 数据的处理将在法律规定的范围内进行，且不超出用户所授权的目的和范围；同时，用户享有对其个人数据的访问、更正、删除、限制处理、拒绝等相关权利；以及严格遵守适用的法律法规，并进行合规审查。

[0204] 从以上描述可以得知，实施本发明实施例所提供的基于Java低代码平台的数据处理方案，优点如下：

[0205] （1）统一在线开发环境，降低开发门槛：本发明通过浏览器即可提供完整的IDE功能，开发者无需在本地安装和配置复杂的开发环境（JDK、Node.js、Maven、IDE等），只需通过浏览器访问平台即可开始前后端代码开发。这显著降低了开发环境搭建的时间成本和技术门槛，使业务人员也能参与代码级定制开发。

[0206] （2）前后端代码协同开发，提升开发效率：通过统一的项目工作区和接口契约管理，前端开发者和后端开发者可以在同一平台中协同工作，实时查看对方的代码变更和接口定义，减少因接口不一致导致的沟通成本和返工。前后端联调功能使得跨端问题定位更加高效。

[0207] （3）实时调试能力，缩短问题定位时间：传统低代码平台缺乏调试能力，开发者只能通过日志输出来定位问题。本发明提供的在线断点调试功能，使开发者能够在代码执行过程中实时查看变量状态和执行流程，问题定位效率提升数倍。前后端联调功能更是将跨端问题的排查时间从小时级缩短到分钟级。

[0208] （4）热部署技术，实现即时生效：通过Java类热替换和前端HMR技术，代码修改后无需重启服务即可即时生效，开发-测试-验证的迭代周期从分钟级缩短到秒级。这对于需要频繁调整业务逻辑和界面样式的场景尤为重要。

[0209] （5）一键发布，简化部署流程：传统发布流程涉及代码打包、上传、部署、重启等多个手动操作步骤，容易出错且耗时较长。本发明的一键发布功能将发布流程自动化，通过增量发布和灰度发布策略，在保证系统稳定性的前提下，实现代码的快速、安全上线。

[0210] 以上所述，仅为本发明的具体实施方式，但本发明的保护范围并不局限于此，任何熟悉本技术领域的技术人员在本发明揭露的技术范围内，可轻易想到各种等效的修改或替换，这些修改或替换都应涵盖在本发明的保护范围之内。因此，本发明的保护范围应以权利要求的保护范围为准。< / script> < / template>

Claims

1. A data processing system based on the Java low-code platform, characterized in that, include: The presentation layer is used to provide a web-based online IDE client; The service layer is used to provide an online development service engine; The data layer provides code version control, compilation artifacts, and release configuration. The runtime layer interacts with the presentation layer, service layer, and data layer to provide a lightweight Java-based runtime container, and enables online development of front-end and back-end code, real-time code compilation and hot deployment, online debugging, and one-click deployment based on the container.

2. The system as described in claim 1, characterized in that, The runtime layer includes: The front-end and back-end code online development module is used to receive online editing requests sent by users through an online IDE client, and to edit the front-end code files or back-end code files online based on the online editing requests; The online real-time debugging module is used to perform source code-level breakpoint debugging based on front-end breakpoints or back-end breakpoints; the front-end breakpoints and back-end breakpoints are set by the user in the IDE client; The hot deployment module is used to trigger an incremental compilation process to generate a new .class file when the file change listener detects code modifications, and then completes the hot deployment of the new .class file; the file change listener is set in the container; The one-click publishing module is used to receive publishing requests sent by users through the online IDE client and complete the one-click publishing of code based on the publishing requests.

3. The system as described in claim 2, characterized in that, The online front-end and back-end code development module includes a front-end code online development unit, used for: Provides a web code editor built on Monaco Editor; the web code editor is used to support syntax highlighting, intelligent prompting, and error checking of front-end technology stacks; the front-end technology stack includes JavaScript, TypeScript, Vue single-file components, and React JSX; Provides a real-time front-end code preview engine; the real-time front-end code preview engine is used to load the front-end application through iframe sandbox technology and supports instant refresh after code modification; Provides front-end resource building services; the front-end resource building services are used to build the front-end source code into browser-executable JavaScript and CSS resources in real time based on the cloud building capabilities of Vite or Webpack.

4. The system as described in claim 3, characterized in that, The online front-end and back-end code development module includes a back-end Java online development unit, used for: Provides an online Java code editor built on Monaco Editor; the online Java code editor is used to provide Java syntax highlighting, code completion, refactoring suggestions and real-time error detection; An incremental compilation engine is provided; the incremental compilation engine is used to quickly compile modified Java source files using the incremental compilation mode of ECJ or javac to generate .class bytecode files.

5. The system as described in claim 4, characterized in that, The online front-end and back-end code development module includes a front-end and back-end code collaborative editing unit, used for: Provide a unified project workspace; the unified project workspace is used to map the front-end src directory and the back-end src directory to the same project tree view, and supports cross-directory file navigation and search; Automatically generate front-end and back-end API call code using OpenAPI / Swagger specifications to achieve front-end and back-end API contract management; Real-time collaborative editing is achieved based on OT or CRDT algorithms.

6. The system as described in claim 5, characterized in that, The online real-time debugging module includes: The backend Java code online debugging unit is used to implement debugging proxy injection, breakpoint management, debugging time handling, and dynamic evaluation of Java expressions based on JDWP technology. The front-end code online debugging unit is used to implement CDP connections based on CDP technology, view and modify the page DOM structure and CSS styles in a web IDE, set breakpoints in TypeScript / Vue / React source code, and assist in locating interface problems between the front-end and back-end; The front-end and back-end integration unit is used for unified debugging of the session manager, cross-short call chain tracing, and shared variable observation area.

7. The system as described in claim 6, characterized in that, The hot deployment module includes: The backend Java hot deployment unit is used to hot deploy modified backend code based on class hot replacement engine, incremental class loader, Spring context hot refresh technology and method-level hot update technology. The front-end hot update unit is used to implement hot updates of front-end code based on HMR, hot style injection, and hot update between components.

8. The system as described in claim 7, characterized in that, The one-click release module is used to implement one-click code release based on the release pipeline orchestrator, code difference analyzer, environment configuration manager and canary release controller; The one-click publish module is also used to provide a publish rollback mechanism.

9. A data processing method based on the Java low-code platform, characterized in that, The method is implemented based on the system described in claim 8, and includes: Receive user access requests for the Java low-code platform and initialize the online development environment based on the access requests; Receive online editing requests sent by users through online IDE clients, and perform online editing of front-end code files or back-end code files based on the online editing requests; The file is modified and the new .class file is hot-deployed; the file change listener is set in the container. Enables online real-time debugging at the source code level based on front-end or back-end breakpoints; the front-end and back-end breakpoints are set by the user in the IDE client; When the file change listener detects code modifications, it triggers an incremental compilation process to generate new .class files. Receive release requests sent by users through online IDE clients, and complete one-click code release based on the release requests.

10. The method as described in claim 9, characterized in that, The code is published with one click based on the aforementioned publication request, specifically as follows: Select the target environment and its target code based on the release request; By comparing the current code with the target code through the release service, an incremental release package containing the changed files is generated based on the comparison results. After the incremental release package undergoes automated testing, it proceeds to the deployment process. The incremental release package is released to the target server cluster according to the deployment strategy of the target environment; the deployment strategy includes full release or canary release; After release, release logs and code snapshots are recorded, and rollback operations are supported.

Images