CN112818176B

CN112818176B - Data processing method, device, equipment and storage medium

Info

Publication number: CN112818176B
Application number: CN202110196579.3A
Authority: CN
Inventors: 胡钦骋; 唐济民
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2021-02-08
Filing date: 2021-02-08
Publication date: 2023-12-12
Anticipated expiration: 2041-02-08
Also published as: CN112818176A

Abstract

The application relates to a data processing method, a device, equipment and a storage medium, wherein the method comprises the following steps: acquiring a protocol file, wherein the protocol file is a definition file of protocol data; compiling the protocol file to obtain a first file and a second file corresponding to the protocol file, wherein the first file is a source code file, and the second file is a binary file; performing data structure conversion on the protocol data according to a first file and a second file corresponding to the protocol file to generate a first type file; and based on the first type file, displaying a first operation interface of the protocol data at the client. The application can avoid the complicated operation of modifying the editor code to adapt to different data structures, reduce the development and maintenance cost and improve the data configuration efficiency.

Description

Data processing method, device, equipment and storage medium

Technical Field

The present application relates to the field of data processing technologies, and in particular, to a data processing method, apparatus, device, and storage medium.

Background

Protobuf (Protocol Buffers) is a data exchange format similar to Json, XML, etc. of Google open source, and can be applied to various fields such as network transmission, communication protocol, data storage, etc. as a binary data transmission format with excellent efficiency and compatibility.

In the related art, a manner of editing a text file such as Json or XML and then converting the edited text file by using a conversion tool, or a manner of separately developing a binary editor is often adopted to generate a format of Protobuf data. The mode of converting by using the converting tool is universal in format, does not need additional development support, but is quite invisible in business logic, so that error configuration files which meet basic standards but do not meet logic are easily configured, errors are difficult to check, maintenance cost is high, and data configuration efficiency is affected. The binary editor is independently developed, the structured display of the data is popular and easy to understand, the data can be displayed by attaching logic, but the development cost is high, when the data structure is changed, the editor code also needs to be adaptively modified, otherwise, the error reporting or the unavailability can be caused, the operation is complex, and the data configuration efficiency is further influenced.

Disclosure of Invention

The application provides a data processing method, a device, equipment and a storage medium, which can avoid the complicated operation of modifying an editor code to adapt to different data structures, reduce development and maintenance costs and improve data configuration efficiency.

In one aspect, the present application provides a data processing method, the method including:

acquiring a protocol file, wherein the protocol file is a definition file of protocol data;

compiling the protocol file to obtain a first file and a second file corresponding to the protocol file, wherein the first file is a source code file, and the second file is a binary file;

performing data structure conversion on the protocol data according to a first file and a second file corresponding to the protocol file to generate a first type file;

and based on the first type file, displaying a first operation interface of the protocol data at the client.

Another aspect provides a data processing apparatus, the apparatus comprising:

the file acquisition module is used for acquiring a protocol file, wherein the protocol file is a definition file of protocol data;

the compiling module is used for compiling the protocol file to obtain a first file and a second file corresponding to the protocol file, wherein the first file is a source code file, and the second file is a binary file;

the class generating module is used for carrying out data structure conversion on the protocol data according to the first file and the second file corresponding to the protocol file to generate a first class file;

And the interface generation module is used for displaying a first operation interface of the protocol data on the client side based on the first type file.

In another aspect there is provided an electronic device comprising a processor and a memory having stored therein at least one instruction or at least one program loaded by the processor and performing a data processing method as described above.

Another aspect provides a computer readable storage medium having stored therein at least one instruction or at least one program loaded and executed by a processor to implement a data processing method as described above.

The application provides an operation interface for displaying the protocol data by automatically reading the protocol file, is convenient for checking whether the stored protocol data is correct or not, is convenient for editing the protocol data, and provides a quick repair means for the protocol data in emergency; the structured display of the protocol data is obtained based on the definition file, when the data structure is changed, the editor code is not required to be changed, the structured display can be automatically identified according to the definition file, the operation is convenient, the development and maintenance cost is reduced, and the data configuration efficiency is further improved.

Drawings

In order to more clearly illustrate the embodiments of the application or the technical solutions and advantages of the prior art, the following description will briefly explain the drawings used in the embodiments or the description of the prior art, and it is obvious that the drawings in the following description are only some embodiments of the application, and other drawings can be obtained according to the drawings without inventive effort for a person skilled in the art.

Fig. 1 is an exemplary diagram of configuration using Json format provided by an embodiment of the present application.

FIG. 2 is a schematic diagram of a data processing system according to an embodiment of the present application.

Fig. 3 is a flow chart of a data processing method according to an embodiment of the present application.

Fig. 4 is a schematic flow chart of generating a first type file according to an embodiment of the present application.

FIG. 5 is an exemplary diagram of generating a first type of file according to an embodiment of the present application.

