Development system framework and method based on low-code platform

Abstract

The invention relates to the technical field of data processing, in particular to a development system framework and method based on a low-code platform. The development framework comprises a presentation layer used for generating a user interface and obtaining data input by a user in the user interface; the business logic layer is used for managing a dependency relationship between business logic components and processing the data sent by the presentation layer through the business logic components to obtain a processing result; and the persistent layer is used for generating and executing SQL statements so as to persist the processing result into the database or obtain data from the database and feed back the data to the presentation layer. By using the development system framework, the coding quantity can be reduced, and the development efficiency can be improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of data processing, and particularly to a development system framework and method based on a low-code platform. BACKGROUND

[0002] In a traditional development mode, a developer often needs to build each layer of an application system from the ground up, from the design of a user interface to the implementation of complex business logic and the interaction with a database, and each link requires a large amount of repetitive code writing work. This "zero-start" development mode not only consumes a large amount of time and effort of the developer, resulting in a long development cycle, but also makes it difficult for an enterprise to quickly respond to changes in market demand.

[0003] To this end, how to reduce the coding workload to improve the development efficiency is a technical problem that needs to be solved at present. SUMMARY

[0004] To solve the technical problem of low development efficiency caused by a large amount of repetitive code writing in the traditional development mode, the present application provides solutions in the following aspects.

[0005] In a first aspect, the present application provides a development system framework based on a low-code platform, comprising: a presentation layer configured to generate a user interface and obtain data input by a user in the user interface; a business logic layer configured to manage a dependency relationship between business logic components and process data sent by the presentation layer through the business logic components to obtain a processing result; and a persistence layer configured to generate and execute an SQL statement to persist the processing result into a database or obtain data feedback from the database to the presentation layer.

[0006] Further, the presentation layer obtains the layout, attributes and interaction behaviors of interface elements through Axelor, and generates the user interface according to the layout, attributes and interaction behaviors of the interface elements, wherein the layout, attributes and interaction behaviors of the interface elements are defined by the user through a drag-and-drop and configuration operation mode in the presentation layer.

[0007] Beneficial effects: through simple operation modes such as drag-and-drop and configuration, a developer can quickly create a user interface without writing a large amount of code, thereby shortening the development cycle and improving the development efficiency.

[0008] Further, the business logic layer includes a dependency injection management unit configured to manage the dependency relationship between the business logic components.

[0009] Beneficial effects: through the dependency injection management unit, the developer can focus more on the implementation of business logic, without paying too much attention to the management of the dependency relationship between business logic components, thereby improving the development efficiency.

[0010] Further, the dependency injection management unit is specifically configured to create and inject the dependency object required by the business logic component according to the binding relationship between the interface and the implementation class.

[0011] Beneficial effects: by automatically creating and injecting the dependency object required by the business logic component according to the binding relationship, the decoupling of the business logic component is realized, so that the business logic component does not need to care about the creation process of the dependency object, thereby improving the testability and maintainability of the code.

[0012] Further, the business logic layer further includes a modular management unit, and the modular management unit is configured to divide the system into a plurality of independently managed and maintained modules.

[0013] Beneficial effects: by dividing the system into a plurality of independently managed and maintained modules, each module can focus on a specific business function, thereby facilitating the expansion and upgrade of the system.

[0014] Further, the persistence layer includes an object-relational mapping unit and a transaction management unit, wherein the object-relational mapping unit is configured to map objects and database tables, and the transaction management unit is configured to manage the start, commit and rollback of transactions through the transaction management mechanism of Hibernate.

[0015] Further, the object-relational mapping unit is specifically configured to generate corresponding SQL statements according to the mapping relationship between the entity class and the database table.

[0016] Beneficial effects: by automatically generating corresponding SQL statements according to the mapping relationship between the entity class and the database table, the user does not need to manually write complex SQL code, thereby improving the development efficiency.

[0017] In a second aspect, the present application provides a low-code platform-based development method, which adopts the low-code platform-based development system framework of the first aspect, and the development method comprises the following steps: obtaining the layout, properties and interactive behaviors of the interface elements defined by the user, and the injection relationship between the business logic components and the dependency objects and the mapping relationship between the entity classes and the database tables; the presentation layer generates a user interface according to the layout, properties and interactive behaviors of the interface elements; in response to the need of the business logic component to inject the dependency object, the business logic layer creates and injects the dependency object required by the business logic component according to the injection relationship corresponding to the business logic component; and in response to receiving a persistence operation, the persistence layer generates and executes a corresponding SQL statement according to the mapping relationship.

