CN113791779A

CN113791779A - Data processing method, device and system

Info

Publication number: CN113791779A
Application number: CN202110950286.XA
Authority: CN
Inventors: 单鹏涛
Original assignee: Wuba Co Ltd
Current assignee: Wuba Co Ltd
Priority date: 2021-08-18
Filing date: 2021-08-18
Publication date: 2021-12-14

Abstract

The invention provides a data processing method, device and system, and relates to the technical field of computers. The method comprises the following steps: converting the Flutter source code data corresponding to the interface to be generated into initial FairDSL data through Fair, wherein the Flutter source code data comprises: and writing the Flutter source code data corresponding to the target component in the interface to be generated into the Flutter source code data of the specific method function. And extracting FairDSL data of a component corresponding to the target component and interface FairDSL data corresponding to the specific method function from the initial FairDSL data. Adding component FairDSL data corresponding to a target component into the interface FairDSL data to generate target FairDSL data; and the client analyzes the target FairDSL data and generates an interface. The present application reduces code complexity in a particular method function.

Description

Data processing method, device and system

Technical Field

The present invention relates to the field of computer technologies, and in particular, to a data processing method, apparatus, and system.

Background

Flutter is a mobile User Interface (UI) framework that is an open source for Google (Google). It can support the rapid construction of high-quality native UI interfaces on various types of systems such as ios and Android (Android). However, Flutter does not support dynamization, that is, a UI interface constructed by Flutter cannot be changed once it is published. Therefore, Fair comes, and is an open source framework for UI and logic dynamic designed for the Flutter, so as to realize dynamic update of the UI interface constructed based on the Flutter framework. And the developer can write description information and/or logic information of the component in the interface to be updated by using the Flutter. The electronic equipment converts the source code data written by the Flutter into a farm-specific language (DSL) through the Fair. The client parses the Fair DSL to generate a new UI interface.

However, if the Fair DSL generated by Fair can generate a complete interface after parsing, it needs to ensure that all codes are written into the same specific method function (compiled build method function) when writing is performed by using Flutter. This makes the code in the specific method function complicated, resulting in poor readability and high maintenance cost of the code in the specific method function.

Disclosure of Invention

In view of this, the present application provides a data processing method, apparatus and system, which reduce the complexity of codes in a specific method function to a certain extent, improve the readability of codes in the specific method function, and reduce the maintenance cost of codes.

According to a first aspect of the present application, there is provided a data processing method, the method comprising:

converting the Flutter source code data corresponding to the interface to be generated into initial Fair-domain specific language DSL data through a Fair, wherein the Flutter source code data comprises: the method comprises the steps that first source code data and second source code data are included, wherein the first source code data are Flutter source code data corresponding to a target component in an interface to be generated, the second source code data are Flutter source code data written in a specific method function, and the second source code data comprise a calling statement of the first source code data;

extracting, from the initial Fair DSL data, component Fair DSL data corresponding to the target component and interface Fair domain specific language DSL data corresponding to the specific method function, where the interface Fair DSL data includes: a target component identifier corresponding to a target component in the interface to be generated;

adding component Fair DSL data corresponding to the target component into the interface Fair DSL data to generate target Fair DSL data;

and sending the target Fair DSL data to a client so that the client can analyze the target Fair DSL data and generate an interface.

According to a second aspect of the present application, there is provided a data processing method, the method comprising:

receiving target Fair DSL data of an interface to be generated, which is sent by a server, wherein the target Fair DSL data is generated by the server by adopting the data processing method of the first aspect;

parsing the target Fair DSL data to generate an interface.

According to a third aspect of the present application, there is provided a data processing apparatus comprising:

the generating module is used for converting Flutter source code data corresponding to an interface to be generated into initial Fair domain specific language DSL data through Fair, and the Flutter source code data comprises: the method comprises the steps that first source code data and second source code data are included, wherein the first source code data are Flutter source code data corresponding to a target component in an interface to be generated, the second source code data are Flutter source code data written in a specific method function, and the second source code data comprise a calling statement of the first source code data;

an extracting module, configured to extract, from the initial Fair DSL data, component Fair DSL data corresponding to the target component and interface Fair DSL data corresponding to the specific method function, where the interface Fair DSL data includes: a target component identification corresponding to the target component;

an adding module, configured to add, to the interface Fair DSL data, component Fair DSL data corresponding to the target component, and generate target Fair DSL data;

and the sending module is used for sending the target Fair DSL data to a client so that the client can analyze the target Fair DSL data and generate an interface.

According to a fourth aspect of the present application, there is provided a data processing apparatus comprising:

a receiving module, configured to receive target Fair DSL data of an interface to be generated, where the target Fair DSL data is generated by the server by using the data processing method according to any one of claims 1 to 6;

and the analysis module is used for analyzing the target Fair DSL data so as to generate an interface.

In a fifth aspect, the present application provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the steps of the data processing method according to any one of the first aspect or the second aspect.

In a sixth aspect, the present application provides an electronic device comprising: a processor, a memory and a computer program stored on the memory and executable on the processor, the processor implementing the steps of the data processing method according to any one of the first or second aspects when executing the program.

Aiming at the prior art, the method has the following advantages:

according to the data processing method provided by the embodiment of the application, the flute source code data corresponding to the interface to be generated is converted into the initial Fair-field specific language DSL data through the Fair. And extracting the Fair DSL data of the component corresponding to the target component and the interface Fair DSL data corresponding to the specific method function from the initial Fair DSL data. And adding the Fair DSL data of the component corresponding to the target component into the interface Fair DSL data to generate the target Fair DSL data. And sending the target Fair DSL data to the client so that the client can analyze the target Fair DSL data and generate an interface. In this technical scheme, Flutter source code data includes: the first source code data and the second source code data. The first source code data is the Flutter source code data corresponding to the target component in the interface to be generated. The second source code data is Flutter source code data written in a specific method function, and the second source code data includes a call statement for the first source code data. By calling the Fair DSL data of the component corresponding to the target component in the interface Fair DSL data, a complete interface can be generated by the Fair based on the independently packaged Flutter source code data corresponding to the target component and the Flutter source code data of the specific method function. Compared with the technology, all Flutter source code data corresponding to all interfaces to be generated and comprising all components of the interfaces do not need to be written into the specific method function, the complexity of codes in the specific method function is reduced, the readability of the codes in the specific method function is improved, and the maintenance cost is reduced.

Drawings

FIG. 1 is a block diagram of a data processing system according to an embodiment of the present disclosure;

fig. 2 is a flowchart of a data processing method provided in an embodiment of the present application;

fig. 3 is a flowchart of a data generation method provided in an embodiment of the present application;

fig. 4 is a schematic flowchart of a method dictionary and a DSL dictionary generation method according to an embodiment of the present application;

FIG. 5 is a flow chart of another data processing method provided by an embodiment of the present application;

fig. 6 is a flowchart of a target Fair DSL data parsing method according to an embodiment of the present application;

fig. 7 is a block diagram of a data processing apparatus according to an embodiment of the present application;

fig. 8 is a block diagram of a data processing apparatus according to an embodiment of the present application;

fig. 9 is a block diagram of an electronic device provided in an embodiment of the present application.

Detailed Description

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, not all, embodiments of the present 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.

Referring to fig. 1, a data processing system according to an embodiment of the present application is shown. As shown in fig. 1, the data processing system includes: a client 101 and a server 102. The client 101 and the server 102 are connected through a wired network or a wireless network. It should be noted that the implementation environment may include one or more clients, and fig. 1 illustrates an example in which the implementation environment includes only one client.

The service end 102 may be configured to generate target Fair DSL data of the interface to be generated. The generated target Fair DSL data is transmitted to the client 101. The target Fair DSL data may be a structure description file corresponding to the interface to be generated. The client 101 may receive the target Fair DSL data sent by the server 102. The target Fair DSL data is parsed to generate an interface, i.e., the generated interface is displayed at the client. Optionally, after receiving the target Fair DSL data sent by the server 102, the client 101 may store the target Fair DSL data of the interface to be generated. And in response to a user-triggered interface display instruction, acquiring the stored target Fair DSL data so as to display the interface. Alternatively, the client 101 may generate an interface display request in response to a user's display triggering operation for the page to be generated. And sending the interface display request to the server to receive target Fair DSL data corresponding to the interface to be generated, which is sent by the server in response to the interface display request, so as to display the interface. Alternatively, the client 101 may be installed in a terminal. The terminal can be a mobile phone, a tablet computer, a wearable device or the like. The server 102 may be a single server or a service cluster formed by a plurality of servers.

Please refer to fig. 2, which shows a flowchart of a data processing method according to an embodiment of the present application. The data processing method can be applied to the data processing system shown in fig. 1 and executed by a server in the data processing system shown in fig. 1. As shown in fig. 2, the data processing method may include:

step 201, converting the Flutter source code data corresponding to the interface to be generated into initial fairDSL data through fairs. The Flutter source code data includes: the source code generating method comprises first source code data and second source code data, wherein the first source code data are Flutter source code data corresponding to a target component in an interface to be generated, the second source code data are Flutter source code data written in a specific method function, and the second source code data comprise a calling statement of the first source code data.

In the embodiment of the application, the server side compiles the interface to be generated by using the Flutter and the Fair and compiles the interface by using a Flutter compiler to obtain initial Fair DSL data. The interface to be generated is a Flutter interface, that is, a UI interface constructed by Flutter. The data structure of the Flutter interface is a component (Widget) tree structure, that is, a tree data structure composed of a plurality of components. The basic construction element of the Flutter interface is a Widget, and each Widget may also include one or more widgets. And (4) obtaining the Widget tree forming the interface by layer-by-layer wrapping of the Widget.

Wherein the interface may include a plurality of UI components. There is a class of widgets that can be used to package UI components. The FairDSL data of the component corresponding to the Widget can be used for describing the structure of the UI component, so that the UI component can be drawn after the FairDSL data of the component is analyzed. Alternatively, the target component (target Widget) may refer to an independent component for encapsulating the UI component. The Flutter source code data corresponding to the independent component is not written into the specific method function.

In the embodiment of the application, the server side can convert Flutter source code data corresponding to the interface to be generated into initial Fair DSL data by using a Flutter compiler. In the process of converting the second source code data written in the specific method function, the first source code data is called through a calling statement aiming at the first source code data so as to convert the first source code data. The method and the device realize that the Flutter source code data corresponding to the interface to be generated are all converted into the initial Fair DSL data.