Fig. 6 is a flowchart illustrating a first operation interface generation according to an embodiment of the present application.

FIG. 7 is an exemplary diagram of interface control generation provided by an embodiment of the present application.

Fig. 8 is an exemplary diagram of a first operation interface according to an embodiment of the present application.

Fig. 9 is a schematic flow chart of another method for generating a first operation interface according to an embodiment of the present application.

Fig. 10 is a flowchart of another data processing method according to an embodiment of the present application.

Fig. 11a is a diagram illustrating a nested structure provided by an embodiment of the present application.

Fig. 11b is an exemplary diagram of a secondary expansion recursion provided by an embodiment of the present application.

Fig. 12 is an example of a second operation interface provided by an embodiment of the present application.

Fig. 13 is another example of a second operation interface provided by an embodiment of the present application.

Fig. 14 is a flowchart of another data processing method according to an embodiment of the present application.

FIG. 15 is an exemplary diagram of a check control provided by an embodiment of the present application.

Fig. 16 is an exemplary diagram of a verification display panel provided by an embodiment of the present application.

Fig. 17 is a schematic structural diagram of a data processing apparatus according to an embodiment of the present application.

Fig. 18 is a schematic structural diagram of a class generating module according to an embodiment of the present application.

Fig. 19 is a schematic diagram of the structure of a variable declaration unit according to an embodiment of the present application.

Fig. 20 is a schematic structural diagram of an interface generating module according to an embodiment of the present application.

Fig. 21 is a schematic structural diagram of another interface generating module according to an embodiment of the present application.

Fig. 22 is a schematic structural diagram of another data processing apparatus according to an embodiment of the present application.

Fig. 23 is a schematic structural diagram of another data processing apparatus according to an embodiment of the present application.

Fig. 24 is a schematic diagram of an embodiment of the present application. The hardware structure schematic diagram of the device for realizing the method provided by the embodiment of the application.

Detailed Description

The present application will be described in further detail with reference to the accompanying drawings, for the purpose of making the objects, technical solutions and advantages of the present application more apparent. It will be apparent that the described embodiments are only some, but not all, embodiments of the application. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to be within the scope of the application.

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

The following explanation is first made on the related nouns involved in the embodiments of the present specification:

unity3D (also referred to as Unity engine): the game engine is an engine applied to a three-dimensional scene and developed by Unity Technologies, is a multi-platform comprehensive game development tool capable of enabling players to easily create types of interactive contents such as three-dimensional video games, building visualizations, real-time three-dimensional animations and the like, and is a comprehensive integrated professional game engine.

Protobuf (Protocol Buffer): a data exchange format similar to Json, XML, etc. that is a Google open source, the internal data of which is in a pure binary format.

Protobuf is a binary data transmission format with excellent efficiency and compatibility, and can be applied to various fields such as network transmission, communication protocols, data storage and the like. To construct Protobuf data, the related art mainly adopts two ways: firstly, editing a Json or XML text file, and then converting the edited text file by using a conversion tool; in the second mode, a binary editor is developed separately.

For the first mode, text editing is visual for a source data structure, errors of data are easy to check, and low-level errors such as format errors can be directly checked by code checking; and because the format is universal, the existing editing tool is mature, additional development support is not needed, the conversion tool can be developed secondarily by means of some open-source libraries, and the development is relatively easy and efficient. However, the threshold for non-programmers is high, and even part of the content needs to be planned with fine arts; logic is extremely non-intuitive, such as in the game field, the gate logic and skill execution sequence all need logic imagination capability, and the text editing to understand specific logic requires enough time cost and labor cost; because of the common format, some basic error configuration files which meet the standard but do not meet the logic are easily allocated; debugging and troubleshooting errors are very inconvenient and inefficient for the development process. As shown in fig. 1, which is an exemplary diagram configured using the Json format.

For the second mode, a programmer is required to assist in developing an independent binary editor, and the data structure editing is completely customized due to the independent binary editor, so that additional checking tool checking can be developed, and the correctness of the data is ensured at the first time of editing; the structured display of the data is popular and easy to understand, and the data can be displayed by attaching logic; the content of options and controls is filled in, the editing threshold is low, and the code file is not required to be edited. However, development costs are extremely high, more humanized, and when data structures are modified, editor codes need to be modified in time, otherwise errors may be reported or not available.

Based on the above description, the embodiment of the application provides a data processing method, so as to reduce development and maintenance costs and improve data configuration efficiency. Referring to FIG. 2, a schematic architecture diagram of a data processing system according to an embodiment of the present application is shown, where the system may implement the data processing method according to the embodiment of the present application. As shown in fig. 2, the system may include a client 10 and a server 20.