[0018] Further, the layout, the attribute and the interaction behavior of the user-defined interface element, and the injection relationship between the business logic component and the dependent object and the mapping relationship between the entity class and the database table are acquired, including: the layout, the attribute and the interaction behavior of the interface element are acquired through Axelor; the injection relationship between the business logic component and the dependent object is acquired through Guice; and the mapping relationship between the entity class and the database table is acquired through Hibernate.

[0019] Further, the development method further includes: in response to the user interface receiving user input data, processing the data by the business logic component managed by Guice.

[0020] The present application has the beneficial effects that: through the presentation layer, the user only needs to quickly build the user interface through the visual operation and the small amount of code configuration, reduces the programming workload, shortens the development cycle, and thus improves the development efficiency; through the business logic layer, the user can pay more attention to the implementation of the business logic, and does not need to pay attention to the management of the dependency relationship between the business logic components, thus reducing the programming workload; since the persistence layer can automatically generate the SQL statement, the user does not need to write a large amount of SQL code, thus improving the development efficiency. BRIEF DESCRIPTION OF DRAWINGS

[0021] Figure 1 is a structural block diagram schematically showing a low-code platform-based development system framework according to an embodiment of the present application;

[0022] Figure 2 is a flow block diagram schematically showing a low-code platform-based development method according to an embodiment of the present application. DETAILED DESCRIPTION

[0023] The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, rather than all the embodiments of the present application. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor fall within the protection scope of the present application.

[0024] The specific embodiments of the present application will be described in detail below with reference to the drawings.

[0025] Figure 1 is a structural block diagram schematically showing a low-code platform-based development system framework according to an embodiment of the present application;

[0026] Traditional software development, from interface design to business logic implementation to database operation, generally requires writing a large amount of repetitive code, resulting in low development efficiency, and as the business continues to develop, the function of the application system is increasingly complex, and the traditional monolithic architecture is difficult to cope with the horizontal expansion and function iteration of the system, and the maintenance difficulty and cost of the system also increase. To solve the technical problem of low development efficiency caused by the need to write a large amount of code during development, in a first aspect, the present application provides a development system framework based on a low-code platform.

[0027] Specifically, as shown in the development system framework includes a presentation layer, a business logic layer and a persistence layer. Among them, the presentation layer is used to generate a user interface and obtain data input by a user in the user interface; the business logic layer is used to manage the dependency relationship between business logic components, and process the data sent by the presentation layer through the business logic components to obtain a processing result; the persistence layer is used to generate and execute SQL (Structured Query Language, structured query language) statements to persist the processing result into a database or obtain data feedback from the database to the presentation layer. Figure 1

[0028] In this embodiment, the development system framework integrates the dependency injection framework Guice, the low-code development framework Axelor and the persistence layer framework Hibernate (JPA), wherein the low-code development framework Axelor is applied to the presentation layer, the dependency injection framework Guice is applied to the business logic layer, and the persistence layer framework Hibernate (JPA) is applied to the persistence layer.

[0029] The integration method is to build different information forms into different models (models), and at the same time, the low-code part (such as the front-end view) is displayed on the basis of the model layer, and the reference logic between different models is queried through ORM (object relationship mapping) association on this basis. In the integration process, in order to solve the structural conflict between the low-code platform and the ORM model (that is, the low-code platform allows users to dynamically adjust the database table, but the traditional ORM needs to predefine the entity class, and the change needs to restart the service), the change of the database table structure is synchronized in real time as the ORM entity metadata, and the JPA (Java Persistence API) entity is dynamically updated through bytecode enhancement. In addition, since the process engine needs to ensure the atomicity of multi-database operation when cross-service calling (such as batch order + order service), the corresponding annotation is added to the Service (service) layer managed by DI (dependency injection), and the distributed transaction is triggered through the JPA operation of the ORM.

[0030] ​In one embodiment, the presentation layer includes a visual interface building unit, which is a visual design tool provided by Axelor, for obtaining the layout, attributes and interaction behaviors of interface elements and generating a user interface according to the layout, attributes and interaction behaviors of the interface elements. The layout, attributes and interaction behaviors of the interface elements are defined by the user through operation modes such as dragging and configuring in the visual interface building unit.

[0031] When the user inputs data in the user interface, the presentation layer can obtain the data through Axelor and send the data to the business logic layer.