Step 202, extracting, from the initial Fair DSL data, component Fair DSL data corresponding to the target component and interface Fair DSL data corresponding to the specific method function, where the interface Fair DSL data includes: and identifying the target component corresponding to the target component.

In an alternative implementation manner, as shown in fig. 3, the process of extracting, by the service end, component Fair DSL data corresponding to the target component and interface Fair DSL data corresponding to the specific method function from the initial Fair DSL data may include:

step 301, the service end converts the initial Fair DSL data into abstract syntax tree data.

In this embodiment of the application, the server may perform Abstract Syntax Tree (AST) analysis on the initial Fair DSL data to obtain AST data corresponding to the initial Fair DSL data. AST is an abstract representation of the syntactic structure of source code data (also known as source code). It represents the syntactic structure of the programming language in the form of a tree, where each node on the tree represents a structure in the source code data.

Step 302, the server extracts the component data corresponding to the target component under the component label node in the AST, and generates the component Fair DSL data corresponding to the target component identifier based on the component data.

In the embodiment of the present application, a component tag node refers to a node for indicating a Flutter source code data corresponding structure describing a target component. The server may traverse each node in the AST data, and obtain component data corresponding to the target component under the component tag node by screening. In an alternative implementation, where the target component is for encapsulating a separate component of the UI component, the component tag node refers to a node for indicating a separate Flutter source code data structure.

Optionally, in the case that the object of the target component is a function, that is, the target component is an encapsulation function. The component identifier corresponding to the target component may be a function name (className). The component tag node may include: the node type is a node of a function declaration (function declaration), and/or the node type is a node of a method declaration (method declaration). For ease of illustration, the function declaration node is used to indicate a node whose node type is a function declaration. And adopting the method declaration node to indicate the node type as the node of the method declaration. The component tag node includes: function declarations nodes and/or method declarations nodes. It should be noted that, in the case that the component tag node is a method declaration type, the component identifier of the target component does not include the function name of the specific method function (built method function).

The process of extracting, by the server, component data corresponding to a target component below a component tag node in the AST may include: the server extracts component data (function data) corresponding to each function name under the function declaration node in the AST, and component data (function data) corresponding to each function name except the function name of the function name which is the specific method function in each function under the method declaration node.

In the embodiment of the application, the service end adopts a FairDSL standard format to convert the component data corresponding to the target component into the FairDSL data. Alternatively, the data format of the component Fair DSL data may be JSON. For example, the component FairDSL standard format may be:

"{" className ": target component identification",

"na" { component data } } "

If the target component indicated by the target component identifier exists in the component data (i.e., the nested dynamic component), the component Fair DSL standard format may be:

step 303, the server extracts target data except the component data corresponding to the target component in the AST, and generates interface Fair DSL data based on the target data.

In this embodiment, the server may traverse each node in the AST data, and obtain target data of each node except for component data corresponding to the target component by screening. And the service end adopts an interface Fair DSL standard format to convert the target data into interface Fair DSL data. The interface Fair DSL standard format may be set based on actual traffic requirements, among other things.

For example, as shown in fig. 4, the server generates initial Fair DSL data, and traverses nodes in the AST data corresponding to the initial Fair DSL data. Aiming at any node, the server side judges whether the node is a function declaration node or not. If the node is a function declaration node (function declaration), extracting each function name and component data corresponding to the function name under the function declaration node, and generating component Fair DSL data corresponding to each function name. If the node is not a function declaration node, determining whether the node is a method declaration node (MethodDeclaration). And if the node is not the method declaration node, extracting target data under the node to generate interface FairDSL data. If the node is a method declaration node, for component data under the method declaration node, whether a function name corresponding to the component data is a specific function name (built) of a specific method function is determined, that is, whether a function corresponding to the component data is the specific method function is determined. And if the function name is not the specific function name, extracting the function name and the component data corresponding to the function name, and generating the component Fair DSL data corresponding to the function name. And if the function name is the specific function name, extracting target data corresponding to the specific function name to generate interface Fair DSL data. Each function name and corresponding component Fair DSL data are written into a method dictionary (methodMap), and interface Fair DSL data are written into a DSL dictionary (Map).

In another alternative implementation, component Fair DSL data corresponding to the target component and interface Fair DSL data corresponding to the specific method function may be artificially extracted from the initial Fair DSL data.

Step 203, adding the assembly Fair DSL data corresponding to the target assembly to the interface Fair DSL data, and generating the target Fair DSL data.

Optionally, the implementation manner of adding, by the service end, the Fair DSL data of the component corresponding to the target component to the interface Fair DSL data to generate the target Fair DSL data is various, and three examples are described in this embodiment of the present application.

In a first optional implementation manner, the process of adding, by the service end, component Fair DSL data corresponding to the target component to the interface Fair DSL data may include: and the service end adds the first mapping data to the interface Fair DSL data to obtain the target Fair DSL data. The first mapping data includes: the target component identifies and associates stored component Fair DSL data corresponding to the target component.