The client 10 may be a smart phone, a desktop computer, a tablet computer, a notebook computer, a digital assistant, a smart wearable device, a monitoring device, a voice interaction device, or the like. The client 10 may store a protocol file 11 and a running tool script 12. Specifically, the client 10 provides an operation interface of protocol data (Protobuf data) through the running tool script 12, and transmits a corresponding data instruction to the server 20 based on an operation of the user in the operation interface.

The server 20 may be a server that operates independently, or a distributed server, or a server cluster that is composed of a plurality of servers, and may also be a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDNs, and basic cloud computing services such as big data and artificial intelligence platforms. The server 20 may read a protocol file (Proto file) 11, provide the protocol data in the operation interface and the editing mode of each data field in the protocol data, and perform corresponding data processing based on the data instruction of the client 10. The server 20 and the client 10 may be directly or indirectly connected through wired or wireless communication, and the present application is not limited herein.

Referring to fig. 3, a flowchart of a data processing method according to an embodiment of the application is shown, and the method can be applied to the system shown in fig. 2. It is noted that the present specification provides method operational steps as described in the examples or flowcharts, but may include more or fewer operational steps based on conventional or non-inventive labor. The order of steps recited in the embodiments is merely one way of performing the order of steps and does not represent a unique order of execution. When implemented in a real system or server product, the methods illustrated in the embodiments or figures may be performed sequentially or in parallel (e.g., in a parallel processor or multithreaded environment). As shown in fig. 3, the method may include:

S301, acquiring a protocol file, wherein the protocol file is a definition file of protocol data.

The protocol file refers to a Proto file, that is, a file with Proto as a suffix, and the protocol data refers to Protobuf data. After the user writes the protocol file, the protocol file can be stored in a preset path, the protocol file under the preset path is automatically acquired by running a tool script in the client, and then an operation interface of protocol data is provided for the user based on the protocol file. It will be appreciated that the preset path is generally a path specified in the tool script, and once the preset path is changed, the path specified in the tool script will be adaptively modified, and the setting of the preset path is not specifically limited in the present application.

S303, compiling a protocol file to obtain a first file and a second file corresponding to the protocol file, wherein the first file is a source code file, and the second file is a binary file.

After the server obtains the protocol file, the first file and the second file can be obtained by executing a compiling statement or running a compiling tool to compile the protocol file, for example, executing protoc.exe plus command parameters or running a protoc tool. The source code file may be a source code file in Java language, a source code file in c# language, or a source code file in c++, or the like, that is, the first file may be a cs file (file with a suffix of cs), a Java file (file with a suffix of Java), a cpp file (file with a suffix of cpp), or the like, and the second file refers to compiling the generated binary file, that is, the pb file (file with a suffix of pb).

S305, carrying out data structure conversion on the protocol data according to the first file and the second file corresponding to the protocol file, and generating a first type file.

The first file and the second file record the original data structure of Protobuf data, and in order to convert the original data structure from the required data structure, the original data structure can be repackaged, and the first file, namely the Wrapper file, is established to realize the method.

In one possible embodiment, referring to fig. 4, step S305 may include:

and S3051, obtaining a name space and a data structure corresponding to the protocol data according to a second file corresponding to the protocol file.

In order to avoid naming conflict and quickly search protocol data, the embodiment of the application generates different namespaces for different protocol data, and the namespaces can be obtained by analyzing the second file. In an implementation, the name of the namespace may correspond to the name of the item in which the protocol file is located, for example, the name of the item in which the protocol file is located is FaGame, and the name of the namespace may be formed by adding a preset suffix to FaGame, such as FaGame.

The data structure indicates the business logic of the protocol data, and the data structure includes a data type and a limit modifier of each data field. The data type is used to indicate the type of storage of the data field and may include a base type and a structure type. The basic type is that the data field is a basic data type or array type, such as int, string, bool, byte, etc. The structure type refers to that the data field is a message structure or a reference structure, and in practical applications, it is common that a message defined in other proto files can be referenced in one proto file, which results in that the data type of the formed data field is the structure type.

The limit modifier refers to a flag that limits the data field, and the proto file provides three limit modifiers, required, optional, and repeated. The data field defined by required is an essential field, the data field defined by optional is an optional field, and the data field defined by repeated is a field which can contain a plurality of elements, that is, the class member variable corresponding to the data field defined by repeated needs to store a plurality of values, and the data field defined by required or optional needs to store only one value. It will be appreciated that not every data field has a limit modifier, i.e. the limit modifier may be empty.

And S3053, establishing a first type file in the name space.

It can be understood that the language type used by the first type file is consistent with the language type used by the first file, that is, if the first file is a cs file, the first type file is also a cs file, and so on.

S3055, traversing each data field in the data structure, determining a target type based on the data type and the limit modifier of the data field, and declaring a member variable corresponding to the data field by using the target type in the first type file.

Because the data types of each data field are different, the data types can be mapped into the types of member variables which can be expressed by the language used by the first type file, and then the types are further updated by combining whether the data fields are limited by repeated or not, so that the target types are obtained.

