Low-code development platform, method, and device based on an independent deployment architecture

Abstract

This application relates to the technical field of software development, and discloses a low-code development platform, method, and device based on an independent deployment architecture. The platform includes multiple modules, is designed with a C / S architecture, and splits low-code into corresponding microservices; starts independent running services for each application; deploys multiple replicas of the same application on multiple hosts or in K8S namespaces; during multi-replica deployment, different applications are isolated from each other, and applications interact with other services. Each application will call other microservices when running; when it comes to calls between different services, RESTful APIs are used for data exchange; an asynchronous call method is adopted, and tasks are processed based on an asynchronous thread pool. Through the solution provided by this disclosure, an efficient application independent deployment architecture of the low-code platform can be achieved, meeting the needs of customers for flexible and efficient deployment and use, and improving development efficiency.

Description

Technical Field

[0001] This application relates to the technical field of software development, for example, to a low-code development platform, method, and device based on an independent deployment architecture. Background Art

[0002] With the rapid development and wide use of low-code platforms, in addition to meeting the basic functions, customers have further requirements for the flexibility, scalability, and performance of the platforms.

[0003] In the existing platform solutions, the independent deployment function has been introduced to support the independent deployment of running applications, improving the application delivery efficiency and operation and maintenance flexibility.

[0004] However, in the process of developing based on the existing development platforms, there are still problems such as low efficiency, poor flexibility, and reliability.

[0005] It should be noted that the information disclosed in the above background art section is only used to enhance the understanding of the background of this application. Summary of the Invention

[0006] To have a basic understanding of some aspects of the disclosed embodiments, a simple summary is given below. This summary is not a general review, nor is it intended to identify key / important constituent elements or delineate the protection scope of these embodiments, but rather serves as a preface to the subsequent detailed description.

[0007] The embodiments of the present disclosure provide a low-code development platform based on an independent deployment architecture, which includes a gateway service module, a form design module, a database design module, a process engine module, and a message center module;

[0008] Based on the gateway service module, the form design module, the database design module, the process engine module, and the message center module, using the C / S architecture design, the low-code is split into corresponding individual microservices;

[0009] The design state and the running state are decoupled into independent microservices, and the development and design of the applications to be published are completed in the design state, and independent running state services are started for each application;

[0010] The same application is deployed in multiple replicas on multiple hosts or in K8S namespaces to support horizontal scaling and elastic scaling;

[0011] When deploying in multiple replicas, a circular mechanism is used for deployment in the same Nacos space. Different applications are isolated from each other, and applications interact with other services. Each application will call other microservices when running;

[0012] When it comes to the invocation between different services, use RESTful API for data exchange;

[0013] Adopt an asynchronous invocation method and process tasks based on an asynchronous thread pool.

[0014] In some embodiments, when there are multiple different application services in the same operating environment and the service process needs to invoke an application request, based on the application ID of the application or other unique identification fields in the database, the corresponding application process is invoked.

[0015] In some embodiments, the above-mentioned method of adopting an asynchronous invocation method and processing tasks based on an asynchronous thread pool includes:

[0016] Modify each request in the thread pool using the Decorator pattern, store and record the attribute information in the request corresponding to each thread, and return the stored attribute information in the request together when returning the thread information.

[0017] In some embodiments, in terms of data storage, the above-mentioned development platform supports relational databases and NoSQL databases, uses Nacos as a dynamic service discovery, configuration management, and service management tool, and uses the load balancer Nginx to distribute requests.

[0018] The embodiments of the present disclosure provide a low-code development method based on an independent deployment architecture, which is applied to a development platform including a gateway service module, a form design module, a database design module, a process engine module, and a message center module;

[0019] Based on the gateway service module, the form design module, the database design module, the process engine module, and the message center module, adopt a C / S architecture design and split the low-code into corresponding microservices;

[0020] Decouple the design state and the running state into independent microservices, complete the development and design of the applications to be published in the design state, and then start independent running state services for each application;

[0021] Deploy multiple replicas of the same application on multiple hosts or in K8S namespaces to support horizontal expansion and elastic scaling;