The server may obtain, from storing each component Fair DSL data, component Fair DSL data stored in association with the target component identifier based on the target component identifier, and generate first mapping data. Optionally, the data format of the first mapping data may be a dictionary format. The first mapping data may be referred to as a method dictionary (methodMap). The first mapping data comprises a first key-value pair, a key field of the first key-value pair being used for storing a target component identification, and a value field being used for storing corresponding component Fair DSL data.

In a second optional implementation manner, the process of adding, by the service end, component FairDSL data corresponding to the target component to the interface FairDSL data may include: second mapping data is generated. The second mapping data includes: the method dictionary identifies and associates the stored first mapping data. And adding second mapping data to the interface Fair DSL data to obtain target Fair DSL data. Wherein the method dictionary identification is used to indicate a component FairDSL data support call in the first mapping data.

The server may generate the second mapping data after generating the first mapping data. The generation process of the first mapping data may refer to the generation process of the first mapping data in the foregoing second optional implementation manner. The embodiments of the present application are not described in detail again. Optionally, the data format of the second mapping data may be a dictionary format. The second mapping data comprises second key-value pairs, the key fields of the second key-value pairs are used for storing method dictionary identifications, and the value fields are used for storing corresponding first mapping data.

In a third optional implementation manner, the process of adding, by the service end, component Fair DSL data corresponding to the target component to the interface Fair DSL data may include: and the service end directly adds the Fair DSL data of the component corresponding to the target component into the interface Fair DSL data to obtain the target Fair DSL data.

The service end can extract the component Fair DSL data stored in association with the target component identification from the stored component Fair DSL data based on the target component identification. Therefore, the Fair DSL data of the component is added to the interface Fair DSL data, and the target Fair DSL data is obtained. The target Fair DSL data is used to fully describe the structure corresponding to the interface to be generated. It should be noted that, after the service end adds the component Fair DSL data to the interface Fair DSL data, the target component identifier originally included in the interface Fair DSL data may be deleted from the interface Fair DSL data. Therefore, repeated analysis and generation of the assembly Fair DSL data caused by the fact that the target Fair DSL data comprises the assembly Fair DSL data corresponding to the target assembly and the target assembly identification when the target Fair DSL data is analyzed subsequently are avoided. And the interface generation accuracy is guaranteed.

And step 204, sending the target Fair DSL data to the client so that the client can analyze the target Fair DSL data and generate an interface.

In this embodiment of the application, the service end may package the target Fair DSL data to a DSL dictionary (DSLMap), and send the DSL dictionary including the target Fair DSL data to the client at a set time. And after the client receives the DSL dictionary, the client analyzes the DSL dictionary to obtain the target Fair DSL data. And analyzing the target Fair DSL data and generating an interface. The set time can be an interface updating time triggered by a developer. For example, for an interface of an application program, the update time of the interface is the version update time of the application program. The server can add the target FairDSL data to the installation package corresponding to the application program, and send the target FairDSL data to the client. Therefore, when the client receives the triggering display operation of the user for the interface to be generated, the target Fair DSL data is obtained and analyzed to generate the interface. Or, the set timing may be a reception timing at which the server receives an interface display request for the interface to be generated. That is, the server may send the target Fair DSL data to the client after receiving the interface display request for the interface to be generated, which is sent by the client.

To sum up, in the data processing method provided in the embodiment of the present application, the router source code data corresponding to the interface to be generated is converted into DSL data in the specific language in the initial router domain by the router. And extracting the Fair DSL data of the component corresponding to the target component and the interface Fair DSL data corresponding to the specific method function from the initial Fair DSL data. And adding the Fair DSL data of the component corresponding to the target component into the interface Fair DSL data to generate the target Fair DSL data. And sending the target Fair DSL data to the client so that the client can analyze the target Fair DSL data and generate an interface. In this technical scheme, Flutter source code data includes: the first source code data and the second source code data. The first source code data is the Flutter source code data corresponding to the target component in the interface to be generated. The second source code data is Flutter source code data written in a specific method function, and the second source code data includes a call statement for the first source code data. By calling the Fair DSL data of the component corresponding to the target component in the interface Fair DSL data, a complete interface can be generated by the Fair based on the independently packaged Flutter source code data corresponding to the target component and the Flutter source code data of the specific method function. Compared with the technology, all Flutter source code data corresponding to all interfaces to be generated and comprising all components of the interfaces do not need to be written into the specific method function, the complexity of codes in the specific method function is reduced, the readability of the codes in the specific method function is improved, and the maintenance cost is reduced.

And, since it is not necessary to write all code to the same specific method function. Therefore, Flutter source code data corresponding to different components in the interface can be developed by different personnel. Finally, only interface Fair DSL data is called, code modular development is realized, the design thought of developers is more met, the interface design experience of the developers is improved, and the development efficiency is improved.

Referring to fig. 5, a flowchart of another data processing method provided in the embodiments of the present application is shown. The data processing method may be applied to the data processing system shown in fig. 1, executed by a client in the data processing system. As shown in fig. 5, the method includes:

and step 501, receiving target Fair DSL data of an interface to be generated, which is sent by a server.