In view of this, the step of determining the target type based on the data type of the data field and the defined modifier may, when embodied, comprise: if the data type is the basic type, determining the data type as the reference type; if the data type is the structure type, determining a second type file corresponding to the structure type, and determining the type in the second type file as the reference type; updating the reference type based on whether the limit modifier is a multi-choice modifier to obtain the target type.

That is, if the limit modifier is not a multi-choice modifier, when the data type is a base type, the base type is taken as the type of the corresponding member variable of the data field; when the data type is a structure type, since each structure type corresponds to a second type file, namely a Wrapper type file, the Wrapper type in the second type file is used as the type of the member variable corresponding to the data field. In specific implementation, a mapping rule exists between the name of the structure type and the class name of the corresponding Wrapper class in the Wrapper class file, and the server can obtain the Wrapper class according to the mapping rule. For example, the name of the structure type plus the fixed suffix wrapier is the corresponding class.

For example, the data field CastNums, where the data type is the int type, the type of the member variable corresponding to the data field generated in the first type file is also the int type. For the structure type, for example, the structure type is faskiltriggerwrapper, the class in the second type file corresponding to the structure type is faskiltriggerwrapper, and the type of the member variable corresponding to the data field generated in the first type file is faskiltriggerwrapper.

After the reference type is determined, the reference type is then adjusted based on the defined modifier. Specifically, if the limit modifier is a multi-choice modifier, the reference type is updated to a list. For example, if the CastNums qualifier is a multi-choice modifier, the last generated member variable may be declared as List < int > or ArrayList < int > or the like.

S3057, based on the first file corresponding to the protocol file and each member variable, creating an objective function in the first type file, wherein the objective function is used for converting the data structure of the protocol data.

In the embodiment of the application, besides the functions necessary for forming the class files, such as constructors, in order to realize the conversion between the data structure displayed by the interface and the data structure defined in the source code file, the conversion is realized by adding the objective function in the first class file. The objective function may include at least a first function for implementing reading of protocol data and a second function for implementing saving of protocol data. As shown in fig. 5, which generates one example of a first type of file.

S307, based on the first type file, a first operation interface of the protocol data is displayed on the client.

Each member variable in the first type file corresponds to a data field in the protocol data, and the data structure is also unchanged, so that the first operation interface can be generated based on the type of each member variable in the first type file, such as a text box of int type using limiting integers, a text box of floating point type using limiting floating point numbers, and the like.

Based on this, in one possible embodiment, as shown in fig. 6, step S307 may include:

s3071, obtaining all member variables in the first type file.

S3073, for each member variable, generating an interface control of the member variable according to the type of the member variable.

Specifically, for each member variable, if the type of the member variable is a basic data type, directly generating a corresponding interface control; if the type of the member variable is an array type, traversing each array element according to the length of the member variable, and continuing to execute step S3073 by taking each data element as the member variable; if the type of the member variable is the structure type, each sub-structure in the member variable is traversed, and the step S307 is continuously executed with each sub-structure as the member variable.

For example, as shown in FIG. 7, for a base data type, if the base data type is int (integer), then a textbox control is generated that restricts integers using the IntField; if the underlying data type is float, then generating a textbox control that restricts floating point numbers using the FloatField; if the underlying data type is string (string type), generating an unrestricted text box space using TextField; if the basic data type is a bool (boolean type), generating a switching control by using Toggle; if the underlying data type is enum (enumerated type), a ComboBox is used to generate a drop-down control.

S3075, variable information and interface controls of each member variable are displayed in a first operation interface of the client.

In the embodiment of the application, the variable information at least comprises a variable name, and for the member variable of the structure type, the variable information can also comprise a variable length, and in the first operation interface, the displayed data structure is consistent with the service logic to be represented by the protocol data. As shown in fig. 8, which is an example of a first operation interface of protocol data. For protocol data named FaGameMapData, items represents all data Items of Map Info, size provides the number of data Items, and for the Inited Born Actors field, its Size portion represents the number of Inited Born Actors.

And when the source code file is a source code file of C# language, the Unity engine provides a serialization function for supporting a data structure of System.

In view of this, as shown in fig. 9, in one-row embodiment, step S307 may further include:

s3077, storing the first type files under the first target directory.

S3079, using a file loading mechanism of a preset engine to run a first type of file under a first target directory so as to add a first operation interface of protocol data in an attribute panel of the preset engine.

The preset engine is an engine applied to a three-dimensional scene, namely a Unity engine. The first target directory refers to a directory of compiling C# source code files when the Unity engine is running. The file loading mechanism provided by the Unity engine is that the Unity engine automatically detects the C# source code files under the first target object, if the C# source code files are changed, all the C# source code files are automatically recompiled, and then corresponding modules are loaded based on the compiled results, so that corresponding operation interfaces can be added in the attribute panel.

