CN117193728A - Development method and device of software as-a-service platform - Google Patents

Abstract

The application discloses a method and a device for developing a software-as-a-service platform. Wherein the method comprises the following steps: analyzing the first metadata to obtain first information, and analyzing the second metadata to obtain second information; determining an object code template corresponding to a business object in a preset code template library, and determining a first code corresponding to first information; converting the first code into an executable program, and processing the first instruction input by software, namely a service platform tenant, through the executable program; generating a component object corresponding to the second information through presetting a low code development frame, and determining a second code corresponding to the component object; determining a loading engine for loading the second code, and analyzing a second instruction input by the software serving as a tenant of the service platform through the loading engine to render a front-end page of the software serving as the service platform. The application solves the technical problem of poor user experience caused by the fact that the user cannot customize the configuration of the undeveloped components in the software, namely the service platform.

Description

Development method and device of software as-a-service platform

Technical Field

The application relates to the technical field of software development, in particular to a method and a device for developing a software-as-a-service platform.

Background

SaaS is a short for Software-as-a-Service, and is a completely innovative Software application mode starting to emerge in the 21 st century with the development of internet technology and the maturation of application Software. The SaaS is a mode of providing software through the Internet, vendors uniformly deploy application software on own servers, customers can order required application software services to vendors through the Internet according to actual demands of the customers, pay the vendors for the services according to the quantity and time of the ordered services, and obtain the services provided by the vendors through the Internet.

The method for customizing the components in the SaaS platform by the relevant software tenants is mainly realized by presetting the components with configurable data by SaaS manufacturers and separating logic and configuration data. Through the method, the client provides configuration data according to manufacturer specifications, so that the purpose of self-defining functions is achieved. However, the parts outside the preset need to find the manufacturer to re-develop the new component and then perform the custom configuration, that is, the user cannot customize the configuration of the undeveloped component in the SaaS platform, so that the use experience of the user is poor.

In view of the above problems, no effective solution has been proposed at present.

Disclosure of Invention

The embodiment of the application provides a method and a device for developing a software-as-a-service platform, which at least solve the technical problem of poor user experience caused by the fact that a user cannot customize the configuration of undeveloped components in the software-as-a-service platform.

According to an aspect of the embodiment of the present application, there is provided a method for developing a software-as-a-service platform, including: analyzing first metadata for describing the business object to obtain first information, and analyzing second metadata for describing the view object to obtain second information; determining an object code template corresponding to the business object in a preset code template library, and determining a first code corresponding to first information through the object code template; converting the first code into an executable program, and processing the first instruction input by software, namely a service platform tenant, through the executable program; generating a component object corresponding to the second information through presetting a low code development frame, and determining a second code corresponding to the component object; determining a loading engine for loading the second code, and analyzing a second instruction input by the software serving as a tenant of the service platform through the loading engine to render a front-end page of the software serving as the service platform.

Optionally, the first metadata comprises at least one of: behavior information, entity information, attribute remote information, attribute persistence information, attribute extension information, field name information, field type information, field source information, field business rule information, field encryption rule information, and field authority information.

Optionally, parsing the first metadata for describing the business object to obtain first information includes: and analyzing entity information, behavior information, attribute remote information, attribute persistence information and attribute extension information in the first metadata to respectively obtain class information, interface information, entity field information, service call information, database information and service logic information corresponding to the service object.

Optionally, parsing, by the loading engine, the second instruction input by the software as a service platform tenant to render a front-end page of the software as a service platform, including: acquiring a first view object to be bound in a second instruction; calling a first business object corresponding to the first view object through a preset interface in the loading engine, and filling the first view object to obtain a second view object; determining a first component object corresponding to the second view object according to the target field in the second instruction; typesetting the first component object according to the configuration information in the second instruction to obtain a second component object; rendering the second component object.

Optionally, generating the component object corresponding to the second information by presetting a low code development framework includes: determining a basic component object according to a design specification corresponding to a preset low-code development framework, wherein the basic component object at least comprises: text box, drop-down box, single selection component, multiple selection component, data chart component; and assembling the basic component objects according to the logic relation of the basic component objects in the second information, and generating the component objects.

Optionally, the second information includes at least one of: front-end component information, data container information, interface call information, page field information, custom code segment information and page document object model structure information, wherein the page document object model structure information is used for integrating the front-end component information, the data container information, the interface call information, the page field information and the custom code segment information.

Optionally, the loading engine is further configured to run on a different terminal device interacting with the software as a service platform through the interpreter.

According to still another aspect of the embodiment of the present application, there is also provided a device for developing a software-as-a-service platform, including: the analysis module is used for analyzing the first metadata used for describing the business object to obtain first information, and analyzing the second metadata used for describing the view object to obtain second information; the first determining module is used for determining an object code template corresponding to the business object in the preset code template library, and determining a first code corresponding to the first information through the object code template; the conversion module is used for converting the first code into an executable program and processing the first instruction input by software, namely a service platform tenant, through the executable program; the second determining module is used for generating a component object corresponding to the second information through presetting a low code development framework and determining a second code corresponding to the component object; and the third determining module is used for determining a loading engine for loading the second code, and analyzing a second instruction input by the software serving as a tenant of the service platform through the loading engine so as to render the front-end page of the software serving as the service platform.

