CN115016784B

CN115016784B - Low code application multiplexing method, application analysis system, equipment and storage medium

Info

Publication number: CN115016784B
Application number: CN202210941276.4A
Authority: CN
Inventors: 朱羽; 艾润; 贺光忠
Original assignee: Yudongyuan Beijing Information Technology Co ltd
Current assignee: Yudongyuan Beijing Information Technology Co ltd
Priority date: 2022-08-08
Filing date: 2022-08-08
Publication date: 2022-11-01
Anticipated expiration: 2042-08-08
Also published as: CN115016784A

Abstract

The invention provides a low-code application multiplexing method, an application analysis system, equipment and a storage medium, which are used for obtaining descriptive information of a target low-code application, creating a tree structure based on container connection information in the descriptive information, determining a model component and a container corresponding to each tree node in the tree structure, generating a syntax tree corresponding to the target low-code application, creating a component program entity of the model component corresponding to each tree node based on the syntax tree, and sequentially executing an operation method of each component program entity based on the connection relation of each component program entity.

Description

Low code application multiplexing method, application analysis system, equipment and storage medium

Technical Field

The invention relates to the technical field of computer software information, in particular to a low-code application multiplexing method, an application analysis system, low-code application multiplexing equipment and a storage medium.

Background

The low-code development platform is a development platform which can quickly generate an application program without codes or by a small amount of codes, and a method for developing the application program through visualization enables developers with different experience levels to create a webpage and move the application program through a graphical user interface by using a dragging component and model-driven logic. The main advantage is to allow the end-user to develop own applications, build business processes, logic and data models, etc. using easy-to-understand visualization tools, and add own code if necessary.

At present, no uniform application description standard is formed in the development process of low-code applications, the connection between model components used in the applications adopts a hard connection mode, and the system migration mode on the same low-code development platform also adopts the traditional data migration mode, the reinstallation and deployment of application programs, the parameter configuration and other operations, so that the efficiency is low, the operation is complex, the sharing and the interoperation of application development results can not be realized among different low-code development platforms, the reusability and the production efficiency of business applications are reduced, and the compatibility and the cross-platform migration of the low-code model development are not facilitated.

Disclosure of Invention

One of the objectives of the present invention is to provide a low code application multiplexing method, an application parsing system, a device and a storage medium, which are used to improve reusability and production efficiency of business applications and achieve the effect of cross-platform migration of low code models.

In a first aspect, the present invention provides a method for multiplexing low-code applications, the method comprising: acquiring descriptive information of a target low-code application, and standardizing the descriptive information; the descriptive information at least comprises information used for constructing a model component of the target low-code application, container information for running the model component and container connection information; creating a tree structure according to the container connection information, and generating a syntax tree corresponding to the target low-code application based on the model component and the container corresponding to each tree node in the tree structure; creating a component program entity of the model component corresponding to each tree node based on the syntax tree; and sequentially executing the operation method corresponding to each component program entity based on the connection relation of each component program entity.

In a second aspect, the present invention provides an application parsing system, including: the adapter is used for acquiring descriptive information of a target low-code application and standardizing the descriptive information; the descriptive information at least comprises information used for constructing a model component of the target low-code application, container information for running the model component and container connection information; the parser is used for creating a tree structure according to the container connection information and generating a syntax tree corresponding to the target low-code application based on the model component and the container corresponding to each tree node in the tree structure; a converter for creating a component program entity of the model component corresponding to each of the tree nodes based on the syntax tree; and the executor is used for sequentially executing the operation method corresponding to each component program entity based on the connection relation of each component program entity.

In a third aspect, an embodiment of the present invention provides an apparatus, including: a memory for storing executable instructions; a processor, configured to implement the low-code application multiplexing method of the first aspect when executing the executable instructions stored in the memory.

In a fourth aspect, the present invention provides a storage medium storing executable instructions for implementing the low-code application multiplexing method of the first aspect when executed by a processor.

The low-code application multiplexing method, the application analysis system, the equipment and the storage medium provided by the invention firstly obtain the descriptive information of the target low-code application, then create a tree structure according to the container connection information, and generate a syntax tree corresponding to the target low-code application based on the model component and the container corresponding to each tree node in the tree structure; the method comprises the steps of establishing a component program entity of the model component corresponding to each tree node based on the syntax tree, and finally sequentially executing an operation method corresponding to each component program entity based on the connection relation of each component program entity.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings needed to be used in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present invention and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained according to the drawings without inventive efforts.

Fig. 1 is a scene diagram of a low code application multiplexing method according to an embodiment of the present invention;

FIG. 2 is a schematic flow chart of a low-code application multiplexing method provided by an embodiment of the invention;