In this embodiment of the present application, target FairDSL data is generated by a server using the data processing method provided in this embodiment of the present application. The service end can package the target Fair DSL data to a DSL dictionary (DSLMap), and send the DSL dictionary including the target Fair DSL data to the client at a set time. And after the client receives the DSL dictionary, the client analyzes the DSL dictionary to obtain the target Fair DSL data. And analyzing the target Fair DSL data and generating an interface. The set time can be an interface updating time triggered by a developer. For example, for an interface of an application program, the update time of the interface is the version update time of the application program. The server can add the target FairDSL data to the installation package corresponding to the application program, and send the target FairDSL data to the client. Therefore, when the client receives the triggering display operation of the user for the interface to be generated, the target Fair DSL data is obtained and analyzed to generate the interface. Or, the set timing may be a reception timing at which the server receives an interface display request for the interface to be generated. That is, the server may send the target Fair DSL data to the client after receiving the interface display request for the interface to be generated, which is sent by the client.

Step 502, parse the target Fair DSL data to generate an interface.

In the embodiment of the application, the client can respond to the triggering display operation of the user for the interface to be generated, and obtain the target Fair DSL data received by the client and sent by the server. The target Fair DSL data is parsed to generate an interface. The target Fair DSL data generation method is different, and the corresponding target Fair DSL data analysis method is also different. In the embodiments of the present application, the three implementation manners of generating the target Fair DSL data are described, where the target Fair DSL data is analyzed correspondingly.

A first alternative implementation. As shown in fig. 6, the target Fair DSL data includes first mapping data. The process of the client parsing the target Fair DSL data to generate the interface may comprise:

step 601, the client extracts first mapping data from the target Fair DSL data, and deletes the first mapping data from the target Fair DSL data to obtain interface Fair DSL data. Interface Fair DSL data includes: and the target component identification corresponding to the target component in the interface to be generated.

Optionally, the first mapping data may be added to the set location when added to the interface Fair DSL data. Such as the first or last bit. The client may extract the first mapping data from the set position in the target Fair DSL data, and delete the first mapping data from the target Fair DSL data to obtain the interface Fair DSL data. To avoid duplicate parsing of the target Fair DSL data corresponding to the target component.

Illustratively, the client stores a loader (dart), a decoder (dart), and a runner (builder.dart). And the client receives the DSL dictionary which comprises the target Fair DSL data and is sent by the server. The DSL dictionary may be loaded by a loader driver. And transmits the loaded DSL dictionary to the decoder. The decoder extracts a method dictionary (first mapping data) from the DSL dictionary and deletes the method dictionary from the DSL dictionary. And transmitting the extracted method dictionary and the DSL field after deleting the method dictionary to the operator. And the operator decodes the DSL dictionary, and interface Fair DSL data is obtained by recursion line by line.

Step 602, the client analyzes the interface Fair DSL data.

In the embodiment of the application, the interface Fair DSL data can be called line by line through a runtime mechanism of a code language Dart of Flutter to analyze the interface Fair DSL data.

Wherein the interface Fair DSL data includes a target component identification for the target component. When the interface Fair DSL data is called line by line, it may be determined whether the call object exists in the first mapping data, that is, whether the call object is the target component identifier.

If so, it indicates that the interface Fair DSL data does not include the specific Fair DSL data that needs to be invoked. The specific Fair DSL data is component Fair DSL data corresponding to the target component identifier in the first mapping data. And if not, indicating that the interface Fair DSL data comprises the specific Fair DSL data required to be called. Calling is continued on the interface Fair DSL data line by line.

Optionally, when the object of the target component is a function, the client may determine whether the called function name exists in a key domain of each key-value pair included in the first mapping data. If yes, go to step 603; if not, the interface Fair DSL data is continuously called line by line. In an alternative implementation, the client may use a function.application dynamic call method to make a line-by-line call on the interface Fair DSL data.

Step 603, when the component identifier obtained by parsing exists in the first mapping data, the client extracts the component Fair DSL data corresponding to the component identifier from the first mapping data, and parses the component Fair DSL data corresponding to the component identifier.

In this embodiment of the application, the client may call the target Fair DSL data corresponding to the target component extracted from the first mapping data line by line.

Step 604, the client uses a router engine to draw an interface based on the interface Fair DSL data and the analysis result of the component Fair DSL data corresponding to the component identifier existing in the first mapping data.

In the embodiment of the application, the client draws an interface based on the interface Fair DSL data and the call result of the component Fair DSL data corresponding to the component identifier existing in the first mapping data by using the Flutter engine. Thereby completing the resolution to rendering of the DSL dictionary, including the method dictionary.

A second alternative implementation. The target FairDSL data includes second mapping data. The process of the client parsing the target Fair DSL data to generate the interface is substantially the same as the generation process in the first alternative implementation. The difference is that the process of the client extracting the first mapping data from the target FairDSL data in step 601 includes: and extracting corresponding first mapping data from the target Fair DSL data based on the method dictionary identification in the second mapping data. Therefore, the method of mapping the method dictionary identification and the first mapping data to the target Fair DSL data is adopted, so that the client can conveniently extract the first mapping data from the target Fair DSL data based on the method dictionary identification, and the data extraction efficiency is improved.

In a third alternative implementation, the client may parse the target Fair DSL data directly to generate the interface. The step 602 may be referred to in the process of analyzing the target FairDSL data, which is not described in this embodiment of the present application.