Whereas the data structure derived from the format of the Protobuf data, i.e. the first file, does not support the serizableattribute. In order to use the serialization functionality in the property panel, the first file and the data structure in the property panel need to be converted, so that the first class of file corresponding class needs to be a serialization class, that is, the first class of file corresponding class is limited by using the serialization class. For example, if the first type file is a faskiltraiggerwrapier.cs file, the header of the faskiltraiggerwrapier corresponding type in the faskiltraiggerwrapier.cs file needs to be defined using system.

And an operation control used for operating the protocol data is also provided in the first operation interface, and the user can trigger an operation instruction by clicking the operation control. The operation control may at least include a creation control, a saving control, an uploading control and a deleting control, where the creation control is used for setting a default value for each data field in the protocol data, the saving control is used for saving the value of each data field in the first operation interface, the uploading control is used for adding a data field, and the deleting control is used for deleting the data field. In order to increase the user experience, the names of the operation controls can be adjusted for different protocol data.

By automatically reading the protocol file, an operation interface for displaying the data structure of the protocol data is provided, so that whether the stored protocol data is correct or not can be checked conveniently, the protocol data can be edited conveniently, and a quick repair means is provided for the protocol data in emergency.

Because the Unity engine has a layer limit on the automatic serialization of data, the method for providing multi-level sub-structure serialization can be considered for a very deep data structure, so that the editing of specific data fields can be realized. By providing an operator interface for a particular data field, the user does not have to spend more time editing the particular data field to find, which is particularly beneficial for deeper-level protocol data to quickly locate the particular data field.

In a possible implementation manner, as shown in fig. 10, the data processing method provided by the foregoing embodiment may further include:

s1001, in response to a query instruction, the query instruction carries target field information.

The user can trigger a query instruction through a query control in the first operation interface, and the target field information is used for indicating the position of a target field to be queried in a data structure of the protocol data.

S1003, analyzing the target field information by utilizing the target function in the first type file to obtain a target field.

The type of the target field information may be a character string type, which means that the target field information is a character string, and a structure type, which means that the target field information is a message structure.

When the server analyzes the target field information, if the type of the target field information is a character string type, dividing the target field information according to a preset special character to obtain at least one child node; then for each child node, a lookup is performed using a combination of reflection and recursion until the target field is found. When reflection and recursion are used for searching, for the data field of the array type, analyzing out the Index member, and obtaining a value by calling the Item [ Index ] through reflection; for byte arrays, a structure requiring further unpacking is generally adopted, and the related types can be selected for unpacking through parameter options and then further analyzed. Since Protobuf is not capable of completing a self-nesting or loop-referencing structure, there is no concern that self-nesting or loop-referencing and the like cause problems of wireless recursion.

For byte data, since Protobuf native is unable to complete self-nesting and circular referencing, it is considered to support byte data double-expansion recursion in a secondary packing manner. A disadvantage of typing bytes into a data structure is that it requires more packaging once per nested layer. As shown in fig. 11a, which is an exemplary diagram of the nested structure. To this end, some of the packaged types are enumerated by using a whitelist approach. If the type of the target field information is a structure type, detecting whether the structure type is in a white list or not; if yes, analyzing by using a predefined basic data editing class. As shown in fig. 11b, which is an example of the second expansion recursion, in fig. 11b, the BaseDataEditor is the basic data editing class.

S1005, a second operation interface of the target field is displayed at the client.

As shown in fig. 12, which is one example of the second operation interface. In fig. 12, the target field information is a character string, and the user can input target field information of a target field to be queried, i.e., triggers [0], actions [0], bonnactor, bonnactors [0], in the SearchString, the target field information indicating that the target field to be queried is the 1 st element of the bonnactors, which is located under the 1 st element of Triggers, the 1 st element of Actions. The user may trigger a query instruction by clicking a Translate button (query control) to display all sub-elements of the 1 st bornActors [0] in the second operation interface. In the object-oriented programming language, the point numbers represent the attribution information, so that the target field information is preferably segmented by using the point numbers, but it is also possible to segment by using special characters such as semicolons, commas, etc., and the embodiment of the present application is not limited in detail herein.

And figure 13 shows another example of a second operator interface. In fig. 13, the target field information is a message structure, and the user may select a message structure to be queried, for example, query fachecker state, and then all member variables in the corresponding class file of the message structure, that is, all member variables in the fachecker state wrapper, may be displayed in the second operation interface.

By providing the sub-structure query and display for the protocol data with deeper hierarchical structure and analyzing the secondary binary package adopted in part of the sub-structure in a recursion analysis mode, the user can quickly locate the relevant fields of the protocol data to be edited or checked, and the data editing efficiency is further improved.

It can be understood that the second operation interface may be a part of the first operation interface or may be a regenerated operation interface, and the present specification does not specifically limit the presentation form of the second operation interface.