[0032] By using the visual design tool provided by Axelor, the user can quickly build a user interface through operation modes such as dragging and configuring, which reduces the coding workload of the interface and shortens the development cycle, thereby improving the development efficiency.

[0033] In addition, the business logic can also be implemented through configuration and a small amount of code writing, for example, by defining a workflow, a rule engine and the like, the business process can be automatically implemented, thereby reducing the workload of implementing the business logic through traditional programming.

[0034] In one embodiment, the business logic layer includes a dependency injection management unit, which manages the dependency relationship between business logic components through Guice, that is, when dependency injection is needed, Guice automatically creates a dependent object according to the binding relationship between an interface and an implementation class (which is defined / written by the user) and automatically injects the dependent object required by the business logic component into the business logic component. For example, when a business service class (a kind of business logic component) needs to call other data access classes or tool classes, Guice will automatically create and inject these dependent objects.

[0035] By managing the dependency relationship between business logic components through Guice, the developer can reduce the coding workload of this part and only needs to write the key part, such as the coding related to the business logic, thereby improving the development efficiency.

[0036] In the traditional mode, the business logic component needs to manually create a dependent object, which leads to strong dependence of the code on the specific implementation class, and further leads to the necessity of connecting a real database when testing, while Guice can automatically create and inject a dependent object according to the binding relationship between an interface and an implementation class, so that the dependent implementation can be dynamically replaced when testing, thereby improving the testability of the code; Guice can explicitly determine the dependency relationship through constructor injection (or field injection, etc.), without the need to view the internal implementation of the class to determine which services are dependent, so that the code structure is clear, thereby improving the maintainability of the code.

[0037] Further, the business logic layer further comprises a modular management unit, which is configured to split the system into a plurality of independently manageable and maintainable modules based on the Guice-based features (e.g., display dependency declaration), each of which can focus on a specific business function and interact with each other through dependency injection. By being divided into a plurality of independently manageable and maintainable modules, the modules can be tested, upgraded and developed in parallel, thereby facilitating the expansion and upgrade of the system.

[0038] In one embodiment, the persistence layer comprises an object-relational mapping unit, which is configured to automatically map objects and database tables through Hibernate (JPA). Specifically, the business logic layer acquires user-defined entity classes and mapping relationships between the entity classes and the database tables, and Hibernate automatically generates corresponding SQL statements according to the mapping relationships between the entity classes and the database tables, thereby performing persistent operations (addition, deletion, modification and query, etc.) on the data according to the SQL statements. Herein, the user can describe and define the mapping relationships between the entity classes and the database tables in the business logic layer through annotations or XML (eXtensible Markup Language) configuration files.

[0039] By automatically generating SQL statements, the user does not need to manually write complex SQL codes, thereby shortening the development cycle, improving the development efficiency, and improving the efficiency and accuracy of the persistent operations.

[0040] Further, the persistence layer further comprises a transaction management unit, which is configured to manage the start, commit and rollback of transactions through the transaction management mechanism of Hibernate (JPA) when performing database operations (i.e., addition, deletion, modification and query). By managing transactions through the transaction management mechanism of Hibernate (JPA), the problem of data inconsistency and incompleteness caused by improper transaction processing can be avoided.

[0041] In summary, the presentation layer acquires the data input by the user (user interface triggers business logic operation) through Axelor and transmits it to the business logic layer, which processes the data through the business logic components managed by Guice, and then the persistence layer persists the processed data into the database through Hibernate.

[0042] Through the collaborative work of the frameworks (Axelor, Guice and Hibernate), the development efficiency can be significantly improved, the development cost can be reduced, and the code quality, maintainability and scalability of the system can be improved. When the business requirements of an enterprise change, the system can be quickly expanded in function and upgraded in module without the need for large-scale reconstruction of the entire system.

[0043] Figure 2 is a flow chart diagram schematically showing a low-code platform based development method according to an embodiment of the present application.

[0044] In a second aspect, the present application provides a low-code platform based development method, as shown in Figure 2 The method of the present application comprises the following steps.

[0045] S101, obtaining the layout, attributes and interaction behaviors of the user-defined interface elements, and the injection relationship between the business logic components and the dependent objects and the mapping relationship between the entity classes and the database tables.

[0046] Before that, the system needs to be built. Specifically, the operating environment required by Axelor, Guice and Hibernate is installed and configured, including Java development environment (JDK, Java Development Kit), dependent libraries of various frameworks, etc., to ensure the version compatibility between the frameworks to ensure the stability of the system. Further, using the project initialization tool provided by Axelor, a project skeleton based on low-code development is created, in which the dependencies of Guice and Hibernate are introduced, and the initialization parameters of each framework are configured, such as the module configuration file of Guice, the database connection information of Hibernate (JPA), etc.