To sum up, in the data processing method provided in the embodiment of the present application, the target Fair DSL data of the interface to be generated, which is sent by the server, is received and analyzed to obtain the target Fair DSL data, so as to generate the interface. The server side converts the Flutter source code data corresponding to the interface to be generated into initial Fair-field specific language DSL data through the Fair. And extracting the Fair DSL data of the component corresponding to the target component and the interface Fair DSL data corresponding to the specific method function from the initial Fair DSL data. And adding the Fair DSL data of the component corresponding to the target component into the interface Fair DSL data to generate the target Fair DSL data. In this technical scheme, Flutter source code data includes: the first source code data and the second source code data. The first source code data is the Flutter source code data corresponding to the target component in the interface to be generated. The second source code data is Flutter source code data written in a specific method function, and the second source code data includes a call statement for the first source code data. By calling the Fair DSL data of the component corresponding to the target component in the interface Fair DSL data, a complete interface can be generated by the Fair based on the independently packaged Flutter source code data corresponding to the target component and the Flutter source code data of the specific method function. Compared with the technology, all Flutter source code data corresponding to all interfaces to be generated and comprising all components of the interfaces do not need to be written into the specific method function, the complexity of codes in the specific method function is reduced, the readability of the codes in the specific method function is improved, and the maintenance cost is reduced.

In another data processing method provided in the embodiment of the present application, the data processing method may be applied to the data processing system shown in fig. 1. The method comprises the following steps:

step 701, the server side converts the Flutter source code data corresponding to the interface to be generated into initial Fair domain specific language DSL data through Fair. The Flutter source code data includes: the source code generating method comprises first source code data and second source code data, wherein the first source code data are Flutter source code data corresponding to a target component in an interface to be generated, the second source code data are Flutter source code data written in a specific method function, and the second source code data comprise a calling statement of the first source code data.

Step 702, the service end extracts the component Fair DSL data corresponding to the target component and the interface Fair DSL data corresponding to the specific method function from the initial Fair DSL data. Interface Fair DSL data includes: and identifying the target component corresponding to the target component.

Step 703, the service end adds the component Fair DSL data corresponding to the target component to the interface Fair DSL data, and generates target Fair DSL data.

Step 704, the server sends the target Fair DSL data to the client.

The explanation and implementation manners of steps 701 to 704 may refer to the explanation and implementation manners of steps 201 to 204 in sequence, which is not described in detail in this embodiment of the present invention.

Step 705, the client parses the target Fair DSL data to generate an interface.

The explanation and implementation of step 705 may refer to the explanation and implementation of step 502, which is not described in detail in this embodiment of the present invention.

Referring to fig. 7, a block diagram of a data processing apparatus according to an embodiment of the present application is shown. As shown in fig. 7, the data processing apparatus 800 includes: a generation module 801, an extraction module 802, an addition module 803, and a sending module 804.

A generating module 801, configured to convert Flutter source code data corresponding to an interface to be generated into initial Fair domain specific language DSL data by using a Fair, where the Flutter source code data includes: the method comprises the steps that first source code data and second source code data are included, wherein the first source code data are Flutter source code data corresponding to a target component in an interface to be generated, the second source code data are Flutter source code data written in a specific method function, and the second source code data comprise a calling statement of the first source code data;

an extracting module 802, configured to extract, from the initial Fair DSL data, component Fair DSL data corresponding to the target component and interface Fair DSL data corresponding to the specific method function, where the interface Fair DSL data includes: a target component identification corresponding to the target component;

an adding module 803, configured to add, to the interface Fair DSL data, component Fair DSL data corresponding to the target component, to generate target Fair DSL data;

a sending module 804, configured to send the target Fair DSL data to the client, so that the client parses the target Fair DSL data and generates an interface.

Optionally, the adding module 803 is further configured to:

adding first mapping data to the interface Fair DSL data to obtain target Fair DSL data, wherein the first mapping data comprises: the target component identifies and associates stored component Fair DSL data corresponding to the target component.

Optionally, the adding module 803 is further configured to:

generating second mapping data, the second mapping data comprising: a method dictionary identification and first mapping data stored in association, the method dictionary identification being used to indicate a Fair DSL data support call in the first mapping data;

and adding second mapping data to the interface Fair DSL data to obtain target Fair DSL data.

Optionally, the data format of the first mapping data and/or the second mapping data is a dictionary format.

Optionally, the extracting module 802 is further configured to:

converting the initial Fair DSL data to abstract syntax tree AST data;

extracting component data corresponding to a target component under a component label node in AST, and generating component Fair DSL data corresponding to a target component identifier based on the component data;

target data except component data corresponding to a target component under each node in AST is extracted, and interface Fair DSL data is generated based on the target data.

Optionally, the object of the target component is a function, and the component identifier of the target component is a function name; the types of component label nodes include: function declarations and/or device declarations; wherein, in case that the component label node is a device declaration type, the component identification of the target component does not include a function name of the specific device function.