In practice, when deleting data fields in a partial Proto file and reconstructing its data structure, reading cannot be performed with the new data structure because the already packed byte data is old. While the editing is followed as much as possible without destructive modification, there are variations in development. In order to save time for planning the configuration of the art and repeatedly brushing, and achieve migration of byte data, as shown in fig. 14, in a possible implementation, the data processing method provided in the foregoing embodiment may further include:

s1401, in response to the upgrade instruction, copying the protocol file to obtain an old protocol file, and copying the byte data file corresponding to the protocol file to obtain an old byte data file.

S1403, after finishing the modification of the protocol file, copying the file formed by the modification of the protocol file to obtain a new protocol file.

When the migration of protocol data is performed, the most critical problem is to replace the Byte data file corresponding to the old protocol file with the Byte data file corresponding to the new protocol file, wherein the Byte data file refers to the Byte binary file of the data. When the server executes, the core idea is to roll out the source code files of the old protocol file and the new protocol file, and reorganize the old byte data file by reading the source code file to obtain the new byte data file. It is necessary to copy the old protocol file, the old byte data file, and the new protocol file first, and store them under a specific path.

S1405, compiling the old protocol file and the new protocol file respectively to obtain a first file corresponding to the old protocol file and a first file corresponding to the new protocol file.

In the implementation, the first file corresponding to the old protocol file and the first file corresponding to the new protocol file may be obtained in the same manner as in step S303. The first file refers to a source code file, e.g., for the C# language, the first file is a cs file.

S1407, converting the old byte data file by utilizing a predefined conversion class based on the first file corresponding to the old protocol file and the first file corresponding to the new protocol file to obtain the new byte data file.

In the embodiment of the application, the predefined conversion class is used for reading the first file corresponding to the old protocol file and the first file corresponding to the new protocol file, and reorganizing the old byte data file so as to obtain the new byte data file.

S1409, storing the new byte data file in the second target directory. The second target directory refers to a directory storing a byte data file corresponding to the new protocol file.

By providing automatic data migration, after modifying the protocol file, the new data structure can be edited in the interface without modifying the editor code, namely, the latest data structure can be displayed to the user each time according to the change of the data structure of the configuration data without modifying the code, thereby saving development and maintenance cost and improving data editing efficiency.

For checking data dependency, data consistency, and the like, for various protocol data, the data processing method provided by the method embodiment further includes: responding to a verification instruction, wherein the verification instruction comprises a verification identification; acquiring data to be verified from the protocol data based on the identification; and checking the data to be checked according to the checking rule corresponding to the data to be checked.

The verification identification is used for uniquely identifying the data to be verified. As shown in fig. 15, which is an exemplary diagram of a verification control related to verification provided to a user in a first operation interface, the user may trigger a verification instruction by clicking the verification control. In order to intuitively understand whether the data to be checked passes or not, as shown in fig. 16, a check display panel is further provided for the user, and the check display panel is dynamically updated in real time, and once an item which does not meet the check rule is detected, the item is displayed in the check display panel.

According to the technical scheme provided by the embodiment of the method, the data processing method provided by the embodiment of the application provides an operation interface for displaying the protocol data by automatically reading the protocol file, so that whether the stored protocol data is correct or not can be checked conveniently, the protocol data can be edited conveniently, and a quick restoration means is provided for the protocol data in emergency; the structured display of the protocol data is obtained based on the definition file, when the data structure is changed, the editor code is not required to be changed, the protocol data can be automatically identified according to the self-defined file, the operation is convenient, the development and maintenance cost is reduced, and the data configuration efficiency is further improved.

In addition, under the condition that a separate editor is not developed manually, configuration and debugging can be rapidly carried out through an operation interface; in addition, under the condition that the behavior of some complex editors is not in line with expectations, the debugging can be assisted by observing and repairing the data, so that the method has high practicability.

Based on the same inventive concept as the method embodiment, the embodiment of the application also provides a data processing device. As shown in fig. 17, the apparatus 1700 may include:

a file obtaining module 1710, configured to obtain a protocol file, where the protocol file is a definition file of protocol data;

the compiling module 1720 is configured to compile a protocol file to obtain a first file and a second file corresponding to the protocol file, where the first file is a source code file and the second file is a binary file;

the class generating module 1730 is configured to perform data structure conversion on the protocol data according to the first file and the second file corresponding to the protocol file, so as to generate a first class file;

the interface generating module 1740 is configured to present a first operation interface of the protocol data on the client based on the first type file.

In one possible implementation, as shown in fig. 18, class generation module 1730 may include:

A file parsing unit 1731, configured to obtain a namespace and a data structure corresponding to the protocol data according to the second file corresponding to the protocol file;

a class file creation unit 1732 for creating a first class file in the namespace;

a variable declaration unit 1733, configured to traverse each data field in the data structure, determine a target type based on a data type and a definition modifier of the data field, and declare a member variable corresponding to the data field using the target type in the first type file;