According to still another aspect of the embodiment of the present application, there is also provided a nonvolatile storage medium, where the storage medium includes a stored program, and when the program runs, the device where the storage medium is controlled to execute the above method for developing a software as a service platform.

According to still another aspect of the embodiment of the present application, there is also provided an electronic device including: the system comprises a memory and a processor, wherein the processor is used for running a program stored in the memory, and the program runs to execute the software, namely the development method of the service platform.

In the embodiment of the application, first metadata for describing the business object is analyzed to obtain first information, and second metadata for describing the view object is analyzed to obtain second information; determining an object code template corresponding to the business object in a preset code template library, and determining a first code corresponding to first information through the object code template; converting the first code into an executable program, and processing the first instruction input by software, namely a service platform tenant, through the executable program; generating a component object corresponding to the second information through presetting a low code development frame, and determining a second code corresponding to the component object; determining a loading engine for loading a second code, analyzing a second instruction input by software serving as a tenant of a service platform through the loading engine, analyzing a service object and a view object which are defined by the loading engine to obtain first information and second information, and automatically generating a back-end service and a front-end page through a low-code technology, thereby achieving the purpose of configuring undeveloped components in the service platform, which is the custom software, and further achieving the technical effect of improving the user experience, and further solving the technical problem of poor user experience caused by the fact that the user cannot customize the configuration of the undeveloped components in the service platform.

Drawings

The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this specification, illustrate embodiments of the application and together with the description serve to explain the application and do not constitute a limitation on the application. In the drawings:

FIG. 1 is a flow chart of a method of developing a software-as-a-service platform according to an embodiment of the application;

FIG. 2 is a flow chart of another method of developing a software-as-a-service platform according to an embodiment of the application;

FIG. 3 is a flow chart of a method of generating a backend service according to an embodiment of the present application;

FIG. 4 is a flow chart of a method of generating a front-end page according to an embodiment of the application;

FIG. 5 is a block diagram of a development device of a software-as-a-service platform according to an embodiment of the present application;

fig. 6 is a block diagram of a hardware configuration of a computer terminal (or electronic device) of a development method of a software-as-a-service platform according to an embodiment of the present application.

Detailed Description

In order that those skilled in the art will better understand the present application, a technical solution in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in which it is apparent that the described embodiments are only some embodiments of the present application, not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the present application without making any inventive effort, shall fall within the scope of the present application.

It should be noted that the terms "first," "second," and the like in the description and the claims of the present application and the above figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments of the application described herein may be implemented in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

According to an embodiment of the present application, there is provided a method embodiment of a method for developing a software-as-a-service platform, it being noted that the steps shown in the flowcharts of the drawings may be performed in a computer system such as a set of computer-executable instructions, and that although a logical order is shown in the flowcharts, in some cases the steps shown or described may be performed in an order different from that herein.

Fig. 1 is a flowchart of a method for developing a software-as-a-service platform according to an embodiment of the present application, as shown in fig. 1, the method comprising the steps of:

step S102, analyzing the first metadata for describing the business object to obtain first information, and analyzing the second metadata for describing the view object to obtain second information.

According to some alternative embodiments of the present application, a business object refers to an object in a business logic layer that encapsulates business data and business logic, and a business object is an abstraction of a business entity in the real world of the object, including attributes and behaviors of the entity. Business objects typically correspond to data in tables or other data sources in a database. View objects refer to objects in a user interface layer that are used to present data, and view objects are a subset of business objects that typically include only data of a portion of the attributes of the business objects. The purpose of the view object is to convert the data in the business object into data presented on the user interface, and to receive data entered by the user and convert it into a data format that the business object can handle.

In SaaS, a business object refers to a data entity or collection of entities related to a particular business, which represents a core data model in an application, typically corresponding to a table or document in a database. Business objects include entity attributes, relationships, and behaviors in an application. A view object is a specific representation of a business object for presenting data of the business object to an end user, the view object typically being generated by front-end logic of an application and customized according to the needs and rights of the user. The view object may include some or all of the attributes of the business object and may format, filter, or aggregate the data. In SaaS platforms, the conversion between business objects and view objects is typically handled by an intermediate layer between back-end logic and front-end logic. This middle layer is responsible for converting the business objects in the database into view objects needed by the front end and processing user requests from the front end to convert them into the appropriate business object operations.

Step S104, determining an object code template corresponding to the business object in a preset code template library, and determining a first code corresponding to the first information through the object code template.

According to further alternative embodiments of the present application, a library of code templates is preset, for example: the Spring Boot project template is a template with a predefined project structure and configuration file and is used for quickly creating and starting a Spring Boot application program. The Spring Boot project template comprises common functions, library dependencies and default configurations, so that a developer can conveniently and quickly build a project and start development. The Spring Boot project template may include some common functional modules, such as database access, log recording, security authentication, etc., and some common development tools and framework integration, such as Spring Data JPA, spring Security, swagger, etc.

Alternatively, first, a business object, such as a User object named "User", is defined, including both name and age attributes. Next, a code template, such as a text file named "template. Txt", is created, including the structure and placeholders of the generated code. Then, a function is written that generates code, which accepts a business object and code template as inputs, and returns the generated code string. And finally, calling a function for generating codes, and transmitting the codes into the service object and the code template to generate the codes.