[0022] When performing multiple-replica deployment, use a cyclic mechanism for deployment in the same Nacos space. Different applications are isolated from each other, and applications interact with other services. Each application will call other microservices when running;

[0023] When it comes to the invocation between different services, use RESTful API for data exchange;

[0024] Adopt the asynchronous call method and process tasks based on an asynchronous thread pool.

[0025] In some embodiments, when there are multiple different application services in the same operating environment and some service processes need to call application requests, the corresponding application process is called based on the application ID of the application or other unique identification fields in the database.

[0026] In some embodiments, the above method of adopting asynchronous call and processing tasks based on an asynchronous thread pool includes:

[0027] Modify each request in the thread pool using the Decorator pattern, store and record the attribute information in the request corresponding to each thread, and return the stored attribute information in the request together when returning the thread information.

[0028] In some embodiments, in terms of data storage, the above development platform supports relational databases and NoSQL databases, uses Nacos as a dynamic service discovery, configuration management, and service management tool, and uses the load balancer Nginx to distribute requests.

[0029] Embodiments of the present disclosure provide an electronic device, which includes at least one processor;

[0030] and a memory communicatively connected to the at least one processor;

[0031] The memory stores instructions executable by the at least one processor. When the instructions are executed by the at least one processor, the at least one processor is enabled to execute the above-mentioned low-code development method based on an independent deployment architecture.

[0032] Embodiments of the present disclosure provide a storage medium storing program instructions, which, when running, execute the above-mentioned low-code development method based on an independent deployment architecture.

[0033] The low-code development platform, method, device, and storage medium provided by the embodiments of the present disclosure can achieve the following technical effects:

[0034] The low-code platform in this disclosure realizes the separation of front-end and back-end and loose-coupling operation by supporting the microservices architecture system, ensuring the efficient development and deployment of applications. At the same time, the platform introduces an independent deployment function, supporting the independent deployment of running applications, further improving the application delivery efficiency and operation and maintenance flexibility. Moreover, for higher performance, the platform innovatively supports multi-lane gray-scale calls and processes request services for different lanes through an asynchronous thread pool, optimizing resource utilization and improving the system's response speed and stability. These technical features jointly promote the wide application of the low-code development platform in enterprise digital transformation, providing users with an efficient, flexible, and reliable development environment.

[0035] The above general description and the following description are only exemplary and explanatory, and are not used to limit this application. Brief Description of the Drawings

[0036] One or more embodiments are exemplarily illustrated by corresponding drawings. These exemplary illustrations and the drawings do not constitute limitations on the embodiments. Elements with the same reference numerals in the drawings are shown as similar elements. The drawings do not constitute a scale limitation, and among them:

[0037] Figure 1 is a schematic structural diagram of a low-code development platform based on an independent deployment architecture provided by an embodiment of the present disclosure;

[0038] Figure 2 is a schematic diagram of the independent deployment function of a low-code platform supporting multi-lane gray-scale calls provided by an embodiment of the present disclosure;

[0039] Figure 3 is a schematic diagram of the scheduling between different services of low code provided by an embodiment of the present disclosure;

[0040] Figure 4 is a schematic diagram of an asynchronous thread pool supporting multi-lane gray-scale calls provided by an embodiment of the present disclosure;

[0041] Figure 5 is a schematic flowchart of a low-code development method based on an independent deployment architecture provided by an embodiment of the present disclosure;

[0042] Figure 6 is a schematic structural diagram of a low-code development device based on an independent deployment architecture provided by an embodiment of the present disclosure. Detailed Description of the Embodiments

[0043] In order to understand the features and technical content of the embodiments of the present disclosure in more detail, the implementation of the embodiments of the present disclosure will be described in detail below with reference to the accompanying drawings. The accompanying drawings are for reference and illustration purposes only and are not intended to limit the embodiments of the present disclosure. In the following technical description, for the sake of explanation, numerous details are provided to give a full understanding of the disclosed embodiments. However, one or more embodiments may still be implemented without these details. In other instances, well-known structures and devices may be shown in a simplified manner to simplify the drawings.

[0044] The terms "first", "second", etc. in the embodiments of the present disclosure are used to distinguish similar objects and do not necessarily describe a specific order or sequence. It should be understood that the data used in this way can be interchanged under appropriate circumstances so as to implement the embodiments of the present disclosure described herein. In addition, the terms "comprising" and "having" and any variations thereof are intended to cover non-exclusive inclusion.