the function declaration unit 1734 is configured to create an objective function in the first type file based on the first file and each member variable corresponding to the protocol file, where the objective function is used to implement conversion of the data structure of the protocol data.

In one possible embodiment, as shown in fig. 19, the variable declaration unit 1733 may include:

a first type determining unit 17331 for determining the data type as a reference type in case the data type is a basic type;

a second type determining unit 17332, configured to determine, when the data type is a structure type, a second type file corresponding to the structure type, and determine a class in the second type file as a reference type;

The type updating unit 17333 is configured to update the reference type based on whether the defined modifier is a multi-option modifier, so as to obtain the target type.

In one possible embodiment, as shown in fig. 20, the interface generation module 1740 may include:

the member variable obtaining unit 1741 is configured to obtain all member variables in the first type file;

the control generating unit 1742 is configured to generate, for each member variable, an interface control of the member variable according to a type of the member variable;

the content filling unit 1743 is configured to display the variable information and the interface control of each member variable in the first operation interface of the client.

In one possible embodiment, as shown in fig. 21, the interface generation module 1740 may further include:

a file storing unit 1744 for storing the first type of files under the first target directory;

the engine running unit 1745 is configured to use a file loading mechanism of a preset engine to run a first type of file under the first target directory, so as to add a first operation interface of protocol data in an attribute panel of the preset engine, where the preset engine is an engine applied to a three-dimensional scene.

In one possible embodiment, as shown in fig. 22, the apparatus 1700 may further include:

A first response module 1750, configured to respond to a query instruction, where the query instruction carries target field information;

the field query module 1760 is configured to parse the target field information by using the target function in the first type file to obtain a target field;

and the field display module 1770 is configured to display a second operation interface of the target field on the client.

the second response module 1780 is configured to copy the protocol file to obtain an old protocol file, and copy the byte data file corresponding to the protocol file to obtain an old byte data file in response to the upgrade instruction;

the file backup module 1790 is configured to copy a file formed by modifying the protocol file after the modification of the protocol file is completed, so as to obtain a new protocol file;

the second compiling module 17100 is configured to compile the old protocol file and the new protocol file respectively to obtain a first file corresponding to the old protocol file and a first file corresponding to the new protocol file;

the byte data generating module 17110 is configured to convert the old byte data file by using a predefined conversion class based on the first file corresponding to the old protocol file and the first file corresponding to the new protocol file, to obtain a new byte data file;

File storage module 17120 is configured to store the new byte data file into the second target directory.

It should be noted that, in the apparatus provided in the foregoing embodiment, when implementing the functions thereof, only the division of the foregoing functional modules is used as an example, in practical application, the foregoing functional allocation may be implemented by different functional modules, that is, the internal structure of the device is divided into different functional modules, so as to implement all or part of the functions described above. In addition, the apparatus and the method embodiments provided in the foregoing embodiments belong to the same concept, and specific implementation processes of the apparatus and the method embodiments are detailed in the method embodiments and are not repeated herein.

The embodiment of the application also provides an electronic device, which comprises a processor and a memory, wherein at least one instruction or at least one section of program is stored in the memory, and the at least one instruction or the at least one section of program is loaded by the processor and executes the data processing method provided by the embodiment of the method.

Further, fig. 24 shows a schematic diagram of a hardware structure of an apparatus for implementing the method provided by the embodiment of the present application, where the apparatus may participate in forming or including the device or the system provided by the embodiment of the present application. As shown in fig. 24, the device 24 may include one or more processors 2402 (shown in figures as 2402a, 2402b, … …,2402 n) (the processor 2402 may include, but is not limited to, a microprocessor MCU or a processing means such as a programmable logic device FPGA), a memory 2404 for storing data, and a transmission means 2406 for communication functions. In addition, the method may further include: a display, an input/output interface (I/O interface), a Universal Serial Bus (USB) port (which may be included as one of the ports of the I/O interface), a network interface, a power supply, and/or a camera. It will be appreciated by those of ordinary skill in the art that the configuration shown in fig. 24 is merely illustrative and is not intended to limit the configuration of the electronic device described above. For example, the device 24 may also include more or fewer components than shown in fig. 24, or have a different configuration than shown in fig. 24.

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

The memory 2404 may be used to store software programs and modules of application software, and the processor 2402 executes the software programs and modules stored in the memory 2404 to perform various functional applications and data processing, i.e., implement a data processing method as described above, according to the program instructions/data storage device corresponding to the method in the embodiment of the present application. Memory 2404 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid state memory. In some examples, memory 2404 may further include memory located remotely from processor 2402, which may be connected to device 24 through a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The transmission means 2406 is for receiving or transmitting data via a network. Specific examples of the network described above may include a wireless network provided by a communication provider of device 24. In one example, the transmission means 2406 includes a network adapter (NetworkInterfaceController, NIC) that can be connected to other network devices through a base station to communicate with the internet. In one example, the transmission means 2406 may be a radio frequency (RadioFrequency, RF) module for communicating with the internet wirelessly.

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