Step S106, converting the first code into an executable program, and processing the first instruction input by the software, i.e. the service platform tenant, through the executable program.

In some alternative embodiments of the application, converting the first code into an executable program includes: the first code is compiled into a machine language, and the process of compiling converts the source code into an intermediate form of executable code, referred to as object code. And linking the target code with the required library file to generate an executable file. The linking process will merge the object code with the desired external library file into one executable file. The generated executable file is run to execute the first code.

The function of the executable program of the rear-end program of the SaaS platform is mainly to process and manage the request and data of the user, provide corresponding services and functions and be particularly responsible for realizing the following functions: 1. user authentication and authorization: the back-end program is responsible for verifying the identity of the user and authorizing the user to access specific functions and data according to the authority level of the user; 2. data storage and management: the back-end program is responsible for storing the data of the user in a proper database and providing operations such as adding, deleting, modifying and the like for the data; 3. business logic processing: the back-end program processes the request of the user by realizing service logic, executes corresponding operation and returns a result to the front-end; 4. security and data protection: the back-end program is responsible for ensuring the security of user data and protecting privacy, including data encryption, access control, malicious attack prevention and the like; 5. performance optimization and extensibility: the back-end program needs to be optimized and adjusted to improve performance so as to cope with the situation of concurrent requests of a large number of users; 6. integration and interface development: the back-end program needs to integrate with other systems, providing interfaces for data exchange and communication with external systems.

Step S108, generating a component object corresponding to the second information through presetting a low code development framework, and determining a second code corresponding to the component object.

As some optional embodiments of the application, a low code development framework is preset such as: a Lowcode-Engine framework, where Lowcode-Engine is a software development framework for rapid development of applications, provides a set of visualizations tools and components that allow a developer to create an application by drag and drop and configuration rather than writing code. The low-code engine framework can greatly accelerate the development speed of the application program and reduce the technical threshold, so that non-technicians can participate in the development of the application program. The low code engine framework typically includes the following functions and features: 1. visual drag-and-drop interface: a developer can design an application program interface through a drag-and-drop component and configuration attributes, and does not need to manually write codes; 2. reusable component library: the low code engine framework typically provides a set of predefined libraries of components that can be used directly by developers to build applications; 3. service logic configuration: a developer may define business logic of an application program, such as form verification, flow control, etc., through a configuration tool; 4. and (3) data model management: the low code engine framework typically provides a data model management tool that allows developers to define and manage data models for applications; 5. code generation and automated testing: the low code engine framework typically has code generation and automated test functions that automatically generate the code of the application and provide test tools to verify the correctness of the application.

And the component object corresponding to the second information is a front-end component in the SaaS platform, wherein the component in the front-end refers to an independent and reusable user interface element or module used for constructing different parts of a webpage or an application. The components may be buttons, forms, navigation bars, carousel graphics, etc., which have their own styles, behaviors, and functions, and which may be used and combined multiple times. By using components, developers can develop and maintain front-end code more efficiently, improving code reusability and maintainability. The modularized development mode also enables team cooperation to be more convenient, different developers can independently develop and test the components responsible for each, and finally, the components are combined to form a complete webpage or application.

Step S110, determining a loading engine for loading the second code, and analyzing the second instruction input by the software serving as the tenant of the service platform through the loading engine to render the front-end page of the software serving as the service platform.

In some alternative embodiments of the present application, first, the front-end page of the SaaS platform is typically provided to the tenant through a user interface, where the tenant enters instructions, such as clicking on a button, filling in a form, etc. And monitoring and capturing instructions of the tenant through a front-end framework or a native JavaScript code. Second, the captured instruction is converted into a processable instruction object, which typically includes information about the instruction type, parameters, target elements, etc., for subsequent processing. And analyzing the instruction by the loading engine, and executing corresponding operation according to the instruction type. Then, the instruction object is transferred to the loaded engine, and the engine executes corresponding analysis operation according to the instruction type. For example, for instructions to fill out forms, the engine may save form data to a database; for a button click instruction, the engine may execute the corresponding business logic. Finally, after the engine executes the instruction, the data or state to be updated is returned. Based on the returned data, the front page can update the corresponding content, such as updating the verification state of the form, displaying the prompt information of successful storage, and the like.

According to the steps, the defined business object and the view object are analyzed to obtain the first information and the second information, and the back-end service and the front-end page are automatically generated through the low-code technology, so that the purpose of configuring undeveloped components in the self-defined software service platform is achieved, and the technical effect of improving the use experience of a user is achieved.

According to some alternative embodiments of the application, the first metadata comprises at least one of: behavior information, entity information, attribute remote information, attribute persistence information, attribute extension information, field name information, field type information, field source information, field business rule information, field encryption rule information, and field authority information.

According to other alternative embodiments of the present application, parsing first metadata describing a business object to obtain first information includes the steps of: and analyzing entity information, behavior information, attribute remote information, attribute persistence information and attribute extension information in the first metadata to respectively obtain class information, interface information, entity field information, service call information, database information and service logic information corresponding to the service object.