[0045] Unless otherwise specified, the term "plurality" means two or more.

[0046] In the embodiments of the present disclosure, the character " / " indicates that the objects before and after are in an "or" relationship. For example, A / B means: A or B.

[0047] The term "and / or" is a description of the association relationship of objects, indicating that three relationships can exist. For example, A and / or B means: A or B, or, the three relationships of A and B.

[0048] The term "corresponding" may refer to an association relationship or a binding relationship. A corresponding to B means that there is an association relationship or a binding relationship between A and B.

[0049] To solve the above problems, the present disclosure provides a low-code development platform, method, device, and storage medium based on an independent deployment architecture.

[0050] The following describes the low-code development platform, method, device, and storage medium based on an independent deployment architecture provided by the embodiments of the present disclosure with reference to the accompanying drawings.

[0051] Figure 1 It is a schematic structural diagram of a low-code development platform based on an independent deployment architecture provided by the embodiments of the present disclosure.

[0052] Combined with Figure 1 As shown, the low-code development platform based on an independent deployment architecture may include a gateway service module 101, a form design module 102, a database design module 103, a process engine module 104, and a message center module 105;

[0053] Based on the gateway service module 101, form design module 102, database design module 103, process engine module 104, and message center module 105, using the client / server (C / S) architecture design, the low-code is split into corresponding microservices;

[0054] Decouple the design state and the running state into independent microservices, and complete the development and design of the applications to be published in the design state, and start independent running state services for each application;

[0055] Deploy multiple replicas of the same application on multiple hosts or in a container orchestration system (Kubernetes, K8S) namespace to support horizontal scaling and elastic scaling;

[0056] During multi-replica deployment, use a circular mechanism to deploy in the same Nacos space. Different applications are isolated from each other, and applications interact with other services. Each application will call other microservices when running. Among them, Nacos is a dynamic service discovery, configuration management, and service management platform that is easy to build cloud-native applications;

[0057] When it comes to calls between different services, use the Representational State Transfer Application Programming Interface (RESTful API) for data exchange;

[0058] Adopt an asynchronous call method to process tasks based on an asynchronous thread pool.

[0059] In some embodiments, when there are multiple different application services in the same running environment and the service process needs to call an application request, based on the application ID of the application or other unique identification fields in the database, call the corresponding application process.

[0060] In some embodiments, the above-mentioned method of adopting asynchronous calls to process tasks based on an asynchronous thread pool includes:

[0061] Modify each request in the thread pool using the Decorator pattern, store and record the attribute information in the request corresponding to each thread, and return the stored attribute information in the request together when returning the thread information.

[0062] In some embodiments, in terms of data storage, the above-mentioned development platform supports relational databases and non-relational (Not Only SQL, NoSQL) databases, uses Nacos as a dynamic service discovery, configuration management, and service management tool, and uses the load balancer Nginx to distribute requests.

[0063] In a specific example, Figure 1 For the low-code development platform based on the independent deployment architecture, in terms of the microservices architecture, according to the microservices architecture design concept, first, based on the main functional modules, define the service boundaries, split these functional modules into independent microservices, and support dynamic deployment and elastic scaling. A complete low-code platform system includes a user center, a gateway service, form design, database design, a process engine, a message center, etc. According to these functional modules, using the C / S architecture design, split the low-code into corresponding individual microservices. Among them, the process engine module corresponds to the workflow service; the application design module corresponds to the application service.

[0064] The front end can be developed using VUE3 + ElementUI, and the back end uses Java + Spring Boot, etc. In terms of data storage, it supports relational databases and NoSQL databases (Redis). Use Nacos as the dynamic service discovery, configuration management, and service management tool, and use the load balancer Nginx to distribute requests.

[0065] In terms of the independently deployed running-state applications, to achieve the dynamic deployment of applications, decouple the design state and the running state into independent microservices. Complete the development and design of the applications to be published in the design state, and then start independent running-state services for each application.