[0047] In one embodiment, the layout, attributes and interaction behaviors of the user-defined interface elements can be obtained through Axelor. Specifically, the user (for example, a developer) uses the visual interface design tool provided by Axelor (i.e. the visual interface building unit in the first aspect) to drag the required interface elements (such as text boxes, buttons, tables, input boxes, etc.) on the design canvas, then designs the layout of the interface elements according to the business requirements, sets the attributes of the interface elements (such as the placeholder of the text box, the style of the button, etc.), and finally binds events to the interface elements (such as adding a click event to the button), which refers to the mechanism of associating the interaction behaviors (such as clicking, inputting) of the interface elements (such as buttons, input boxes) with specific code logic. When the event is bound, the user uses the script language or a small amount of Java code provided by Axelor in the event handling code area to define the business logic operation triggered after clicking the button, for example, setting the business logic operation triggered after clicking the "login" button, triggering the click event, calling the corresponding function to verify the username and password in the event callback, or submitting the form data, etc. Thus, the attributes, layout and interaction behaviors of the interface elements are obtained.

[0048] By constructing the visual interface based on Axelor, the user can quickly construct the visual interface without writing a large amount of code, thereby improving the development efficiency.

[0049] In one embodiment, the injection relationship between the business logic component and the dependent object can be obtained by Guice. Specifically, a user can define a business logic component (e.g., a business service class) using Java language, and declare the dependent object required by the business logic component through a constructor, a field, or the like. For example, a user management service class can depend on a user data access object for implementing the add, delete, modify, and query operations of user information. Further, in a module configuration file of Guice, the injection relationship between the business logic component and the dependent object is configured (including declaring the dependent object required by the business logic component, and defining the binding relationship between an interface and an implementation class). Thus, the injection relationship between the business logic component and the dependent object is obtained.

[0050] In one embodiment, the mapping relationship between the entity class and the database table can be obtained by Hibernate. Specifically, a user can define an entity class corresponding to a database table using Java language; further, the mapping relationship between the entity class and the database table can be described through an annotation (e.g., the @Entity, @Table, @Column, or the like annotation of JPA), including the table name, the field name, the field type, or the like. For example, a user entity class is defined, and is mapped to a user table in a database through an annotation. Thus, the mapping relationship between the entity class and the database table is obtained.

[0051] S102, the presentation layer generates a user interface according to the layout, properties, and interaction behaviors of the interface elements.

[0052] S103, in response to the business logic component requiring an injection of a dependent object, the business logic layer creates and injects the dependent object required by the business logic component according to the injection relationship corresponding to the business logic component.

[0053] Specifically, the business logic layer (Guice) automatically creates the dependent object according to the binding relationship between the interface and the implementation class, and injects the dependent object into the corresponding business logic component. For example, a user data access interface is bound with a specific user data access implementation class, and when a business service class requires a user data access object, Guice automatically creates and injects the object. By binding the interface and the implementation class, Guice can be made to know how to create and inject the dependent object, so that the business service class does not need to be related to the creation process of the dependent object, and the testability and maintainability of the code are improved.

[0054] In one embodiment, a user can write specific business logic code in a business service class (a business logic component). When a user interface triggers a business operation, the business logic component calls a method of the dependent object to perform corresponding data processing. For example, in user registration business logic, a method of a user data access object is called to save the information of a user to a database.

[0055] S104, in response to receiving the persistence operation, the persistence layer generates and executes a corresponding SQL statement according to the mapping relationship.

[0056] Specifically, a data access object interface and an implementation class are created. Data operation methods such as save, query, update, delete, etc. are defined in the data access object interface. In the corresponding implementation class, these data operation methods are implemented through the API (Application Programming Interface) provided by Hibernate (JPA). Specifically, when these APIs are called, Hibernate (JPA) generates and executes a corresponding SQL statement according to the mapping relationship between the entity class and the database table to complete data persistence. For example, when session.save(user) is called in UserDaoImpl, Hibernate will first parse the mapping rules of the User class (such as the table name specified by @Table and the field name bound by @Column), and then automatically generate a corresponding INSERT statement according to the operation type of "save" and execute the INSERT statement to complete data persistence. Wherein, UserDaoImpl is an implementation class of a data access object; session.save(user) represents calling the save() method of the Session object of Hibernate to persist the user object to the database; @Table and @Column are annotations of JAP; and the INSERT statement is an insert statement used to save data to the database.