Behavior (Action): refers to a certain operation or function in the SaaS platform, such as logging in, registering, adding goods, etc. Entity (Entity): refers to a particular object or instance in the SaaS platform, such as a user, commodity, order, etc. Attribute (Attribute): refers to a certain characteristic or feature of an entity describing a certain aspect of the entity, such as the name of the user, the price of the good, the status of the order, etc. Attribute Remote (Remote Attribute): refers to the case where the value of the attribute needs to be obtained from a remote server or an external SaaS platform, such as obtaining a uniform resource locator for the user's avatar picture. Attribute persistence (Persistent Attribute): refers to the case where the value of the attribute needs to be permanently saved in a database or other persistent store, such as saving the user's registration time, inventory count of goods, etc. Attribute extension (Extended Attribute): refer to extending or supplementing attributes in some way to meet specific needs, such as adding additional custom fields to the user. Field Name (Field Name): a name or identifier referring to an attribute or field is used to uniquely identify the attribute or field. Field Type (Field Type): refers to the data type of an attribute or field, such as a string, integer, date, etc. Field Source (Field Source): refers to the source of data for an attribute or field, such as from user input, database query results, external interfaces, and the like. Field business rules (Field Business Rules): refers to business logic or rules imposed on the values of attributes or fields, such as range restrictions on user age fields, format requirements on commodity price fields, and the like. Field encryption rules (Field Encryption Rules): refers to rules that encrypt values of attributes or fields to protect the security of sensitive information, such as hash encrypting user password fields. Field rights (Field Permissions): refers to access rights control rules for attributes or fields that are used to limit the manipulation or viewing rights of different users or roles to the attributes or fields.

In some optional embodiments of the present application, the loading engine parses the second instruction input by the software, i.e. the service platform tenant, to render the software, i.e. the front end page of the service platform, and may be implemented by the following method: acquiring a first view object to be bound in a second instruction; calling a first business object corresponding to the first view object through a preset interface in the loading engine, and filling the first view object to obtain a second view object; determining a first component object corresponding to the second view object according to the target field in the second instruction; typesetting the first component object according to the configuration information in the second instruction to obtain a second component object; rendering the second component object.

Specifically, firstly, calling an interface to acquire service object data, analyzing data returned by the interface, and filling the data into the service object. Secondly, acquiring field configuration information, including field types, field names, field verification rules and the like; and selecting a corresponding component to load according to the field type. For example, if the field type is text entry, a text entry box component is loaded; if the field type is a drop down list, the drop down list component is loaded. Finally, acquiring page layout configuration information, including the position, the size, the arrangement mode and the like of the components; according to the layout configuration information, the position and the size of the component are adjusted to enable the component to meet the layout requirements; the arrangement of the components, such as horizontal arrangement, vertical arrangement, etc., is determined based on the layout configuration information.

As some optional embodiments of the present application, generating the component object corresponding to the second information by presetting the low code development framework is implemented by: determining a basic component object according to a design specification corresponding to a preset low-code development framework, wherein the basic component object at least comprises: text box, drop-down box, single selection component, multiple selection component, data chart component; and assembling the basic component objects according to the logic relation of the basic component objects in the second information, and generating the component objects.

Basic component objects such as: button (Button): for triggering an interactive action or submitting a form; input box (Input): for entering text or numbers; text box (Textarea): for entering lines of text; drop down box (Dropdown): for selecting one or more options; radio) box: for selecting one from a plurality of options; check box (Checkbox): for selecting a plurality of options from a plurality of options; list (List): for exposing a set of data, paging or rolling loading may be supported; table (Table): the system is used for displaying two-dimensional data and supporting functions of sorting, filtering, paging and the like; popup window (modular): the method is used for displaying prompt information, operation confirmation or detailed content; label page (Tabs): for switching different content pages; navigation bar (Navbar): for navigating different pages or functional areas.

For example, suppose that a simple calculator component object needs to be generated, including addition and subtraction functions, as follows: first, the function and requirements of the component object are determined: the calculator component needs to be able to perform addition and subtraction operations. Next, the required basic component objects are determined: an add component object and a subtract component object. Then, according to the logical relation of the basic component objects, the components are assembled according to a proper sequence: the addition may be performed first and then the subtraction may be performed. Finally, generating a component object according to the assembled basic component object: the add component object and the subtract component object are combined into one calculator component object.

In some alternative embodiments of the application, the second information includes at least one of: front-end component information, data container information, interface call information, page field information, custom code segment information and page document object model structure information, wherein the page document object model structure information is used for integrating the front-end component information, the data container information, the interface call information, the page field information and the custom code segment information.

The front-end component is a modularized code organization mode in front-end development, and splits each functional module of the page into independent components, and each component is responsible for own rendering and interaction logic. The components may be simple buttons, form input boxes, etc., or may be complex lists, carousel maps, etc. The data container is used for storing and managing the data in the application program, and can be a simple variable or a special data management base, and can share the data among different components so as to realize unified management and state consistency of the data. Interface call refers to the process of data interaction between the front-end application and the back-end server. The front end acquires the data of the back end through calling the interface and displays the data on the page. Interface calls may be accomplished using tools such as Ajax, fetch, axios. The page field refers to form elements such as various input boxes, drop-down boxes, check boxes and the like on the page, and elements such as texts, pictures and the like for displaying data. The page field is used for receiving user input or displaying data, and through interaction with the data container, data transmission and updating can be achieved. Custom code fragments refer to code written by a developer according to his own needs to implement specific functions or solve specific problems. The custom code fragment may be a function, a class, a component, etc., that can be invoked where appropriate to achieve the desired functionality. The page document object model structure refers to that a browser analyzes the hypertext markup language document into a tree structure, and through the page document object model structure, operations such as adding, deleting, modifying and checking elements on a page can be performed.