[0066] To balance performance and make full use of machine resources, it is usually necessary to deploy multiple different applications in the same space. To improve the availability and reliability of the system, deploy multiple replicas of the same application on multiple hosts or in K8S namespaces to support horizontal scaling and elastic scaling. During the multi-replica deployment, we use a circular mechanism to deploy in the same Nacos space. Different applications are isolated from each other, but applications interact with other services such as (workflow, message, user center). Each application will call other microservices when running, as Figure 2 shown in the function diagram.

[0067] In terms of multi-lane grayscale calls, in the same set of operating environments, when it comes to calls between different services, services usually communicate through the HyperText Transfer Protocol (HTTP) or Google Remote Procedure Call (gRPC) technology. In this disclosure, RESTful APIs are used for data exchange. However, if there are multiple different application services in the same operating environment, special tags are needed to identify external requests. When some service processes need to call application requests, the application requests can be accurately called to the application process. Here, the distinguishable variable for different applications is the application ID or other unique identification fields in the database. In this disclosure, the application ID is used as the distinguishing identifier. This identifier can be placed in the HTTP request header. This technology ensures that requests can be accurately sent to the corresponding application services under the synchronization mechanism and the corresponding processing results can be obtained.

[0068] However, to improve efficiency, asynchronous services are needed. In particular, an asynchronous thread pool can better solve the problems of high concurrency and reduce blocking. In actual application operations, it will be found that the services are disordered when calling applications. For example, when it is expected to initiate a main process in Application A to call the corresponding sub-process, it will involve the interaction between the workflow service and the application service, such as Figure 3 shown.

[0069] a. When initiating the main process form action, it runs in the process of Application A service, and then calls the workflow service process to handle workflow-related services;

[0070] b. When processing in the workflow service, it calls the Application A process again to judge the rules in the form and identify the sub-processes that need to be triggered;

[0071] c. Furthermore, Application A service calls the workflow process again. After processing the sub-process information in the workflow process, the result needs to be fed back to the application;

[0072] d. At this time, the workflow process needs to call the correct application process to feed back the result. Here, the workflow process can use asynchronous calls to the application service to improve efficiency.

[0073] Although in the case of asynchronous requests, the system uses an interceptor to intercept the requests and stores the tag information of the request header, the application ID, in the context. In this way, the workflow process can call the correct corresponding application process and then return the result to the application and the front-end user.

[0074] In terms of processing service requests from different lanes in an asynchronous thread pool, to reduce the overhead of thread creation and destruction, thread pools are usually used to handle tasks. In this disclosure, to improve the reuse rate of system resources, we also use an asynchronous thread pool to handle tasks during asynchronous calls. However, during actual operation, it is found that there will be problems such as disorderly application calls and incorrect process handling. The interaction between the asynchronous thread pool and the application is as Figure 4 shown.

[0075] In a thread pool, ThreadLocal is generally used to store thread information. Since the threads processing requests in the thread pool are random, if thread A is active when a request is called into the thread pool, thread A will be used to continue processing the task. However, at this time, the ThreadLocal variable in thread A is the information of the previous request. Although we use different request header information when calling the thread pool, this new request header information is not actually used. Therefore, in the asynchronous thread pool, we need to introduce and pass some necessary contexts in the request.

[0076] Here, to ensure that the request information headers are not lost in the thread pool, the Decorator pattern is used to modify each request in the thread pool. First, the attribute information in the request corresponding to each thread is stored and recorded, and the method RequestContextHolder.getRequestAttributes() is used here; then when returning, the thread information returns the above-stored request attribute information together. This ensures the information flow of the request headers with application IDs from the request between different processes and will not be lost when using the asynchronous thread pool.

[0077] To improve the efficiency of system resource utilization, in this disclosure, we innovatively use an asynchronous thread pool to process request services from different lanes, which not only ensures the independence and concurrent processing ability of tasks in different lanes, but also needs to be able to correctly process request services and responses from different lanes.

[0078] Through the method provided in this disclosure, an efficient application independent deployment architecture for a low-code platform can be realized, meeting the needs of customers for flexible and efficient deployment and use, and improving the development efficiency.