The embodiment of the application also provides a computer readable storage medium, wherein at least one instruction or at least one section of program is stored in the computer readable storage medium, and the at least one instruction or the at least one section of program is loaded and executed by a processor to realize the data processing method provided by the embodiment of the method.

Alternatively, in the present embodiment, the above-described computer-readable storage medium may be located in at least one network server among a plurality of network servers of the computer network. Alternatively, in the present embodiment, the storage medium may include, but is not limited to: a U-disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a removable hard disk, a magnetic disk, or an optical disk, or other various media capable of storing program codes.

Embodiments of the present application also provide a computer program product or computer program comprising computer instructions stored in a computer readable storage medium. The processor of the electronic device reads the computer instructions from the computer-readable storage medium and executes the computer instructions to cause the electronic device to execute the computer-readable storage medium provided by the method embodiments described above.

It should be noted that: the sequence of the embodiments of the present application is only for description, and does not represent the advantages and disadvantages of the embodiments. And the foregoing description has been directed to specific embodiments of this specification. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for the apparatus and electronic device embodiments, since they are substantially similar to the method embodiments, the description is relatively simple, and references to the parts of the description of the method embodiments are only required.

The foregoing description has fully disclosed specific embodiments of this application. It should be noted that any modifications to the specific embodiments of the application may be made by those skilled in the art without departing from the scope of the application as defined in the appended claims. Accordingly, the scope of the claims of the present application is not limited to the foregoing detailed description.

Claims

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

based on the first type file, a first operation interface of the protocol data is displayed at the client;

the data structure conversion is performed on the protocol data according to the first file and the second file corresponding to the protocol file, and the generation of the first type file comprises the following steps:

obtaining a name space and a data structure corresponding to the protocol data according to a second file corresponding to the protocol file;

Establishing the first type file in the name space;

traversing each data field in the data structure, determining a target type based on the data type and the limit modifier of the data field, and declaring a member variable corresponding to the data field in the first type file by using the target type;

and creating an objective function in the first type file based on the first file corresponding to the protocol file and each member variable, wherein the objective function is used for realizing conversion of the data structure of the protocol data.

2. The method of claim 1, wherein the determining the target type based on the data type of the data field and the defined modifier comprises:

if the data type is the basic type, determining the data type as a reference type;

if the data type is a structure type, determining a second type file corresponding to the structure type, and determining the type in the second type file as the reference type;

updating the reference type based on whether the defined modifier is a multi-choice modifier to obtain the target type.

3. The method according to claim 1, wherein the presenting, at the client, the first operation interface of the protocol data based on the first type of file includes:

Acquiring all member variables in the first type file;

for each member variable, generating an interface control of the member variable according to the type of the member variable;

and displaying the variable information and the interface control of each member variable in a first operation interface of the client.

4. The method of claim 1, wherein the source code file is a c# language source code file, and the first class file corresponding class is a serialization class;

the displaying, at the client, the first operation interface of the protocol data based on the first type file includes:

storing the first type files under a first target directory;

and operating the first type of files under the first target directory by using a file loading mechanism of a preset engine to add a first operation interface of the protocol data in an attribute panel of the preset engine, wherein the preset engine is an engine applied to a three-dimensional scene.

5. The method according to claim 1, wherein the method further comprises:

responding to a query instruction, wherein the query instruction carries target field information;

analyzing the target field information by utilizing the target function in the first type file to obtain a target field;

And displaying a second operation interface of the target field at the client.

6. The method according to claim 1, wherein the method further comprises:

in response to the upgrade instruction, copying the protocol file to obtain an old protocol file, and copying a byte data file corresponding to the protocol file to obtain an old byte data file;

copying a file formed by modifying the protocol file after the protocol file is modified, so as to obtain a new protocol file;

compiling the old protocol file and the new protocol file respectively to obtain a first file corresponding to the old protocol file and a first file corresponding to the new protocol file;

converting the old byte data file by utilizing a predefined conversion class based on a first file corresponding to the old protocol file and a first file corresponding to the new protocol file to obtain a new byte data file;

and storing the new byte data file into a second target directory.

7. A data processing apparatus, the apparatus comprising:

the interface generation module is used for displaying a first operation interface of the protocol data on the client side based on the first type file;

establishing the first type file in the name space;

8. An electronic device, characterized in that it comprises a processor and a memory, in which at least one instruction or at least one program is stored, which is loaded by the processor and which performs the data processing method according to any of claims 1-6.

9. A computer readable storage medium having stored therein at least one instruction or at least one program, the at least one instruction or the at least one program being loaded and executed by a processor to implement the data processing method of any of claims 1-6.