As a further alternative embodiment of the application, the loading engine is also adapted to run on different terminal devices interacting with the software as a service platform via an interpreter.

The terminal device may be a desktop computer, a notebook computer, a smart phone, a tablet computer, or other smart device. The load engine is the component responsible for parsing and executing code, while the interpreter is responsible for converting code into executable instructions. When the terminal device interacts with the software, i.e., the service platform, the loading engine and interpreter may assist the terminal device in performing the desired operations and communicating with the platform. Such interactions may include sending requests to the platform, receiving and processing responses, updating data, and the like. The terminal device interacts with the software, i.e. the service platform, through the loading engine and the interpreter, and can realize remote access and use of various services and functions.

Fig. 2 is a flowchart of a method for developing a software-as-a-service platform according to an embodiment of the present application, as shown in fig. 2, the method comprising the steps of:

in step S202, an object is defined.

In step S2021, a metadata table is built to provide abstract meta-model support for object definition, where the metadata table provides basic entities and relationships for recording and managing attributes and definitions of objects such as tables, columns, indexes, etc. in the database. Metadata tables contain information about the structure, type, constraints, index, associations, etc. of the data set, helping developers and administrators to better understand and manipulate the data.

An object meta-model is a model that describes objects in a SaaS platform and relationships between objects, defines the properties, behavior, and associations of objects, and describes the classification and inheritance relationships of objects. Object metamodels are typically represented using class diagrams, where classes represent the types of objects, attributes represent the characteristics of objects, methods represent the behavior of objects, and associations represent relationships between objects. The view meta-model is a model for describing views and relationships between views in the SaaS platform, defines attributes, operations and associations of the views, and describes organization and dependency relationships between the views. View meta-models are typically represented using a view model graph, where views represent the visible portion of the system, properties represent features of the views, operations represent behavior of the views, and associations represent relationships between the views.

Metadata tables typically contain the following fields or attributes, table names: designating a name of the dataset; column name: designating a column name in the dataset; data type: specifying the data type of each column, such as an integer, a string, a date, etc.; constraint: specifying constraint conditions of each column, such as uniqueness constraint, non-null constraint, etc.; index: designating an index on each column or group of columns to improve query performance; association relation: designating association relations between the tables and other tables, such as a primary key-foreign key relation and the like; remarks: additional description or annotation of the data set is provided. Through the metadata table, a user can quickly understand and query the structure and properties of the data set stored in the database, so that data management, query and analysis can be better performed.

In step S2022, a business object is defined to obtain an object meta-model.

The service object mainly describes a back-end service and comprises a behavior field and an attribute field, wherein the behavior field is used for defining interface capability, and the attribute field is used for defining field basic information, wherein the basic information comprises a field name, a field type, a field source acquisition rule, a field service rule, an index field, persistence, a field encryption rule, a field authority and the like.

The object meta-model includes: behavior information, entity information, the entity information including: attribute information including an extension portion in addition to a field name and a field type: the field source, the field source acquisition rule, the field business rule, whether to index the field, whether to persist, the field encryption rule, and the field permission need to be described.

For example, in a transaction scenario, the following are explanations of behavior information, entity information, attribute information, field names, field types, field sources, field source acquisition rules, field business rules, whether fields are indexed, whether persistence, field encryption rules, and field permissions:

in step S2023, the view object is defined, resulting in a view element model.

The view object mainly describes a front page, and comprises page display and service object mapping rules, wherein the page display comprises: page field name, field type, field display rule; the business object mapping rule is used for defining the value logic of the front-end field, and comprises the following steps: referenced business object, referenced business object field.

The view meta model description comprises page behaviors and page data entities, and the entity attributes comprise field names, page field types, page field display rules, value logic of page fields and referenced business objects.

Step S2024 provides the object designer page based on the object meta model and the view meta model.

In the object designer page, objects and views may be created and edited using object meta-models and view meta-models. Through the object metamodel, objects in the system and their properties, behaviors, and relationships can be defined. Through the view meta model, user interfaces in the system and their components, layouts, and events can be defined. Through the object designer page, the two metamodels can be used to create and edit objects and views, thereby enabling design and development of the system.

Step S204, generating a back-end service. Fig. 3 is a flowchart of a method for generating a backend service according to an embodiment of the present application, as shown in fig. 3, the method includes the steps of:

Step S2041, selecting a target business object in the object designer, and determining a target code template corresponding to the business object in a preset code template library.

In step S2042, the first metadata for describing the service object is parsed to obtain first information, and the first code corresponding to the first information is determined through the target code template.

And analyzing entity information, behavior information, attribute remote information, attribute persistence information and attribute extension information in the first metadata to respectively obtain class information, interface information, entity field information, service call information, database information and service logic information corresponding to the service object.

Step S2043, the first code is converted into a service, and the service is packaged.