FIG. 3 is a diagram illustrating an example of development of a low-code application according to an embodiment of the present invention;

FIG. 4 is a diagram illustrating a process for developing a low-code application by a low-code platform according to an embodiment of the present invention;

fig. 5 is a schematic diagram of low-code application migration of a homogeneous platform according to an embodiment of the present invention;

fig. 6 is a schematic diagram illustrating low-code application migration of a heterogeneous platform according to an embodiment of the present invention;

FIG. 7 is a schematic flow chart of step S202 provided by the embodiment of the present invention;

fig. 8 is a schematic flowchart of step S203 provided by the embodiment of the present invention;

fig. 9 is a schematic flowchart of step S204 provided by the embodiment of the present invention;

FIG. 10 is a functional block diagram of an application parsing system according to an embodiment of the present invention;

fig. 11 is a block diagram of a device according to an embodiment of the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention. The components of embodiments of the present invention generally described and illustrated in the figures herein may be arranged and designed in a wide variety of different configurations.

Thus, the following detailed description of the embodiments of the present invention, presented in the figures, is not intended to limit the scope of the invention, as claimed, but is merely representative of selected embodiments of the invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, it need not be further defined and explained in subsequent figures.

In the description of the present invention, it should be noted that if the terms "upper", "lower", "inside", "outside", etc. indicate an orientation or a positional relationship based on that shown in the drawings or that the product of the present invention is used as it is, this is only for convenience of description and simplification of the description, and it does not indicate or imply that the device or the element referred to must have a specific orientation, be constructed in a specific orientation, and be operated, and thus should not be construed as limiting the present invention.

Furthermore, the appearances of the terms "first," "second," and the like, if any, are used solely to distinguish one from another and are not to be construed as indicating or implying relative importance.

It should be noted that the features of the embodiments of the present invention may be combined with each other without conflict.

The low-code development scheme is that a scheme which can be originally precipitated by codes, such as components, templates and modules, is precipitated on a product in a visual mode, the modules are assembled in modes of dragging, configuring and the like, after business logic and function construction is completed, application can be delivered and updated in a one-key mode, all changing and data processing scripts and deployment processes are automatically tracked, and deployment on multiple platforms such as iOS, andriod, web and the like can be achieved.

At present, because the connection between the model components used in the application adopts a hard connection mode, and a system migration mode on the same low-code development platform also adopts the traditional data migration mode, the reinstallation and deployment of application programs, the parameter configuration and other operations, the efficiency is low, the operation is complex, and the sharing and the interoperation of application development results cannot be realized among different low-code development platforms, so that the reusability and the production efficiency of business application are reduced.

In order to solve the above problems, an embodiment of the present invention provides a low-code application multiplexing method, which formulates a series of model components, component description specifications, component dependency specifications, and component connection specifications to form a description specification of a low-code service application, and develops an analysis software system of the specification to ensure that any low-code development platform can understand the low-code service application, so that migration and interoperation of different low-code platforms are possible, thereby greatly improving reusability of the service application and improving production efficiency.

Fig. 1 is a scene diagram of a low-code application multiplexing method according to an embodiment of the present invention, and as shown in fig. 1, the application scene may include

terminal devices

101, 102, 103, a network 104, and a server 105. The network 104 serves as a medium for providing communication links between the

terminal devices

101, 102, 103 and the server 105. Network 104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few.

The user may use the

terminal devices

101, 102, 103 to interact with the server 105 via the network 104 to receive or send messages or the like. The

terminal devices

101, 102, 103 may have various low-code installed thereon, such as a shopping-like application, a web browser application, a search-like application, an instant messaging tool, a mailbox client, social platform software, etc. (by way of example only).

The

terminal devices

101, 102, 103 may be various devices having a display screen and supporting web browsing, including but not limited to smart phones, tablet computers, laptop portable computers, desktop computers, and the like.

The server 105 may be a server providing various services, such as a background management server (for example only) providing support for websites browsed by users using the

terminal devices

101, 102, 103, a low-code platform providing support for development of low-code applications, or an application parsing system providing multiplexing of low-code applications. The background management server may analyze and perform other processing on the received data such as the user request, and feed back a processing result (e.g., a webpage, information, or data obtained or generated according to the user request) to the terminal device.

It should be noted that the low-code application multiplexing method provided by the embodiment of the present invention may be generally executed by the server 105. Accordingly, the application parsing system 300 provided by the embodiment of the present invention can be generally disposed in the server 105. The low-code application multiplexing method provided by the embodiment of the present invention may also be executed by a server or a server cluster that is different from the server 105 and is capable of communicating with the