[0079] Corresponding to the Figure 1 low-code development platform based on an independent deployment architecture in , this disclosure also provides a low-code development method based on an independent deployment architecture. This method is applied to a development platform including a gateway service module, a form design module, a database design module, a process engine module, and a message center module;

[0080] As Figure 5 shown, this method can specifically include:

[0081] S501, based on the gateway service module, form design module, database design module, process engine module, and message center module, adopts the C / S architecture design, and splits the low-code into corresponding individual microservices;

[0082] S502, decouples the design state and the running state into independent microservices, completes the development and design of the applications to be published in the design state, and then starts independent running state services for each application;

[0083] S503, deploys multiple replicas of the same application on multiple hosts or in K8S namespaces to support horizontal scaling and elastic scaling;

[0084] S504, when performing multi-replica deployment, uses a circular mechanism for deployment in the same Nacos space. Different applications are isolated from each other, and applications interact with other services. Each application will call other microservices when running;

[0085] S505, when it comes to calls between different services, uses RESTful API for data exchange;

[0086] S506, adopts an asynchronous call method and processes tasks based on an asynchronous thread pool.

[0087] In some embodiments, when there are multiple different application services in the same running environment and some service processes need to call application requests, the corresponding application process is called based on the application ID of the application or other unique identification fields in the database.

[0088] In some embodiments, the above-mentioned method of adopting an asynchronous call method and processing tasks based on an asynchronous thread pool includes:

[0089] Modifies each request in the thread pool using the Decorator pattern, stores and records the attribute information in the request corresponding to each thread, and returns the stored attribute information in the request together when returning the thread information.

[0090] In some embodiments, in terms of data storage, the above-mentioned development platform supports relational databases and NoSQL databases, uses Nacos as a dynamic service discovery, configuration management, and service management tool, and uses the load balancer Nginx to distribute requests.

[0091] Combined with Figure 6As shown in the figure, an embodiment of the present disclosure further provides a low-code development device 600 based on an independent deployment architecture, including a processor 604 and a memory 601. Optionally, the system may further include a communication interface 602 and a bus 603. Among them, the processor 604, the communication interface 602, and the memory 601 can complete mutual communication through the bus 603. The communication interface 602 can be used for information transmission. The processor 604 can call the logical instructions in the memory 601 to execute the low-code development method based on the independent deployment architecture in the above embodiment.

[0092] In addition, when the logical instructions in the above-mentioned memory 601 can be implemented in the form of software functional units and sold or used as an independent product, they can be stored in a computer-readable storage medium.

[0093] The memory 601, as a computer-readable storage medium, can be used to store software programs and computer-executable programs, such as the program instructions / modules corresponding to the methods in the embodiments of the present disclosure. The processor 604 executes functional applications and data processing by running the program instructions / modules stored in the memory 601, that is, implements the low-code development method based on the independent deployment architecture in the above embodiment.

[0094] The memory 601 may include a program storage area and a data storage area. Among them, the program storage area can store an operating system and application programs required for at least one function; the data storage area can store data created according to the use of the terminal device, etc. In addition, the memory 601 may include a high-speed random access memory and may also include a non-volatile memory.

[0095] An embodiment of the present disclosure provides a computer-readable storage medium storing computer-executable instructions, and the computer-executable instructions are set to be a low-code development method based on an independent deployment architecture.

[0096] The above-mentioned computer-readable storage medium may be a transient computer-readable storage medium or a non-transient computer-readable storage medium.

[0097] The technical solution of the embodiments of the present disclosure can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes one or more instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method of the embodiments of the present disclosure. The aforementioned storage medium may be a non-transitory storage medium, including: various media such as USB flash drives, mobile hard disks, read-only memories (ROMs), random access memories (RAMs), magnetic disks, or optical discs that can store program codes, or it may also be a transitory storage medium.