Specifically, first, the code is packaged as a separate service. 1. Packaging the main functions in the code into an independent function or class, ensuring that the function or class can independently run and provide the required functions; 2. a Web service is created using a framework or library and the function or class is registered as an interface or route to the service. Next, a startup script is created, which is used to start the service. In the script, the dependencies required by the service are loaded, the configuration of the service is initialized, then the service is started and the designated ports are listened to. Again, the services are packaged using appropriate tools so that they can be deployed and run lightly in different environments. And then, deploying the packaged service image into a target environment, selectively using a container arrangement tool for deployment and management, configuring parameters such as network access authority, resource limitation and the like of the service according to actual requirements, and starting the service. And finally, testing the service by using a proper testing frame and tool to ensure that the service functions normally. Meanwhile, a proper monitoring tool is configured to monitor the service, so that potential problems can be found and solved in time.

Step S2044, release the service.

Step S206, generating a front-end page. Fig. 4 is a flowchart of a method for generating a front-end page according to an embodiment of the present application, as shown in fig. 4, the method includes the following steps:

in step S2061, user interface designer and domain specific language DSL generation is provided based on the Lowcode-Engine framework.

The user interface designer can provide a visual interface, so that a user can design the user interface by dragging and placing components, and can select different components, such as button text boxes, tables and the like, perform layout and style setting, and after the design is completed, the user can preview the interface effect, and adjust and optimize the interface effect. The domain specific language DSL generator can automatically generate corresponding DSL codes according to an interface designed by a user in the user interface designer, wherein the domain specific language is a programming language specific to a domain, and can be used to describe problems and solutions in the domain. By generating DSL code, a user can more conveniently develop and customize using the Lowcode-Engine framework. The generated DSL code can be used to define logic in terms of structure, layout, style, and interactions of the interface. The user can modify and expand the generated codes according to the own requirements so as to realize more complex functions.

Step S2062, based on the Lowcode-Engine design specification, basic components are realized, including basic components such as text boxes, drop-down boxes, single-choice components, multiple-choice components, data chart components and the like.

And step S2063, a dynamic loading engine is realized, a view model is dynamically analyzed, the basic components in step S2062 are automatically assembled, information such as views, interface calls, data mapping and the like is generated, and the generated content can be adjusted through a user interface designer.

Specifically, the automatic assembling base assembly comprises the following steps: first, interfaces and functions of various basic components need to be defined, and the basic components can be existing components or components developed according to requirements. Secondly, in order to realize automatic assembly, the configuration information of the basic components needs to be uniformly managed, i.e. configuration files, databases or other modes can be used for storing and managing the configuration information of the components. And when the system is started, loading the corresponding basic assembly according to the configuration information, and assembling the loaded basic assembly according to the configuration information to form a complete assembly or system. Finally, after assembly is completed, the assembly needs to be initialized and started. The component's initialization method or provided interface may be invoked to launch the component.

In step S2064, the content generated in step S2063 is converted into DSL, where DSL includes: front-end component information, data container information, interface call information, page field information, custom code segment information and page document object model structure information integrating all the information.

In step S2065, a DSL loading engine for Web, H5, etc. protocols is implemented.

According to the grammar rules of DSL, a lexical analyzer is implemented to decompose DSL codes into tags, which can be identified and extracted using regular expressions or other methods; according to the syntax rules of DSL, a syntax analyzer is implemented to build an abstract syntax tree. According to the semantics and requirements of DSL, a DSL loading engine is implemented to execute DSL codes, and the loading engine can execute corresponding operations, such as loading and analyzing resources of protocols of Web, H5 and the like, according to instructions and expressions in an abstract syntax tree. An interface is provided for the DSL loading engine so that a user can write and perform loading tasks using DSL, wherein the interface can include functions such as loading DSL code, executing DSL code, and obtaining execution results.

In step S2066, a corresponding DSL loading engine is built in the front-end application, and the tenant DSL is pulled and the page is rendered.

And when the front-end application is in a proper position, such as an application initialization stage or page loading, a DSL loading request is initiated, and a tenant identification or other necessary parameters are transferred to the DSL loading interface. After receiving the request, the DSL loading interface invokes the DSL loading engine to load and parse the DSL code of the tenant, where the DSL loading engine may obtain the DSL code through a network request, file reading, or other suitable means. Once DSL code is loaded and parsed into data structures that are understandable to the front-end application, the pages can be dynamically generated using these data structures. If the DSL code of the tenant changes, the page can be updated by reinitiating the DSL load request.

Step S208, issuing a function.

Packaging the back-end service into an executable unit, and automatically deploying and operating; compiling the front-end codes into specific domain languages, storing the specific domain languages in the cloud, and pulling the specific domain language files of the terminals by the aid of tenants, and generating front-end pages by means of specific domain language interpreters and dynamic loading engines.

Through the steps, under the condition of self-defining the configuration of undeveloped components in the SaaS platform, the method has the following advantages: 1. the application range is wide, the method is not limited to a specific scene, and is suitable for most business scenes; 2. the use cost is low, and when the tenant realizes the personalized SaaS platform, only the form and the drag are required to be filled in through the object designer and the user interface designer; 3. the special scene supports code embedding, and special problems which cannot be solved by the platform can be realized by a mode of embedding code segments.

Fig. 5 is a structural diagram of a development device of a software-as-a-service platform according to an embodiment of the present application, and as shown in fig. 5, the device includes:

the parsing module 50 is configured to parse the first metadata for describing the service object to obtain first information, and parse the second metadata for describing the view object to obtain second information;

a first determining module 52, configured to determine an object code template corresponding to the service object in a preset code template library, and determine a first code corresponding to the first information through the object code template;

the conversion module 54 is configured to convert the first code into an executable program, and process the first instruction input by software, i.e. a service platform tenant, through the executable program;

a second determining module 56, configured to generate a component object corresponding to the second information by presetting a low code development framework, and determine a second code corresponding to the component object;

the third determining module 58 is configured to determine a loading engine for loading the second code, and parse the second instruction input by the software, i.e. the tenant of the service platform, through the loading engine to render the front end page of the software, i.e. the service platform.

Note that each module in fig. 5 may be a program module (for example, a set of program instructions for implementing a specific function), or may be a hardware module, and for the latter, it may be represented by the following form, but is not limited thereto: the expression forms of the modules are all a processor, or the functions of the modules are realized by one processor.

It should be noted that, the preferred implementation manner of the embodiment shown in fig. 5 may refer to the related description of the embodiment shown in fig. 1, which is not repeated herein.

Fig. 6 shows a hardware block diagram of a computer terminal (or mobile device) for implementing a development method of a software-as-a-service platform. As shown in fig. 6, the computer terminal 60 (or mobile device 60) may include one or more processors 602 (shown in the figures as 602a, 602b, … …,602 n) (the processor 602 may include, but is not limited to, a microprocessor MCU, a programmable logic device FPGA, etc.) a memory 604 for storing data, and a transmission module 606 for communication functions. In addition, the method may further include: a display, an input/output interface (I/O interface), a Universal Serial BUS (USB) port (which may be included as one of the ports of the BUS), a network interface, a power supply, and/or a camera. It will be appreciated by those of ordinary skill in the art that the configuration shown in fig. 6 is merely illustrative and is not intended to limit the configuration of the electronic device described above. For example, the computer terminal 60 may also include more or fewer components than shown in FIG. 6, or have a different configuration than shown in FIG. 6.

It should be noted that the one or more processors 602 and/or other data processing circuits described above may be referred to herein generally as "data processing circuits. The data processing circuit may be embodied in whole or in part in software, hardware, firmware, or any other combination. Furthermore, the data processing circuitry may be a single stand-alone processing module, or incorporated, in whole or in part, into any of the other elements in the computer terminal 60 (or mobile device). As referred to in embodiments of the application, the data processing circuit acts as a processor control (e.g., selection of the path of the variable resistor termination connected to the interface).

The memory 604 may be used to store software programs and modules of application software, such as a program instruction/data storage device corresponding to a development method of a software-as-a-service platform in the embodiment of the present application, and the processor 602 executes the software programs and modules stored in the memory 604 to perform various functional applications and data processing, that is, implement the development method of the software-as-a-service platform. Memory 604 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid state memory. In some examples, memory 604 may further comprise memory located remotely from processor 602, which may be connected to computer terminal 60 via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The transmission module 606 is used to receive or transmit data via a network. The specific examples of the network described above may include a wireless network provided by a communication provider of the computer terminal 60. In one example, the transmission module 606 includes a network adapter (Network Interface Controller, NIC) that can connect to other network devices through a base station to communicate with the internet. In one example, the transmission module 606 may be a Radio Frequency (RF) module for communicating with the internet wirelessly.

The display may be, for example, a touch screen type Liquid Crystal Display (LCD) that may enable a user to interact with a user interface of the computer terminal 60 (or mobile device).

It should be noted here that, in some alternative embodiments, the computer device (or the electronic device) shown in fig. 6 may include hardware elements (including circuits), software elements (including computer code stored on a computer readable medium), or a combination of both hardware elements and software elements. It should be noted that fig. 6 is only one example of a specific example, and is intended to illustrate the types of components that may be present in the computer device (or electronic device) described above.

It should be noted that, the electronic device shown in fig. 6 is used for executing the development method of the software, i.e. the service platform, shown in fig. 1, so the explanation of the execution method of the command is also applicable to the electronic device, and will not be repeated here.

The embodiment of the application also provides a nonvolatile storage medium, which comprises a stored program, wherein the program controls equipment where the storage medium is located to execute the development method of the software serving as a service platform when running.

The nonvolatile storage medium executes a program of the following functions: analyzing first metadata for describing the business object to obtain first information, and analyzing second metadata for describing the view object to obtain second information; determining an object code template corresponding to the business object in a preset code template library, and determining a first code corresponding to first information through the object code template; converting the first code into an executable program, and processing the first instruction input by software, namely a service platform tenant, through the executable program; generating a component object corresponding to the second information through presetting a low code development frame, and determining a second code corresponding to the component object; determining a loading engine for loading the second code, and analyzing a second instruction input by the software serving as a tenant of the service platform through the loading engine to render a front-end page of the software serving as the service platform.

The embodiment of the application also provides electronic equipment, which comprises: the system comprises a memory and a processor, wherein the processor is used for running a program stored in the memory, and the program runs to execute the software, namely the development method of the service platform.