To sum up, the data processing apparatus provided in the embodiment of the present application converts Flutter source code data corresponding to an interface to be generated into initial Fair domain specific language DSL data through Fair. And extracting the Fair DSL data of the component corresponding to the target component and the interface Fair DSL data corresponding to the specific method function from the initial Fair DSL data. And adding the Fair DSL data of the component corresponding to the target component into the interface Fair DSL data to generate the target Fair DSL data. And sending the target Fair DSL data to the client so that the client can analyze the target Fair DSL data and generate an interface. In this technical scheme, Flutter source code data includes: the first source code data and the second source code data. The first source code data is the Flutter source code data corresponding to the target component in the interface to be generated. The second source code data is Flutter source code data written in a specific method function, and the second source code data includes a call statement for the first source code data. By calling the Fair DSL data of the component corresponding to the target component in the interface Fair DSL data, a complete interface can be generated by the Fair based on the independently packaged Flutter source code data corresponding to the target component and the Flutter source code data of the specific method function. Compared with the technology, all Flutter source code data corresponding to all interfaces to be generated and comprising all components of the interfaces do not need to be written into the specific method function, the complexity of codes in the specific method function is reduced, the readability of the codes in the specific method function is improved, and the maintenance cost is reduced.

Referring to fig. 8, a block diagram of a data processing apparatus according to an embodiment of the present application is shown. As shown in fig. 8, the data processing apparatus 900 includes: a receiving module 901 and a parsing module 902.

A receiving module 901, configured to receive target Fair DSL data of an interface to be generated, where the target Fair DSL data is generated by a server by using any data processing method provided in the embodiment of the present application;

a parsing module 902 for parsing the target Fair DSL data to generate an interface.

Optionally, the parsing module 902 is further configured to:

extracting first mapping data from the target Fair DSL data, and deleting the first mapping data from the target Fair DSL data to obtain interface Fair DSL data, wherein the interface Fair DSL data comprises: a target component identifier corresponding to a target component in the interface to be generated;

analyzing interface Fair DSL data;

under the condition that the analyzed component identification exists in the first mapping data, extracting component Fair DSL data corresponding to the component identification from the first mapping data, and analyzing the component Fair DSL data corresponding to the component identification;

and drawing an interface by adopting a Flutter engine based on the interface Fair DSL data and the analysis result of the component Fair DSL data corresponding to the component identification.

Optionally, the parsing module 902 is further configured to: and extracting corresponding first mapping data from the target Fair DSL data based on the method dictionary identification in the second mapping relation.

To sum up, the data processing apparatus provided in the embodiment of the present application obtains the target Fair DSL data by receiving the target Fair DSL data of the interface to be generated, which is sent by the server, and analyzing the target Fair DSL data to generate the interface. The server side converts the Flutter source code data corresponding to the interface to be generated into initial Fair-field specific language DSL data through the Fair. And extracting the Fair DSL data of the component corresponding to the target component and the interface Fair DSL data corresponding to the specific method function from the initial Fair DSL data. And adding the Fair DSL data of the component corresponding to the target component into the interface Fair DSL data to generate the target Fair DSL data. In this technical scheme, Flutter source code data includes: the first source code data and the second source code data. The first source code data is the Flutter source code data corresponding to the target component in the interface to be generated. The second source code data is Flutter source code data written in a specific method function, and the second source code data includes a call statement for the first source code data. By calling the Fair DSL data of the component corresponding to the target component in the interface Fair DSL data, a complete interface can be generated by the Fair based on the independently packaged Flutter source code data corresponding to the target component and the Flutter source code data of the specific method function. Compared with the technology, all Flutter source code data corresponding to all interfaces to be generated and comprising all components of the interfaces do not need to be written into the specific method function, the complexity of codes in the specific method function is reduced, the readability of the codes in the specific method function is improved, and the maintenance cost is reduced.

The data processing device provided by the embodiment of the application is provided with a functional module corresponding to the data processing method, can execute any data processing method provided by the embodiment of the application, and can achieve the same beneficial effects.

In another embodiment provided by the present application, there is also provided an electronic device, which may include: the processor executes the program to realize the processes of the data processing method embodiment, and can achieve the same technical effects, and the details are not repeated here in order to avoid repetition.

For example, as shown in fig. 9, the electronic device may specifically include: a processor 1001, a storage device 1002, a display screen 1003 having a touch function, an input device 1004, an output device 1005, and a communication device 1006. The number of the processors 1001 in the electronic device may be one or more, and one processor 1001 is taken as an example in fig. 9. The processor 1001, the storage device 1002, the display 1003, the input device 1004, the output device 1005, and the communication device 1006 of the electronic apparatus may be connected by a bus or other means.

In yet another embodiment provided by the present application, a computer-readable storage medium is further provided, which has instructions stored therein, and when the instructions are executed on a computer, the instructions cause the computer to execute the data processing method described in any of the above embodiments.

In yet another embodiment provided by the present application, there is also provided a computer program product containing instructions which, when run on a computer, cause the computer to perform the data processing method of any of the above embodiments.

It is noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.

It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.

Through the above description of the embodiments, those skilled in the art will clearly understand that the method of the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but in many cases, the former is a better implementation manner. Based on such understanding, the technical solutions of the present invention may be embodied in the form of a software product, which is stored in a storage medium (such as ROM/RAM, magnetic disk, optical disk) and includes instructions for enabling a terminal (such as a mobile phone, a computer, a server, an air conditioner, or a network device) to execute the method according to the embodiments of the present invention.

While the present invention has been described with reference to the embodiments shown in the drawings, the present invention is not limited to the embodiments, which are illustrative and not restrictive, and it will be apparent to those skilled in the art that various changes and modifications can be made therein without departing from the spirit and scope of the invention as defined in the appended claims.