[0098] The above description and the drawings fully illustrate the embodiments of the present disclosure, enabling those skilled in the art to practice them. Other embodiments may include structural, logical, electrical, process, and other changes. The embodiments only represent possible variations. Unless explicitly required, separate components and functions are optional, and the order of operations may vary. Parts and features of some embodiments may be included in or replace parts and features of other embodiments. As used in the description of the embodiments, unless the context clearly indicates otherwise, the singular forms "a", "an", and "the" are intended to also include the plural forms. Similarly, as used in this application, the term "and / or" refers to any and all possible combinations including one or more of the associated listed items. Additionally, when used in this application, the term "comprise" and its variants "comprises" and / or "comprising" etc. mean the presence of the stated features, wholes, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, wholes, steps, operations, elements, components, and / or groups of these. Without further limitation, an element defined by the statement "comprising one..." does not exclude the presence of additional identical elements in the process, method, or device including the element. In this article, each embodiment may focus on the differences from other embodiments, and the same or similar parts among the embodiments may be referred to each other. For the methods, products, etc. disclosed in the embodiments, if they correspond to the method part disclosed in the embodiments, the relevant parts may refer to the description of the method part.

[0099] Those skilled in the art can realize that the units and algorithm steps of each example described in combination with the embodiments disclosed herein can be implemented by electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are executed in a hardware or software manner may depend on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods for each specific application to implement the described functions, but such implementation should not be considered to exceed the scope of the embodiments of the present disclosure. Those skilled in the art can clearly understand that for the convenience and conciseness of description, the specific working processes of the systems, devices, and units described above can refer to the corresponding processes in the foregoing method embodiments and will not be elaborated herein.

[0100] In the embodiments disclosed herein, the disclosed methods, products (including but not limited to devices, equipment, etc.) can be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of units can be merely a logical function division, and there can be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the displayed or discussed couplings or direct couplings or communication connections to each other can be through some interfaces. The indirect couplings or communication connections of devices or units can be in electrical, mechanical, or other forms. The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they can be located in one place or distributed to multiple network units. Some or all of the units can be selected according to actual needs to implement this embodiment. In addition, in the embodiments of the present disclosure, the functional units can be integrated into one processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit.

[0101] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to embodiments of the present disclosure. In this regard, each block in the flowchart or block diagram may represent a module, a segment of a program, or a portion of code, which contains one or more executable instructions for implementing the specified logical function. In some alternative implementations, the functions noted in the blocks may occur in a different order than noted in the drawings. For example, two consecutive blocks may actually be executed substantially in parallel, or they may sometimes be executed in the reverse order, depending on the functions involved. In the description corresponding to the flowcharts and block diagrams in the accompanying drawings, the operations or steps corresponding to different blocks may also occur in a different order than disclosed in the description, and sometimes there is no specific order between different operations or steps. For example, two consecutive operations or steps may actually be executed substantially in parallel, or they may sometimes be executed in the reverse order, depending on the functions involved. Each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented by a dedicated hardware-based system that performs the specified functions or actions, or can be implemented by a combination of dedicated hardware and computer instructions.

[0102] The various embodiments of the systems and techniques described above in this document can be implemented in digital electronic circuitry, integrated circuit systems, field-programmable gate arrays (FPGA), application-specific integrated circuits (ASIC), application-specific standard products (ASSP), systems-on-a-chip (SOC), complex programmable logic devices (CPLD), computer hardware, firmware, software, and / or combinations thereof. These various embodiments can include: being implemented in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which can be a dedicated or general-purpose programmable processor that can receive data and instructions from a storage system, at least one input device, and at least one output device, and transmit the data and instructions to the storage system, the at least one input device, and the at least one output device.

[0103] The program code for implementing the methods of the present disclosure can be written in any combination of one or more programming languages. These program codes can be provided to the processor or controller of a general-purpose computer, a dedicated computer, or other programmable data processing device, such that when the program codes are executed by the processor or controller, the functions / operations specified in the flowcharts and / or block diagrams are implemented. The program codes can be executed entirely on the machine, partially on the machine, as an independent software package partially on the machine and partially on a remote machine, or entirely on a remote machine or server.

[0104] In the context of this disclosure, a machine-readable medium can be a tangible medium that can contain or store a program for use by or in connection with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

[0105] In order to provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user; and a keyboard and a pointing device (e.g., a mouse or a trackball) by which the user can provide input to the computer. Other kinds of devices can also be used to provide interaction with the user; for example, the feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including acoustic input, speech input, or tactile input).