The processor is configured to execute a program that performs the following functions: analyzing first metadata for describing the business object to obtain first information, and analyzing second metadata for describing the view object to obtain second information; determining an object code template corresponding to the business object in a preset code template library, and determining a first code corresponding to first information through the object code template; converting the first code into an executable program, and processing the first instruction input by software, namely a service platform tenant, through the executable program; generating a component object corresponding to the second information through presetting a low code development frame, and determining a second code corresponding to the component object; determining a loading engine for loading the second code, and analyzing a second instruction input by the software serving as a tenant of the service platform through the loading engine to render a front-end page of the software serving as the service platform.

The foregoing embodiment numbers of the present application are merely for the purpose of description, and do not represent the advantages or disadvantages of the embodiments.

In the foregoing embodiments of the present application, the descriptions of the embodiments are emphasized, and for a portion of this disclosure that is not described in detail in this embodiment, reference is made to the related descriptions of other embodiments.

In the several embodiments provided in the present application, it should be understood that the disclosed technology may be implemented in other manners. The above-described embodiments of the apparatus are merely exemplary, and the division of the units, for example, may be a logic function division, and may be implemented in another manner, for example, a plurality of units or components may be combined or may be integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be through some interfaces, units or modules, or may be in electrical or other forms.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional unit in the embodiments of the present application may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.

The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application may be embodied in essence or a part contributing to the related art or all or part of the technical solution, in the form of a software product stored in a storage medium, including several instructions for causing a computer device (which may be a personal computer, a server or a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a removable hard disk, a magnetic disk, or an optical disk, or other various media capable of storing program codes.

The foregoing is merely a preferred embodiment of the present application and it should be noted that modifications and adaptations to those skilled in the art may be made without departing from the principles of the present application, which are intended to be comprehended within the scope of the present application.

Claims (10)

1. A method for developing a software-as-a-service platform, comprising:

analyzing first metadata for describing the business object to obtain first information, and analyzing second metadata for describing the view object to obtain second information;

determining an object code template corresponding to the business object in a preset code template library, and determining a first code corresponding to the first information through the object code template;

converting the first code into an executable program, and processing the first instruction input by software, namely a service platform tenant, through the executable program;

generating a component object corresponding to the second information through a preset low-code development framework, and determining a second code corresponding to the component object;

determining a loading engine for loading the second code, and analyzing a second instruction input by the software serving as a tenant of the service platform through the loading engine so as to render a front-end page of the software serving as the service platform.

2. The method of claim 1, wherein the first metadata comprises at least one of: behavior information, entity information, attribute remote information, attribute persistence information, attribute extension information, field name information, field type information, field source information, field business rule information, field encryption rule information, and field authority information.

3. The method of claim 2, wherein parsing the first metadata describing the business object to obtain the first information comprises:

analyzing the entity information, the behavior information, the attribute remote information, the attribute persistence information and the attribute expansion information in the first metadata to respectively obtain class information, interface information, entity field information, service call information, database information and service logic information corresponding to the service object.

4. The method of claim 1, wherein parsing, by the load engine, the second instruction entered by the software as a service platform tenant to render the front-end page of the software as a service platform, comprises:

acquiring a first view object to be bound in the second instruction;

Calling a first business object corresponding to the first view object through a preset interface in the loading engine, and filling the first view object to obtain a second view object;

determining a first component object corresponding to the second view object according to a target field in the second instruction;

typesetting the first component object according to the configuration information in the second instruction to obtain a second component object;

rendering the second component object.

5. The method of claim 1, wherein generating the component object corresponding to the second information by presetting a low code development framework comprises:

determining a basic component object according to a design specification corresponding to the preset low-code development framework, wherein the basic component object at least comprises: text box, drop-down box, single selection component, multiple selection component, data chart component;

and assembling the basic component objects according to the logical relation of the basic component objects in the second information to generate the component objects.

6. The method of claim 1, wherein the second information comprises at least one of: front-end component information, data container information, interface call information, page field information, custom code segment information and page document object model structure information, wherein the page document object model structure information is used for integrating the front-end component information, the data container information, the interface call information, the page field information and the custom code segment information.

7. The method of claim 1, wherein the loading engine is further configured to run on a different terminal device that interacts with the software-as-a-service platform via an interpreter.

8. A development device for a software-as-a-service platform, comprising:

the analysis module is used for analyzing the first metadata used for describing the business object to obtain first information, and analyzing the second metadata used for describing the view object to obtain second information;

the first determining module is used for determining an object code template corresponding to the business object in a preset code template library, and determining a first code corresponding to the first information through the object code template;

the conversion module is used for converting the first code into an executable program, and processing the first instruction input by software, namely a service platform tenant, through the executable program;

the second determining module is used for generating a component object corresponding to the second information through presetting a low code development framework and determining a second code corresponding to the component object;

and the third determining module is used for determining a loading engine for loading the second code, and analyzing a second instruction input by the software serving as a tenant of the service platform through the loading engine so as to render the front-end page of the software serving as the service platform.

9. A non-volatile storage medium, characterized in that the non-volatile storage medium comprises a stored program, wherein the program, when run, controls a device in which the non-volatile storage medium is located to execute the method for developing a software-as-a-service platform according to any one of claims 1 to 7.

10. An electronic device, comprising: a memory and a processor for executing a program stored in the memory, wherein the program is executed when executing the method of developing a software-as-a-service platform according to any one of claims 1 to 7.