Those of ordinary skill in the art will appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.

It is clear to those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described systems, apparatuses and units may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

In the embodiments provided in the present application, it should be understood that the disclosed apparatus and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

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 network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit.

The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: various media capable of storing program codes, such as a U disk, a removable hard disk, a ROM, a RAM, 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 person skilled in the art can easily conceive of the changes or substitutions within the technical scope of the present invention, and all the changes or substitutions should be covered within 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 of data processing, the method comprising:

extracting component FairDSL data corresponding to the target component and interface FairDSL data corresponding to the specific method function from the initial FairDSL data, wherein the interface FairDSL data comprises: a target component identification corresponding to the target component;

adding component FairDSL data corresponding to the target component into the interface FairDSL data to generate target FairDSL data;

and sending the target FairDSL data to a client so that the client can analyze the target FairDSL data and generate an interface.

2. The method of claim 1, wherein the adding component FairDSL data corresponding to the target component to the interface FairDSL data to generate target FairDSL data comprises:

adding first mapping data to the interface FairDSL data to obtain target FairDSL data, wherein the first mapping data comprises: the target component identification and associated stored component FairDSL data corresponding to the target component.

3. The method of claim 2, wherein adding the first mapping data to the interfacial FairDSL data to obtain target FairDSL data comprises:

generating second mapping data, the second mapping data comprising: a method dictionary identification and the first mapping data stored in association, the method dictionary identification indicating a component FairDSL data support call in the first mapping data;

and adding the second mapping data to the interface FairDSL data to obtain target FairDSL data.

4. The method according to claim 3, wherein the data format of the first mapping data and/or the second mapping data is a dictionary format.

5. The method of claim 1, wherein extracting, from the initial FairDSL data, component FairDSL data corresponding to the target component and interface FairDSL data corresponding to the particular method function comprises:

converting the initial FairDSL data to abstract syntax tree AST data;

extracting component data corresponding to the target component under a component label node in the AST, and generating component FairDSL data corresponding to the target component identification based on the component data;

and extracting target data except the component data corresponding to the target component under each node in the AST, and generating the interface FairDSL data based on the target data.

6. The method of claim 5, wherein the object of the target component is a function, and the component identifier of the target component is a function name; the types of the component tag nodes include: function declarations and/or method declarations; wherein, in a case that the component tag node is a method declaration type, the component identification of the target component does not include a function name of the specific method function.

7. A method of data processing, the method comprising:

receiving target FairDSL data of an interface to be generated, which is sent by a service end, wherein the target FairDSL data is generated by the service end by adopting the data processing method of any one of claims 1 to 6;

parsing the target FairDSL data to generate an interface.

8. The method of claim 7, wherein the target FairDSL data includes the first mapping data, and wherein parsing the target FairDSL data to generate an interface comprises:

extracting the first mapping data from the target Fair DSL data, and deleting the first mapping data from the target Fair DSL data to obtain interface Fair DSL data, wherein the interface Fair DSL data comprises: a target component identification corresponding to the target component;

parsing the interfacial FairDSL data;

under the condition that the analyzed component identification exists in the first mapping data, extracting component FairDSL data corresponding to the component identification from the first mapping data, and analyzing the component FairDSL data corresponding to the component identification;

and drawing an interface based on the interface FairDSL data and the analysis result of the component FairDSL data corresponding to the component identification by adopting a Flutter engine.

9. The method of claim 8, wherein the target FairDSL data includes the second mapping data, and wherein extracting the first mapping data from the target FairDSL data comprises:

extracting the corresponding first mapping data from the target FairDSL data based on method dictionary identification in the second mapping data.

10. A data processing apparatus, characterized in that the apparatus comprises:

an extracting module, configured to extract, from the initial FairDSL data, component FairDSL data corresponding to the target component and interface FairDSL data corresponding to the specific method function, where the interface FairDSL data include: a target component identification corresponding to the target component;

an adding module, configured to add component FairDSL data corresponding to the target component to the interface FairDSL data, and generate target FairDSL data;

and the sending module is used for sending the target FairDSL data to a client so that the client can analyze the target FairDSL data and generate an interface.

11. A data processing apparatus, characterized in that the apparatus comprises:

a receiving module, configured to receive target FairDSL data of an interface to be generated, where the target FairDSL data is generated by the service end by using the data processing method according to any one of claims 1 to 6;

and the analysis module is used for analyzing the target FairDSL data to generate an interface.

12. An electronic device, comprising: processor, memory and a computer program stored on the memory and executable on the processor, which computer program, when executed by the processor, carries out the steps of the data processing method according to any one of claims 1 to 6 or carries out the data processing method according to any one of claims 7 to 9.

13. A computer-readable storage medium, characterized in that a computer program is stored thereon, which computer program, when being executed by a processor, carries out the steps of the data processing method according to one of claims 1 to 6 or carries out the data processing method according to one of claims 7 to 9.

14. A data processing system, characterized in that the system comprises: a server in communication with the client, the server being configured to implement the steps of the data processing method according to any one of claims 1 to 6, and the client being configured to implement the steps of the data processing method according to any one of claims 7 to 9.