[0106] The systems and techniques described herein can be implemented in a computing system including backend components (e.g., as a data server), or a computing system including middleware components (e.g., an application server), or a computing system including frontend components (e.g., a user computer having a graphical user interface or a web browser through which the user can interact with an implementation of the systems and techniques described herein), or a computing system including any combination of such backend components, middleware components, or frontend components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: a local area network (LAN), a wide area network (WAN), and the Internet.

[0107] A computer system can include a client and a server. The client and the server are generally far apart from each other and typically interact through a communication network. The relationship of the client and the server is generated by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, can also be a server of a distributed system, or a server incorporating a blockchain.

[0108] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired results of the technical solution of this disclosure can be achieved, and no limitation is imposed herein.

[0109] The above specific embodiments do not constitute a limitation on the protection scope of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub - combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure shall be included within the protection scope of this disclosure.

Claims

1. A low-code development platform based on an independent deployment architecture, characterized in that: The platform includes a gateway service module, a form design module, a database design module, a process engine module and a message center module; Based on the gateway service module, form design module, database design module, process engine module and message center module, the C / S architecture design is adopted to split the low code into responsive microservices; Decouple the design state and the running state into independent microservices, complete the development and design of the applications to be released in the design state, and start independent running state services for each application; Deploy multiple copies of the same application on multiple hosts or K8S namespaces to support horizontal expansion and elastic scaling; When deploying multiple copies, a circular mechanism is used in the same Nacos space. Different applications are isolated from each other, and the applications interact with other services. Each application will call other microservices during runtime. When it comes to calls between different services, use RESTful API for data exchange; Using asynchronous calling method, tasks are processed based on asynchronous thread pool.

2. The platform according to claim 1, characterized in that When there are multiple different application services in the same operating environment, when the service process needs to call an application request, the corresponding application process is called based on the application ID of the application or other unique identification fields in the database.

3. The platform according to claim 1, characterized in that: The method of using asynchronous calls to process tasks based on an asynchronous thread pool includes: In the thread pool, each request is modified using the Decorator mode, and the attribute information in the request corresponding to each thread is stored and recorded. When the thread information is returned, the attribute information in the stored request is returned together.

4. The platform according to claim 1, characterized in that: In terms of data storage, the development platform supports relational databases and NoSQL databases, uses Nacos as a dynamic service discovery, configuration management and service management tool, and uses the load balancer Nginx to distribute requests.

5. A low-code development method based on an independent deployment architecture, characterized in that: The method is applied to a development platform including a gateway service module, a form design module, a database design module, a process engine module and a message center module; Based on the gateway service module, form design module, database design module, process engine module and message center module, the C / S architecture design is adopted to split the low code into responsive microservices; Decouple the design state and the running state into independent microservices, complete the development and design of the applications to be released in the design state, and then start independent running state services for each application; Deploy multiple copies of the same application on multiple hosts or K8S namespaces to support horizontal expansion and elastic scaling; When deploying multiple copies, a circular mechanism is used in the same Nacos space. Different applications are isolated from each other, and the applications interact with other services. Each application will call other microservices during runtime. When it comes to calls between different services, use RESTful API for data exchange; Using asynchronous calling method, tasks are processed based on asynchronous thread pool.

6. The method according to claim 5, characterized in that When there are multiple different application services in the same operating environment, and some service processes need to call application requests, the corresponding application process is called based on the application ID of the application or other unique identification fields in the database.

7. The method according to claim 5, characterized in that The method of using asynchronous calls to process tasks based on an asynchronous thread pool includes: In the thread pool, each request is modified using the Decorator mode, and the attribute information in the request corresponding to each thread is stored and recorded. When the thread information is returned, the attribute information in the stored request is returned together.

8. The method according to claim 5, characterized in that In terms of data storage, the development platform supports relational databases and NoSQL databases, uses Nacos as a dynamic service discovery, configuration management and service management tool, and uses the load balancer Nginx to distribute requests.

9. An electronic device, characterized in that: include: at least one processor; and a memory communicatively coupled to the at least one processor; It is characterized in that the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the method according to any one of claims 5-8.

10. A non-transitory computer-readable storage medium storing computer instructions, characterized in that: The computer instructions are used to make a computer execute the method according to any one of claims 5 to 8.

Images