terminal devices

101, 102, 103 and/or the server 105. Accordingly, the parsing system 300 provided by the embodiment of the present invention may also be disposed in a server or a server cluster that is different from the server 105 and is capable of communicating with the

terminal devices

101, 102, 103 and/or the server 105.

It should be understood that the number of terminal devices, networks, and servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for an implementation.

The low code application multiplexing method of the disclosed embodiment will be described in detail below through fig. 2 to 9 based on the scenario described in fig. 1.

Referring to fig. 2, fig. 2 is a schematic flowchart of a low-code application multiplexing method according to an embodiment of the present invention, where an execution subject of the method may be the server in fig. 1, where the server has a low-code platform, the low-code platform may be a target migration platform for a low-code application to be migrated, the target migration platform may be the same as or different from a source low-code platform, and the source low-code platform is a platform for developing a low-code application to be migrated, where the method may include:

s201, obtaining descriptive information of target low-code application, and standardizing the descriptive information; the descriptive information at least comprises information for constructing a model component of the target low-code application, container information for operating the model component and container connection information;

s202, creating a tree structure according to the container connection information, determining a model component and a container corresponding to each tree node in the tree structure, and generating a syntax tree corresponding to target low-code application;

s203, creating a component program entity of the model component corresponding to each tree node based on the syntax tree;

and S204, sequentially executing the operation method corresponding to each component program entity based on the connection relation of each component program entity.

According to the low-code application multiplexing method provided by the embodiment of the invention, firstly, descriptive information of a target low-code application is obtained, a tree structure is created based on container connection information in the descriptive information, a model component and a container corresponding to each tree node in the tree structure are determined, a syntax tree corresponding to the target low-code application is generated, a component program entity of the model component corresponding to each tree node is created based on the syntax tree, and execution logic of each component program entity is sequentially called to operate based on the connection relation of each component program entity.

The above steps S201 to S204 will be described in detail with reference to the accompanying drawings.

In step 201, descriptive information of the target low-code application is obtained and normalized.

In the embodiment of the invention, the target low-code application refers to any low-code application developed through a low-code platform, the data format of the descriptive information can be JSON or XML, the descriptive information is stored through a specification file, and the specification file can be imported to low-code platforms provided by different service providers, so that cross-platform transplantation of the low-code application is realized.

For convenience of understanding descriptive information in the implementation of the present invention, please refer to fig. 3, where fig. 3 is a diagram illustrating a development example of a low-code application according to an embodiment of the present invention, where the descriptive information of a low-code application may include the following information: information of a model component for constructing the target low-code application, container information for running the model component, and container connection information, resource information, and metadata information, which are described in detail below:

1. metadata information: the metadata information is used to describe some basic data of the low-code application, and may include the following information: the unique identification number (id) of the container, the name (name) of the node, the id (module _ id) of the model component corresponding to the container, the id (app _ id) of the low-code application, the name (platform _ name) of the low-code platform for developing the low-code application, the global variables (global _ vars), the version number (version) of the low-code application, and the creation time (create _ time).

2. Information of model component (module): the model component is an abstraction in function based on a plurality of existing low-code application software, such as universal data integration exchange and bus service protocol, the model component acts on resources to realize certain service functions, and can transmit data between different components in a specific data protocol format, and the information of the model component (module) includes the following steps:

id (id): a unique identification number (id) defining the component; the name of the model component; a short description text (description) of the component function; type (type) corresponding to the function of the component in the development of the low-code model; a flow control component (e.g., predicate/branch/loop) (control); a functional component having a certain specific business function (function); other services (require) that must be started by the component; the data protocol received by the component, the protocol rule and the data protocol ((input _ data _ protocol); the data protocol output by the component, the protocol rule and the data protocol (output _ data _ protocol); the data type (type), i.e. binary (binary): binary data, without fixed format, data frame (dataframe): data structure of two-dimensional table, json:datastructure of json:custom (custom): custom data type, internal use, unit, i.e. row (row): data is transferred one row at a time, block (block): data is transferred one block at a time, the data splitting logic depends on the component internal implementation, format, i.e. separator (split): separator between defined data fields, linefeed (linefeed): linefeed character defining data.

3. Container information: the container is used for running a low-code model component, the model defines business functions and a transmitted data protocol, the container is responsible for parameters, environment, configuration and running of the running, and the information of the container can comprise the following information: a unique identification number (id) of the container; the name is as follows: the name (name) of the container; the model component id (module _ id) corresponding to the container; id (resource _ id) of the resource file corresponding to the component; the runtime variables (variables) that the container uses.

4. Container connection information: the mutual connection between the containers is an abstraction of the order, direction and data transfer of the containers in the component coordination processing and task arrangement, and is used for identifying the upstream and downstream relationship and data transfer direction between the containers. The container connection information includes the following information: origin (from): defining the starting end of the connection, namely a container id; target (to): defining a terminating end of the connection, container id; the connection transmits data in a manner of no (none): the data transmitted to the source container is transmitted to the target (balance) in a load balancing mode without transferring the data, and the data transmitted to the source container is transmitted to the target (replication) in a full replication mode.

5. Resource information: resources are an abstraction of object objects that are acted upon by low-code model components, such as: files, data, tables, etc., and resource information includes the following: a unique identification number (id) of the resource; a name (name) of the resource; a uniform resource locator (url) of the resource; authentication information (authentication) required to access the resource.

The embodiment of the present invention provides a possible implementation manner to generate the above descriptive information, including the following steps a1 to a4:

and a1, responding to the initialization operation aiming at the low-code platform, and generating metadata information corresponding to the target low-code application.

It can be understood that when an application designer creates descriptive information of a low-code application through a low-code application platform of a certain service provider, the system background first generates an independent thread to maintain all data and operations on the data of the descriptive information of the whole low-code application, and initializes metadata information in the low-code application system: low code application ID, system platform name, global variable set, version, creation time, creation author, etc.

and a2, displaying an editing page of the target low-code application on the low-code platform.

It will be appreciated that the above-described editing page may be in an editable state similar to the page shown in FIG. 3, a model component on the page, or the like.

a3, respectively responding to the editing operation on the model component, the resource and the container on the editing page, and respectively generating the information of the model component, the resource information, the information of the container and the container connection information of the target low-code application;

and a4, generating descriptive information based on the metadata information, the information of the model component, the resource information, the information of the container and the container connection information.

Referring to fig. 4, fig. 4 is a schematic diagram of a process for developing a low-code application by a low-code platform according to an embodiment of the present invention, that is, on an edit page, when a user inputs information of a container, a resource, a model component, and the like for developing a target low-code application, a background process generates each object according to a specification, and performs corresponding operations on the object, such as persistence, syntax check, container parameter check, resource check, and the like, to find out a container, or a resource, or a connection, which may violate a description specification. After the user finishes the design of the whole low-code application, the descriptive information of the low-code application is generated and is stored to a disk in the form of a specification file, and the thread is destroyed.

After the target low-code application is created, the generated specification file can be imported into other isomorphic platforms or heterogeneous platforms, and the low-code application can be redesigned or submitted to an engine to run the low-code application by analyzing the specification file.

It should be noted that the homogeneous platform and the low-code platform for developing the target low-code application belong to the same service provider, the homogeneous platform may be located in service equipment of other service providers, and the heterogeneous platform is different from the service provider for developing the low-code platform for developing the target low-code application, for example, please refer to fig. 5 and fig. 6, fig. 5 is a schematic diagram for transplanting the low-code application of the homogeneous platform according to the embodiment of the present invention, and fig. 6 is a schematic diagram for transplanting the low-code application of the heterogeneous platform according to the embodiment of the present invention.

Therefore, in a possible implementation, the above manner of acquiring the descriptive information may be: and responding to the user import operation to obtain the file corresponding to the descriptive information.

After obtaining the descriptive information of the target low-code application, the descriptive information needs to be standardized, and the following implementation of the present invention provides a standardized implementation:

b1, determining an adapter corresponding to the format of the descriptive information;

b2, calling an adapter, converting the format of the key name in the descriptive information into a preset key name format, and converting the format of the type field value in the descriptive information into a preset field format.

The preset key name format is an English lowercase format, and the preset field format is an enumeration type format. The adapter in the embodiment of the invention can process the specification files with different formats and convert the specification files into the standard specification files by mapping, and the specific conversion principle is as follows: all key names are represented by English lowercase, and the value of the type field is converted into an enumeration type.

For example, reading the specification file, judging that the file format of the specification file is xml, calling an xml specification adapter, and then sequentially converting the five types of information according to the conversion principle.

Firstly, obtaining metadata information of a source file, converting the metadata information into a corresponding json structure, then converting a key name into English lowercase by an adapter corresponding to a json format, converting a value of a type field into an enumeration type, and converting the converted metadata information into the following information:

{

"app_id": "bdd56aea-df5a-4e9b-872a-8ca42538bc51",

"platform _ name": a certain facilitator low code development platform ",

"global_vars": {

"site":https://www.xxxxxx.com

},

"version": "1.0.0",

"create_time": "1655277298",

"author": "xxxxxx"

}。

in the above, in each line of information, the colon represents the key name before the colon, and all represents in english lowercase, and the colon is followed by the type field, and all represents in enumerated type.

By analogy, model component information of a source file is obtained, the model component information is converted into a corresponding json structure, a key name is converted into English lowercase, and a value of a type field is converted into an enumeration type, wherein the enumeration type is as follows:

{

"id": "aaa51739-c881-4cae-98da-f84ea5f79082",

"name": data resource management ",

"description": data resource management-creation data table DDL ",

"type": "function",

"require": [],

"input_data_protocol": {},

"output_data_protocol": {

"type": "binary",

"unit": "block",

"format": {

"split": ",",

"linefeed": "\r\n"

}

}。

acquiring container information of a source file, converting the container information into a corresponding json structure, converting a key name into English lowercase, and converting a value of a type field into an enumeration type, wherein the structure is as follows:

{

"id": "node-1",

"name": data resource management-creation data table DDL ",

"resource_id":"resource-1",

"module_id": "module-1",

"variable": [{

"database": library name ",

the table name is used as the table name,

"fields":["name","age"]

}]

}。

acquiring container connection information of a source file, converting a source node into a corresponding json structure, converting a key name into English lowercase, and converting a value of a type field into an enumeration type, wherein the enumeration type comprises the following structures:

[{

"from": "node-1",

"to": "node-2",

"transform_type": "none"

},

{

"from": "node-2"，

"to": "node-3",

},

]。

acquiring resource information of a source file, converting the resource information into a corresponding json structure, converting a key name into English lowercase, converting a value of a type field into an enumeration type, and converting the enumeration type into the following structure:

{

"id": "resource-1",

"name": data table defines SQL ",

"uri": "192.168.1.1:/data/app.sql",

"authentication": {}

}。

it should be noted that the above structure is only an example of partial information, and is not a limitation on the information content.

After the descriptive information is standardized, step S202 may be performed.

In step S202, a tree structure is created according to the container connection information, and a syntax tree corresponding to the target low-code application is generated based on the model component and the container corresponding to each tree node in the tree structure.

In the embodiment of the present invention, the container connection information includes a container pair and a orphan container, where the containers in the container pair have a directed connection relationship, and may respectively create tree nodes corresponding to the containers in the orphan container and the container pair, and establish a directed connection relationship between the tree nodes corresponding to the containers in the container, establish a connection relationship between the tree nodes and the root nodes of the orphan container, and establish a connection relationship between the tree nodes and the root nodes of the container having a source value in the container pair, so as to generate a tree structure (which may also be understood as an abstract syntax tree) corresponding to a target low-code application, where each tree node in the virtual structure tree corresponds to an ID value, and based on the ID corresponding to each tree node, a container corresponding to the ID of the tree node is searched in the container information, the value of the tree node is converted into a value of the container, and then a model component corresponding to the container is searched in the information of the model component, and the value of the tree node is converted into a value of the found model component and the container, so as to generate the syntax tree, it can be understood that the syntax tree is used for representing an abstract low-code application that a target low-code application that does not execute a logical plan.

Therefore, in a possible implementation manner, please refer to fig. 7, fig. 7 provides a schematic flowchart of step S202 for an embodiment of the present invention, and step S202 may include:

s202-1, a root node of the tree structure is created.

In embodiments of the invention, a root node is created, the root node has no value, and the pointer of the root node will point to the starting tree node in the join.

S202-2, determining a container pair and a single container from the container connection information;

each container pair having a source container and a target container; the value of the source container is source (from), the value of the target container is target (to), the data structure of the container connection information is a list, and a single node has no value, for example, the container connection information may be expressed as:

{

"from": "node-1",

"to": "node-2",

"transform_type": "none"

}。

then, node-1 is the source container, node-2 is the destination container, and node-1 and node-2 can be regarded as a container pair.

The source container and the target container have a directed connection relationship, that is, the source container points to the target container connection, a single container has no directed connection relationship, and the value of the single container may be the source (from) or the target (to).

S202-3, creating tree nodes corresponding to the single container, the source container and the target container respectively, and establishing a connection relation of the tree nodes corresponding to the source container and the target container respectively, a connection relation of the tree nodes corresponding to the single container and the root node, and a connection relation of the root node and the tree nodes corresponding to the source container to obtain a tree structure.

That is, a tree node is created based on the id of the node value "from", if the tree node has no node pointing, the root node points to the node, and a tree node is created based on the id of the node value "to", and a tree node of the node value "from" is pointed to the node.

S202-4, determining the container corresponding to each tree node and the ID of the model component from the container information according to the ID of each tree node, and determining the model component corresponding to each tree node from the information of the model component according to the ID of the model component.

S202-5, converting each tree node value into respective values of the model component and the container corresponding to the tree node, and generating the syntax tree.

In the embodiment of the present invention, the generated syntax tree is abstract and cannot be executed, so that the syntax tree needs to be converted into an executable component entity, and the component entity is executed to complete the service function of the target low-code application, thereby implementing migration and multiplexing of the target low-code application.

In step S203, based on the syntax tree, a component program entity of the model component corresponding to each tree node is created.

In the embodiment of the present invention, a syntax tree is traversed, based on a model component corresponding to each tree node, a corresponding converter is called to obtain an attribute value, a construction logic, and a preset parameter of the tree node, and the tree node is converted into a component program entity, so that an embodiment of the present invention provides a possible implementation manner, please refer to fig. 8, where fig. 8 is a schematic flowchart of step S203 provided in the embodiment of the present invention, and step S203 includes:

s203-1, determining a component converter corresponding to the model component according to the model component and the container corresponding to each tree node.

S203-2, calling a component converter corresponding to each tree node, acquiring attribute values of the tree nodes through the component converters, and calling a preset construction logic;

for example, a tree node corresponding to a model component free web page component calls fwpcoverter and converts to a corresponding component program entity such as FWPModule described above.

S203-3, converting each tree node into a component program entity based on the attribute values, the preset construction logic and the preset parameters.

In embodiments of the present invention, the component program entities represent executable program models, and the syntax trees formed by the concatenation of the component program entities can be executed to implement the business functions of the target low-code application. Build logic refers to the method of building a component program entity.

In step S204, based on the connection relationship of each component program entity, the operation method corresponding to each component program entity is sequentially executed.

In the embodiment of the present invention, each component program entity is an executable program model, and has a corresponding execution logic, and a syntax tree formed by connecting each component program entity can remove a root node of the syntax tree, convert the syntax tree into a directed acyclic graph, randomly determine a starting component program entity from the directed acyclic graph, and run the starting component program entity until each component program entity is executed, so that an application function of a target low-code application can be implemented.

In an alternative implementation manner, the step S204 may be executed according to fig. 9, where fig. 9 is a schematic flowchart of the step S204 provided in the embodiment of the present invention:

s204-1, removing the root node in the syntax tree.

S204-2, converting the connection relation of each component program entity into a directed acyclic graph;

s204-3, determining an initial component program entity from the directed acyclic graph, and executing an operation method of the initial component program entity;

the starting component program entity may be a component program entity corresponding to any tree node without a parent node in the syntax tree.

S204-4, traversing all the component program entities until each component program entity is executed.

In the embodiment of the invention, the whole directed acyclic graph can be traversed by a breadth-first search algorithm.

Based on the same inventive concept, an application parsing system is further provided in an embodiment of the present invention, please refer to fig. 10, and fig. 10 is a functional block diagram of the application parsing system provided in an embodiment of the present invention, where the application parsing system may be stored in an Operating System (OS) of the device 400 in the form of software or firmware (firmware).

As shown in fig. 10, an application parsing system 300 provided in an embodiment of the present invention may include: adapter 310, resolver 320, converter 330 and actuator 340.

An adapter 310, configured to obtain descriptive information of a target low-code application and standardize the descriptive information; the descriptive information at least comprises information for constructing a model component of the target low-code application, container information for operating the model component and container connection information;

the parser 320 is used for creating a tree structure according to the container connection information, determining a model component and a container corresponding to each tree node in the tree structure, and generating a syntax tree corresponding to the target low-code application;

a converter 330 for creating a component program entity of the model component corresponding to each tree node based on the syntax tree;

and the executor 340 is configured to sequentially execute the operation method corresponding to each component program entity based on the connection relationship of each component program entity.

It is understood that the adaptor 310, the parser 320, the converter 330 and the executor 340 may cooperatively perform the steps in fig. 2 to achieve the corresponding technical effect.

In an alternative embodiment, the adapter 310 is specifically configured to determine an adapter corresponding to a format of the descriptive information; the format of the key name in the descriptive information is converted into a preset key name format, and the format of the type field value in the descriptive information is converted into a preset field format.

In an alternative embodiment, the parser 320 is specifically configured to create a root node of a virtual structure tree; determining a container pair and a single container from the container connection information; each container pair having a source container and a target container; the source container and the target container have a directional connection relation; the single container has no directed connection relation; creating tree nodes corresponding to the single container, the source container and the target container respectively, and establishing a connection relation of the tree nodes corresponding to the source container and the target container respectively, a connection relation of the tree nodes corresponding to the single container and the root node, and a connection relation of the root node and the tree nodes corresponding to the source container to obtain a tree structure; and determining the container corresponding to each tree node and the ID of the model component from the container information according to the ID of each tree node, and determining the model component corresponding to each tree node from the information of the model component according to the ID of the model component. And converting each tree node value into respective values of the model component and the container corresponding to the tree node, and generating the syntax tree.

In an alternative embodiment, the converter 330 is specifically configured to determine, according to the model component and the container corresponding to each tree node, a component converter corresponding to the model component; calling a component converter corresponding to each tree node, acquiring attribute values of the tree nodes through the component converters, and calling a preset construction logic; each tree node is converted to a component program entity based on the attribute values, the preset build logic, and the preset parameters.

In an alternative embodiment, the executor 340 is specifically configured to remove a root node in the syntax tree; converting the connection relation of each component program entity into a directed acyclic graph; determining an initial component program entity from the directed acyclic graph, and calling an execution logic of the initial component program entity to execute; all component program entities are traversed until each component program entity is executed.

In an alternative embodiment, the descriptive information for the target low-code application is generated by: generating metadata information corresponding to the target low-code application in response to an initialization operation for the low-code platform; displaying an edit page of a target low-code application on a low-code platform; respectively responding to the editing operation on the model component, the resource and the container on the editing page, and respectively generating the information of the model component, the resource information, the information of the container and the container connection information of the target low-code application; descriptive information is generated based on the metadata information, the information of the model component, the resource information, the information of the container, and the container connection information.

In an alternative embodiment, obtaining descriptive information for a target low-code application includes: and responding to the user import operation to obtain the file corresponding to the descriptive information.

An embodiment of the present invention further provides a device, where the device may be the terminal device in fig. 1 or a server, please refer to fig. 11, and fig. 11 is a block diagram of a structure of the device according to the embodiment of the present invention.

As shown in fig. 11, the device 400 includes a memory 401, a processor 402, and a communication interface 403, the memory 401, the processor 402, and the communication interface 403 being electrically connected to each other, directly or indirectly, to enable transmission or interaction of data. For example, the components may be electrically connected to each other via one or more communication buses or signal lines.

The memory 401 may be used for storing software programs and modules, such as instructions/modules of the application analysis system 300 provided by the embodiment of the present invention, and may be stored in the memory 401 in the form of software or firmware (firmware) or fixed in an Operating System (OS) of the device 400, and the processor 402 executes the software programs and modules stored in the memory 401, so as to perform various functional applications and data processing. The communication interface 403 may be used for communicating signaling or data with other node devices.

The Memory 401 may be, but is not limited to, a Random Access Memory (RAM), a Read Only Memory (ROM), a Programmable Read Only Memory (PROM), an Erasable Read Only Memory (EPROM), an electrically Erasable Read Only Memory (EEPROM), and the like.

The processor 402 may be an integrated circuit chip having signal processing capabilities. The processor 402 may be a general-purpose processor including a Central Processing Unit (CPU), a Network Processor (NP), and the like; but also Digital Signal Processors (DSPs), application Specific Integrated Circuits (ASICs), field Programmable Gate Arrays (FPGAs) or other Programmable logic devices, discrete Gate or transistor logic devices, discrete hardware components.

It will be appreciated that the configuration shown in FIG. 11 is merely illustrative and that the apparatus 400 may also include more or fewer components than shown in FIG. 11 or have a different configuration than shown in FIG. 11. The components shown in fig. 11 may be implemented in hardware, software, or a combination thereof.

Embodiments of the present invention further provide a readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the low-code application multiplexing method according to any one of the foregoing embodiments. The computer readable storage medium may be, but is not limited to, various media that can store program codes, such as a usb disk, a removable hard disk, a ROM, a RAM, a PROM, an EPROM, an EEPROM, a magnetic disk, or an optical disk.

The above description is only for the specific embodiments of the present invention, but the scope of the present invention is not limited thereto, and any changes or substitutions that can be easily conceived by those skilled in the art within the technical scope of the present invention are included in the scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.

Claims

1. A method for multiplexing applications, the method comprising:

acquiring descriptive information of a target low-code application, and standardizing the descriptive information; the descriptive information at least comprises information used for constructing a model component of the target low-code application, container information for running the model component and container connection information;

creating a tree structure according to the container connection information, and generating a syntax tree corresponding to the target low-code application based on the model component and the container corresponding to each tree node in the tree structure;

creating a component program entity of the model component corresponding to each tree node based on the syntax tree;

sequentially executing the operation method corresponding to each component program entity based on the connection relation of each component program entity;

obtaining descriptive information of a target low-code application and normalizing the descriptive information, including: determining an adapter corresponding to a format of the descriptive information; calling the adapter, converting the format of the key name in the descriptive information into a preset key name format, and converting the format of the type field value in the descriptive information into a preset field format;

creating a tree structure according to the container connection information, and generating a syntax tree corresponding to the target low-code application based on the model component and the container corresponding to each tree node in the tree structure, wherein the syntax tree comprises: creating a root node of the tree structure; determining a container pair and a single container from the container connection information; each of the container pairs having a source container and a target container; the source container and the target container have a directional connection relationship; the single container has no directed connection relation; creating tree nodes corresponding to the single container, the source container and the target container respectively, and establishing a connection relationship between the tree nodes corresponding to the source container and the target container, a connection relationship between the tree nodes corresponding to the single container and the root node, and a connection relationship between the root node and the tree nodes corresponding to the source container to obtain the tree structure; determining a container corresponding to each tree node and an ID of a model component from the container information according to the ID of each tree node pair, and determining a model component corresponding to each tree node from the information of the model component according to the ID of the model component; and converting the value of each tree node into the respective values of the model component and the container corresponding to the tree node, and generating the syntax tree.

2. The method of claim 1, wherein creating a component program entity of the model component corresponding to each of the tree nodes based on the syntax tree comprises:

determining a component converter corresponding to the model component according to the model component and the container corresponding to each tree node;

calling the component converter corresponding to each tree node, acquiring the attribute value of the tree node through the component converter, and calling a preset construction logic;

converting each of the tree nodes into the component program entity based on the attribute values, the preset build logic, and preset parameters.

3. The method according to claim 1, wherein the sequentially executing the operation method corresponding to each of the component program entities based on the connection relationship of each of the component program entities comprises:

removing a root node in the syntax tree;

converting the connection relation of each component program entity into a directed acyclic graph;

determining a starting component program entity from the directed acyclic graph, and calling an execution logic of the starting component program entity to execute;

all of the component program entities are traversed until each of the component program entities is executed.

4. The method of claim 1, wherein the descriptive information for the target low-code application is generated by:

generating metadata information corresponding to the target low-code application in response to an initialization operation for a low-code platform;

displaying an edit page of the target low-code application on the low-code platform;

respectively responding to the editing operation on the model component, the resource and the container on the editing page, and respectively generating the information of the model component, the resource information, the information of the container and the container connection information of the target low-code application;

generating the descriptive information based on the metadata information, the information of the model component, the resource information, the information of the container, and the container connection information.

5. The method of claim 1, wherein obtaining descriptive information of a target low-code application comprises:

and responding to the user import operation to obtain the file corresponding to the descriptive information.

6. An application parsing system, comprising:

the adapter is used for acquiring descriptive information of a target low-code application and standardizing the descriptive information; the descriptive information at least comprises information used for constructing a model component of the target low-code application, container information for running the model component and container connection information;

the parser is used for creating a tree structure according to the container connection information and generating a syntax tree corresponding to the target low-code application based on the model component and the container corresponding to each tree node in the tree structure;

a converter for creating a component program entity of the model component corresponding to each of the tree nodes based on the syntax tree;

the executor is used for sequentially executing the operation method corresponding to each component program entity based on the connection relation of each component program entity;

the adapter is specifically configured to: determining an adapter corresponding to a format of the descriptive information; calling the adapter, converting the format of the key name in the descriptive information into a preset key name format, and converting the format of the type field value in the descriptive information into a preset field format;

the resolver is specifically configured to: creating a tree structure according to the container connection information, and generating a syntax tree corresponding to the target low-code application based on the model component and the container corresponding to each tree node in the tree structure, wherein the syntax tree comprises: creating a root node of the tree structure; determining a container pair and a single container from the container connection information; each of the container pairs having a source container and a target container; the source container and the target container have a directional connection relationship; the single container has no directed connection relation; creating tree nodes corresponding to the single container, the source container and the target container respectively, and establishing a connection relationship between the tree nodes corresponding to the source container and the target container, a connection relationship between the tree nodes corresponding to the single container and the root node, and a connection relationship between the root node and the tree nodes corresponding to the source container to obtain the tree structure; determining a container corresponding to each tree node and an ID of a model component from the container information according to the ID of each tree node pair, and determining a model component corresponding to each tree node from the information of the model component according to the ID of the model component; and converting the value of each tree node into the respective values of the model component and the container corresponding to the tree node, and generating the syntax tree.

7. An electronic device, comprising:

a memory for storing executable instructions;

a processor for implementing the method of any one of claims 1 to 5 when executing executable instructions stored in the memory.

8. A storage medium storing executable instructions for performing the method of any one of claims 1 to 5 when executed by a processor.