[0057] In an embodiment, in the business service class, the transaction consistency of data operation can be ensured through the transaction management mechanism of Hibernate (JPA). The business method can be annotated with an annotation (such as @Transactional) to include the database operation within the method in a transaction, and when an exception occurs during the execution of the method, the transaction will automatically roll back, thereby ensuring the integrity of the data.

[0058] In an embodiment, when unit testing is performed, a test framework (such as JUnit) can be used to perform unit testing on the business logic component and the data access object. Specifically, test cases are written to verify the correctness of the business logic and the accuracy of the data operation. For example, test cases are written to test whether the user registration business logic can correctly save user information to the database.

[0059] In one embodiment, when the integration test is performed, the operation of the simulated user is performed to test whether the whole process from the interface input to the business logic processing and then to the data persistence can be correctly executed, so as to verify whether the cooperation between the frameworks is normal and the integrity of the system function.

[0060] In the description of the present specification, the meaning of "a plurality of" is at least two, such as two, three or more, etc., unless otherwise explicitly specifically limited. In addition, the division of steps of the above method is only for clear description, and when implemented, one step can be combined or some steps can be split and decomposed into multiple steps, as long as the same logical relationship is included.

[0061] Although the present specification has shown and described several embodiments of the present application, it is apparent to those skilled in the art that such embodiments are provided only by way of example. Those skilled in the art will think of many changes, changes and alternatives without departing from the idea and spirit of the present application. It should be understood that various alternatives to the embodiments of the present application described herein can be employed in practicing the present application.

Claims

1. A low-code platform based development system framework, characterized in that, The application comprises: a presentation layer for generating a user interface and obtaining data input by a user in the user interface; a business logic layer for managing dependency relationships between business logic components and processing data sent by the presentation layer through the business logic components to obtain processing results; a persistence layer for generating and executing SQL statements to persist the processing results into a database or obtain data feedback from the database to the presentation layer.

2. The low-code platform based development system framework of claim 1, wherein, The presentation layer obtains the layout, properties and interaction behaviors of interface elements through Axelor and generates the user interface according to the layout, properties and interaction behaviors of the interface elements, wherein the layout, properties and interaction behaviors of the interface elements are defined by the user in the presentation layer through a drag-and-drop and configuration operation mode.

3. The low-code platform based development system framework of claim 1, wherein, The business logic layer comprises a dependency injection management unit for managing dependency relationships between business logic components.

4. The low-code platform-based development system framework of claim 3, wherein, The dependency injection management unit is specifically configured to create and inject dependency objects required by business logic components according to the binding relationship between interfaces and implementation classes.

5. The low-code platform-based development system framework of claim 3, wherein, The business logic layer further comprises a modular management unit for dividing the system into multiple independently managed and maintained modules.

6. The low-code platform-based development system framework of claim 1, wherein, The persistence layer comprises an object-relational mapping unit and a transaction management unit, wherein the object-relational mapping unit is configured to map objects and database tables, and the transaction management unit is configured to manage the start, commit and rollback of transactions through the transaction management mechanism of Hibernate.

7. The low-code platform-based development system framework of claim 6, wherein, The object-relational mapping unit is specifically configured to generate corresponding SQL statements according to the mapping relationship between entity classes and database tables.

8. A development method based on a low-code platform, adopting the development system framework based on a low-code platform according to claim 1, characterized in that, The application comprises: obtaining the layout, properties and interaction behaviors of interface elements defined by a user, and the injection relationship between business logic components and dependency objects and the mapping relationship between entity classes and database tables; the presentation layer generates a user interface according to the layout, properties and interaction behaviors of interface elements; in response to the need of a business logic component to inject a dependency object, the business logic layer creates and injects the dependency object required by the business logic component according to the injection relationship corresponding to the business logic component; in response to receiving a persistence operation, the persistence layer generates and executes corresponding SQL statements according to the mapping relationship.

9. The low-code platform based development method of claim 8, wherein, The application comprises: obtaining the layout, properties and interaction behaviors of interface elements through Axelor; obtaining the injection relationship between business logic components and dependency objects through Guice; obtaining the mapping relationship between entity classes and database tables through Hibernate. The application further comprises:

10. The low-code platform based development method of claim 8, wherein, in response to the user interface receiving data input by a user, processing the data through a business logic component managed by Guice. ​

Images