Table data processing method and device and electronic equipment

Abstract

The invention discloses a table data processing method and device and electronic equipment. The method comprises the steps that a table configuration file sent by a target object is received, and the table configuration file comprises configuration information of each field in a table; a table structure is determined according to the table configuration file, and each cell in the table structure is configured according to the field sequence and specification in the table configuration file; an entity class bound with the table structure is generated, the entity class is bound with column information in the table structure, the entity class comprises annotation information, and the annotation information is used for determining the mapping relation between fields in the entity class and columns in the table structure; and mapping the data in the table to a field corresponding to the entity class. According to the method and the device, the technical problem of high maintenance cost caused by frequent modification and redeployment of codes required by a traditional table processing mechanism during business demand adjustment is solved.

Description

Technical Field

[0001] This application relates to the field of data processing, and more specifically, to a method, apparatus, and electronic device for processing tabular data. Background Technology

[0002] In business systems such as finance, e-commerce, and logistics that require frequent import of tabular data, data models (such as orders, reports, and user information) are often adjusted due to changes in business requirements. In traditional solutions, when data models change frequently, developers need to modify the code and redeploy it each time, resulting in extremely high maintenance costs. Different table template formats require separate parsing logic, leading to poor system scalability, and manually modifying mapping rules can easily cause data misalignment or parsing anomalies.

[0003] There is currently no effective solution to the above problems. Summary of the Invention

[0004] This application provides a method, apparatus, and electronic device for processing tabular data, which at least solves the technical problem that traditional tabular processing mechanisms require frequent code modifications and redeployments when business needs are adjusted, resulting in high maintenance costs.

[0005] According to one aspect of the embodiments of this application, a method for processing tabular data is provided, comprising: receiving a tabular configuration file sent by a target object, wherein the tabular configuration file contains configuration information for each field in the table; determining a table structure based on the tabular configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the tabular configuration file; generating an entity class bound to the table structure, wherein the entity class is bound to column information in the table structure, the entity class includes annotation information, the annotation information being used to determine the mapping relationship between fields in the entity class and columns in the table structure; and mapping data in the table to fields corresponding to the entity class.

[0006] Optionally, generating an entity class bound to the table structure includes: receiving a table export request sent by the target object; obtaining the latest table configuration file based on the table export request; determining the first configuration information of the first field in the table structure based on the latest table configuration file, wherein the first field is any field in the table structure; and determining the entity class and annotation information corresponding to the first field based on the first configuration information, wherein the entity class includes at least one of the following: class name, field name, and field type.

[0007] Optionally, the latest table configuration file can be obtained, including: obtaining the request time of the table export request and obtaining the timestamps of all table configuration files in the database; the table configuration file with the largest difference between the timestamp and the request time is determined as the latest table configuration file.

[0008] Optionally, obtain the latest table configuration file, including: obtaining the version number of all table configuration files from the database; and determining the table configuration file corresponding to the last updated version among the version numbers as the latest table configuration file.

[0009] Optionally, the method further includes: sending a table export request to the database for business data query; receiving query result data returned by the database, wherein the query result data is a list stored in the form of key-value pairs; and mapping the query result data to entity classes.

[0010] Optionally, the method further includes: sending a style rule request to a style adapter, wherein the style adapter is used to parse the style rules in the table configuration file; receiving the cell style object returned by the style adapter, and generating a table file with the corresponding style based on the cell style object.

[0011] Optionally, the method further includes: receiving a table import request sent by the target object, wherein the table import request includes a table template to be uploaded; obtaining the entry corresponding to the field ID of the table template in the table import request, and parsing the table template according to the entry corresponding to the field ID; mapping the parsed table data to the corresponding table file, and storing the table file in the database.

[0012] According to another aspect of the embodiments of this application, a table data processing apparatus is also provided, comprising: a receiving module for receiving a table configuration file sent by a target object, wherein the table configuration file contains configuration information for each field in the table; a determining module for determining a table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file; a generating module for generating an entity class bound to the table structure, wherein the entity class is bound to column information in the table structure, the entity class includes annotation information, the annotation information being used to determine the mapping relationship between the fields in the entity class and the columns in the table structure; and a mapping module for mapping data in the table to fields corresponding to the entity class.

[0013] According to another aspect of the embodiments of this application, an electronic device is also provided, including: a memory for storing program instructions; and a processor connected to the memory for executing program instructions to perform the following functions: receiving a table configuration file sent by a target object, wherein the table configuration file contains configuration information for each field in the table; determining a table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file; generating an entity class bound to the table structure, wherein the entity class is bound to column information in the table structure, the entity class includes annotation information, the annotation information being used to determine the mapping relationship between the fields in the entity class and the columns in the table structure; and mapping data in the table to the fields corresponding to the entity class.

[0014] According to another aspect of the embodiments of this application, a non-volatile storage medium is also provided, the non-volatile storage medium including a stored computer program, wherein the device where the non-volatile storage medium is located executes the above-mentioned table data processing method by running the computer program.

[0015] According to another aspect of the embodiments of this application, a computer program product is also provided, including computer instructions that, when executed by a processor, implement the above-described method for processing tabular data.

[0016] In this embodiment, a table configuration file sent by the target object is received, containing configuration information for each field in the table. The table structure is determined based on the configuration file, where each cell is configured according to the field order and specifications in the configuration file. An entity class bound to the table structure is generated, where the entity class is bound to column information in the table structure. The entity class includes annotation information used to determine the mapping relationship between fields in the entity class and columns in the table structure. Data in the table is mapped to fields corresponding to the entity class, achieving rapid response to changes in business requirements. This results in dynamic table processing with zero code modification and timely effectiveness, thus solving the technical problem of high maintenance costs caused by frequent code modifications and redeployment required by traditional table processing mechanisms when business requirements are adjusted. Attached Figure Description

[0017] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0018] Figure 1 This is a hardware structure block diagram of a computer terminal for implementing a method for processing tabular data according to an embodiment of this application;

[0019] Figure 2 This is a flowchart of a method for processing tabular data according to an embodiment of this application;

[0020] Figure 3 This is a code diagram illustrating an entity class and annotations according to an embodiment of this application;

[0021] Figure 4 This is a structural diagram of a tabular data processing apparatus according to an embodiment of this application;

[0022] Figure 5 This is a technical structure diagram according to an embodiment of this application;

[0023] Figure 6 This is an operation timing flowchart according to an embodiment of this application. Detailed Implementation

[0024] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of the present application.

[0025] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0026] The information collected in this application embodiment is information and data authorized by the user or fully authorized by all parties. The collection, storage, use, processing, transmission, provision, disclosure and application of the relevant data all comply with the relevant laws, regulations and standards of the relevant regions, and necessary confidentiality measures have been taken. It does not violate public order and good morals, and provides corresponding operation entry points for users to choose to authorize or reject the automated decision results. If the user chooses to reject, the process will proceed to the expert decision-making process.

[0027] In related technologies, the mapping relationship between Excel columns and Java Bean fields needs to be implemented through hard coding, which suffers from rigid mapping rules and high costs for adapting to multiple formats. When the data model changes frequently, developers need to modify the code and redeploy it every time, resulting in extremely high maintenance costs. Different Excel template formats require separate parsing logic, leading to poor system scalability. Manually modifying mapping rules can easily cause data misalignment or parsing anomalies, and there is a lack of visual verification mechanisms.

[0028] To address the problems existing in related technologies, embodiments of this application provide a method for processing tabular data, which can be run on... Figure 1 The following describes the computer terminal shown.

[0029] The table data processing method provided in this application can be executed on a mobile terminal, computer terminal, or similar computing device. Figure 1 A hardware block diagram of a computer terminal for implementing a method for processing tabular data is shown. Figure 1 As shown, the computer terminal 10 may include one or more processors (shown as 102a, 102b, ..., 102n in the figure) (the processor may include, but is not limited to, a microprocessor MCU or a programmable logic device FPGA, etc.), a memory 104 for storing data, and a transmission module 106 for communication functions connected via wired and / or wireless networks. In addition, it may also include: a display, a keyboard, a cursor control device, 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, and a BUS bus. Those skilled in the art will understand that... Figure 1 The structure shown is for illustrative purposes only and does not limit the structure of the aforementioned electronic device. For example, computer terminal 10 may also include... Figure 1 The more or fewer components shown, or having the same Figure 1 The different configurations shown.

[0030] It should be noted that the aforementioned one or more processors and / or other data processing circuits are generally referred to herein as "data processing circuits". These data processing circuits may be implemented wholly or partially as software, hardware, firmware, or any other combination thereof. Furthermore, the data processing circuits may be a single, independent processing module, or may be wholly or partially integrated into any other element in the computer terminal 10. As involved in the embodiments of this application, the data processing circuits serve as processor control (e.g., selection of a variable resistor termination path connected to an interface).

[0031] The memory 104 can be used to store software programs and modules of application software, such as the program instructions / data storage device corresponding to the table data processing method in this embodiment. The processor executes various functional applications and data processing by running the software programs and modules stored in the memory 104, thereby realizing the above-mentioned table data processing method. The memory 104 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 instances, the memory 104 may further include memory remotely located relative to the processor, and these remote memories can be connected to the computer terminal 10 via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0032] The transmission module 106 is used to receive or send data via a network. Specific examples of the network described above may include a wireless network provided by the communication provider of the computer terminal 10. In one example, the transmission module 106 includes a Network Interface Controller (NIC), which can connect to other network devices via a base station to communicate with the Internet. In another example, the transmission module 106 may be a Radio Frequency (RF) module, used for wireless communication with the Internet.

[0033] The display may be, for example, a touchscreen liquid crystal display (LCD) that allows the user to interact with the user interface of the computer terminal 10.

[0034] It should be noted here that, in some optional embodiments, the above... Figure 1 The computer terminal shown may include hardware elements (including circuitry), software elements (including computer code stored on a computer-readable medium), or a combination of both hardware and software elements. It should be noted that... Figure 1 This is only one instance of a specific particular instance, and is intended to illustrate the types of components that may exist in the aforementioned computer terminal.

[0035] In the above operating environment, this application provides an embodiment of a method for processing tabular data. It should be noted that the steps shown in the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions. Also, although a logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in a different order than that shown here.

[0036] Figure 2 This is a flowchart of a method for processing tabular data according to an embodiment of this application, such as... Figure 2As shown, the method includes the following steps:

[0037] Step S202: Receive the table configuration file sent by the target object, wherein the table configuration file contains the configuration information of each field in the table.

[0038] In step S202 above, the execution entity is the backend server. The backend server can receive a form configuration file sent from the front-end user interface or other external system (target object) through the API interface. For example, the form configuration file can be sent by the target object (such as a user) through the front-end configuration module. The form configuration file is presented in JSON (JavaScript Object Notation) or other structured data format. The specific content in the form configuration file involves various attributes and settings of each field in the table.

[0039] After receiving the table configuration file, the backend server parses it and converts it into objects or data structures that the program can understand and process. For example, it converts JSON text into Java objects, each object representing a configuration item, such as a field attribute.

[0040] Step S204: Determine the table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file.

[0041] In step S204 above, the table structure (or table layout) can be determined based on the field information defined in the table configuration file. Information in the table configuration file may include, for example, field names, types, display order, width, whether to display, and style settings. The table structure may include the number of columns, their order, column attributes, and applied data formats. By determining the table structure in this step, it is ensured that each cell is displayed correctly according to the field order and specifications (such as width and data format) specified in the configuration file. This satisfies the needs of business users to customize the table layout through the front-end interface, while significantly reducing development and maintenance costs.

[0042] Step S206: Generate an entity class bound to the table structure. The entity class is bound to the column information in the table structure. The entity class includes annotation information, which is used to determine the mapping relationship between the fields in the entity class and the columns in the table structure.

[0043] In step S206 above, generating an entity class bound to the table structure refers to dynamically creating a Java entity class in the backend program based on the table configuration file provided by the frontend user interface. The design of this entity class is closely related to the table structure, meaning that each attribute (field) of the entity class corresponds one-to-one with a column in the table. The annotation information contained in the entity class is used to precisely specify the mapping relationship between the entity class fields and the columns in the table, ensuring that the data can be accurately matched and populated with the columns in the table during the import and export process.

[0044] For example, when generating entity classes, the backend server can leverage reflection and bytecode enhancement techniques (such as Javassist, Byte Buddy, or ASM) to dynamically generate Java entity classes. This step means that the structure of the entity class (such as field names and field types) is not hard-coded at compile time, but dynamically constructed at runtime based on the table configuration file. In the dynamically generated entity class, annotation information is added to each field, for example, using the `@ExcelProperty` annotation (an annotation used for field mapping in the EasyExcel framework). The information contained in the annotation can include: index, value, and other attributes, such as data format, column width, etc. The index represents the ordinal index of the column in the table, used to determine which column the entity class field corresponds to. The value represents the column header, used for column name identification when reading or writing data.

[0045] By dynamically adding annotations to entity classes, the backend server can intelligently parse data from tabular (such as Excel) files. Even if the order or names of table columns change, it can accurately map the data to the corresponding fields in the entity class based on the annotation information. Conversely, when exporting data, the field data in the entity class can be correctly populated into the corresponding columns of the table, making the data processing flow more flexible and robust. This reduces the need to modify the source code when business requirements change, thereby lowering maintenance costs and improving system responsiveness and scalability.

[0046] Step S208: Map the data in the table to the fields corresponding to the entity class.

[0047] In step S208 above, mapping the data in the table to the fields corresponding to the entity class refers to the operation of reading or writing the data of each column into the corresponding attribute (field) of the Java entity class based on the column information in the table (such as an Excel file) during data processing. This step can be implemented with the help of an Excel processing framework, such as EasyExcel, which automatically completes the data mapping through the annotation mechanism and data read / write classes provided by the framework, without the need to manually write complex loops and matching logic.

[0048] For example, when reading an Excel file, each row of data is treated as an instance of a Java entity class. EasyExcel (or other Excel processing frameworks) automatically matches the columns in the table based on the index and value attributes specified in the @ExcelProperty annotation, converts the column data to the corresponding Java type, and then populates the fields in the entity class.

[0049] When writing to an Excel file, the data mapping process is reversed. EasyExcel iterates through instances of Java entity classes, determines which column of the Excel spreadsheet the data for the entity class fields should be written to based on information in the @ExcelProperty annotation (such as index and value), and converts and writes it according to the specified format.

[0050] Through this mechanism, the server can flexibly parse and write data when faced with table files of different formats, greatly simplifying the complexity of data operations and improving the efficiency and accuracy of data processing. Simultaneously, dynamically generating annotated entity classes allows the server to quickly respond to changes in the business model, avoiding frequent modifications to the source code and reducing maintenance costs.

[0051] Through steps S202 to S208 above, the goal of rapidly responding to changes in business requirements is achieved, thereby realizing the technical effect of dynamic table processing with zero code modification and timely effectiveness. This solves the technical problem that traditional table processing mechanisms require frequent code modification and redeployment when business requirements are adjusted, resulting in high maintenance costs. The following is an explanation.

[0052] In step S206 of the above table data processing method, generating an entity class bound to the table structure includes: receiving a table export request sent by the target object; obtaining the latest table configuration file based on the table export request; determining the first configuration information of the first field in the table structure based on the latest table configuration file, wherein the first field is any field in the table structure; and determining the entity class and annotation information corresponding to the first field based on the first configuration information, wherein the entity class includes at least one of the following: class name, field name, and field type.

[0053] In some embodiments of this application, when a user (i.e., the target object) needs to export a table, a table export request can be sent to the backend server through the frontend configuration module. This table export request may include information such as the data range and the exported file format (e.g., Excel). Upon receiving the table export request, the backend server retrieves the latest table configuration file from the configuration center. The configuration center is responsible for storing and managing various configuration information (or configuration files) to ensure that the backend server can obtain the latest version of the configuration data. By parsing the latest table configuration file, field information is extracted, which may include, for example, the first configuration information of the first field. The backend server dynamically generates an entity class using bytecode technology. The attributes (fields) and annotations of this entity class directly correspond to the field descriptions in the parsed table configuration file. An entity class can include the following information: class name, field name, and field type. The class name is dynamically generated and can change dynamically according to the business scenario. The field name matches the logical name of the field in the table configuration file to ensure data consistency. The field type is generated according to the data type definition of the field in the table configuration file, such as String, Integer, or BigDecimal. The annotation information corresponding to the first field is used to guide the EasyExcel framework on how to match the field of the entity class with the column in the table and perform data transformation.

[0054] In the above steps, obtaining the latest table configuration file includes: obtaining the request time of the table export request and obtaining the timestamps of all table configuration files in the database; the table configuration file with the largest difference between the timestamp and the request time is determined as the latest table configuration file.

[0055] In some embodiments of this application, when a user submits a form export request, the backend server records the request time (which can be the moment the server receives the request). This request time is used as a benchmark for filtering the latest form configuration file. All relevant form configuration files are retrieved from the database, and their timestamps are obtained; these timestamps can be the last updated timestamps. By comparing the timestamps and the request time, the form configuration file with the largest difference is determined as the latest form configuration file. This latest form configuration file is used to generate entity classes bound to the form structure and guides the EasyExcel framework on how to import or export data.

[0056] In the above steps, obtaining the latest table configuration file includes: retrieving the version numbers of all table configuration files from the database; and determining the table configuration file corresponding to the last updated version among the version numbers as the latest table configuration file.

[0057] In some embodiments of this application, the latest table configuration file can also be determined in another way: the backend server accesses the database and queries the version numbers of all table configuration files. Typically, the storage structure of the table configuration file in the database assigns a unique version number to each configuration, which increments with each configuration update to track historical configuration changes. After obtaining all version numbers, the latest version is determined based on the naming type of the version numbers. For example, when the naming type of the version numbers can be determined by the size of the version number, a higher version number indicates a newer configuration. Alternatively, when the table configuration file directly contains version numbers, the configuration file with the highest version number can be directly queried from the table configuration file database. The table configuration file corresponding to the last updated version in the version number list is determined as the latest table configuration file.

[0058] For example, in a report generation system, whenever business requirements change and necessitate adjustments to the report's format or content, the relevant configuration files are modified and saved on the front-end interface, with the version number automatically incrementing. When the back-end server receives a request to export a report, it searches the database for the latest version of the configuration file associated with that request, ensuring that the generated report adheres to the latest business rules and format requirements. This approach effectively addresses the continuous evolution of business processes and rapid changes in requirements.

[0059] The above method for processing tabular data further includes: sending a table export request to the database for business data query; receiving the query result data returned by the database, wherein the query result data is a list stored in the form of key-value pairs; and mapping the query result data to entity classes.

[0060] In some embodiments of this application, when a front-end user issues a table export request, the back-end server constructs a database query statement based on the parameters in the table export request (such as time range, business type, exported table format, etc.), and finds business data that meets the request conditions in the database according to the database query statement. After the database executes the query, it returns the query result data. This query result data is presented in a structured form, such as a List. <Map<String,Object> The `ResultMap` property represents a row from the query results. The received query results are mapped to instances of Java entity classes for further data processing or direct output to an Excel file via an Excel export framework. This mapping process is achieved by reading key-value pairs from the `ResultMap` and matching them to the corresponding fields in the entity classes. In practical applications, to simplify code and improve mapping efficiency, Java reflection or ORM frameworks (such as Hibernate and MyBatis) can be used to automate the mapping process. For example, using MyBatis' `ResultMap` feature, the mapping from fields to object properties can be defined in the mapping configuration file, automatically mapping query results to entity class instances.

[0061] The above method for processing tabular data further includes: sending a style rule request to a style adapter, wherein the style adapter is used to parse the style rules in the table configuration file; receiving the cell style object returned by the style adapter, and generating a table file with the corresponding style based on the cell style object.

[0062] In some embodiments of this application, when the backend server generates a table file, it not only needs to obtain the table data but also needs to apply the correct style rules to ensure that the exported table has good readability. Therefore, the backend server sends a style rule request to the style adapter. After receiving the request, the style adapter parses the style rules in the table configuration file. The style rules can be stored in the configuration file in JSON or other structured formats and describe the visual appearance of cells in the table, such as width, font size, color, border style, etc. After parsing the style rules, the style adapter generates a series of CellStyle objects, which encapsulate all the style information of the cells. CellStyle objects can be customized to adapt to the needs of different frameworks, such as following the EasyExcel style definition specifications when using the EasyExcel framework. The backend server uses these cell style objects to generate a table file with the correct styles, for example, by calling the style processing interface of the Excel export framework (such as EasyExcel) to apply the style information (such as CellStyle objects) to specific cells.

[0063] The above method for processing tabular data further includes: receiving a table import request sent by the target object, wherein the table import request includes a table template to be uploaded; obtaining the entry corresponding to the field ID of the table template in the table import request, and parsing the table template according to the entry corresponding to the field ID; mapping the parsed table data to the corresponding table file, and storing the table file in the database.

[0064] In some embodiments of this application, when a user (target object) needs to import data, they upload a table template (which can be an Excel file) through the front-end user interface and send it to the back-end server via a table import request. The back-end server receives the request, which includes the table file and additional parameters such as field IDs and corresponding entries for business type or imported data category. The back-end server parses the table template to extract the data and understand its structure. The parsing process relies on the latest configuration information related to the uploaded table template obtained from the configuration center. This configuration information includes field IDs, names, data types, and other necessary metadata. During the parsing process, each row of data is converted into a Map.<String,Object> The data is structured in the form of a key, such as a field ID, where the value is the corresponding data for that field. The advantage of this data transformation is that even if the field order differs in different templates, the data can still be accurately located and mapped using the field ID. After parsing, the extracted data is mapped to the corresponding Java entity class for further processing or storage. Based on the dynamically generated entity class, the backend server uses reflection or ORM tools to extract the data from the Map.<String,Object> The data is extracted and populated into the corresponding fields of the entity class. After mapping and data transformation, the processed data (i.e., data existing in the form of entity classes) is stored in the database by calling the relevant database interface.

[0065] The process begins with receiving a user-uploaded table import request, then parsing the uploaded table template, mapping the data using dynamically generated entity classes, and storing it in the database. This mechanism ensures that even in environments with frequently changing business requirements, the server can flexibly handle table data of various formats. Furthermore, the dynamic configuration capabilities of the configuration center avoid manual code modifications due to changes in template fields, significantly improving the system's scalability and responsiveness.

[0066] The above method for processing tabular data can solve the following problems: 1) Conflict between frequent changes in business models and hard-coded coupling: Traditional Excel column and Java field mapping requires hard-coded implementation (e.g., fixed binding using @ExcelProperty annotation). When the business model changes (e.g., adding a customer rating field), the code needs to be modified and redeployed, resulting in high maintenance costs and delayed response. 2) Business bottleneck with zero configuration capabilities for non-technical personnel: Business personnel cannot independently adjust the field order / display (e.g., hiding contract amounts), and must submit IT requests and wait for scheduling, leading to delays in urgent report requests (average 3-5 days). 3) Increased compatibility costs for multiple Excel templates: Different department / scenario templates (e.g., differences in column names and order in financial / sales reports) require independent development of parsing logic, increasing the development workload by 2 person-days for each new template, making the system difficult to scale. 4) High error risk and lack of verification in manual mapping: Manual modification of annotations can easily lead to data misalignment (e.g., date columns are mistakenly mapped to amount fields), and there is no real-time preview mechanism. Errors are only discovered after deployment, resulting in extremely high repair costs.

[0067] The tabular data processing method provided in this application generates a JSON configuration including the order of header fields, display status, style, and data format through a front-end visual configuration layer; the configuration is dynamically persisted by the configuration center in the back-end server; the configuration is parsed in real time using a dynamic export engine in the back-end server, and Java entity classes bound to EasyExcel annotations are dynamically generated through bytecode technology to achieve adaptive mapping between headers and data; finally, data format conversion and style rendering are completed through an import / export style adaptation module (or style adapter). This method allows non-technical personnel to define the Excel structure independently through drag-and-drop operations, eliminating the need for development intervention when business models change, significantly reducing maintenance costs. It also supports dynamic adaptation of multiple templates and ensures data accuracy through a visual verification mechanism, significantly improving business iteration efficiency. It is suitable for complex business scenarios that require frequent adjustments to the data model.

[0068] This application provides a tabular data processing system, including a client and a server. The client may include a front-end visual configuration module, which is used to: 1) provide a visual interface supporting user operations such as dragging and sorting, controlling visibility, and defining styles for Excel header fields; 2) convert user configuration behavior into structured JSON data, including field order, display status, style configuration, and data format; and 3) submit the configuration JSON to the back-end configuration center via an interface for subsequent dynamic parsing. The server includes a configuration center module (hereinafter referred to as the configuration center), a dynamic export engine module (hereinafter referred to as the dynamic export engine), and a style adaptation and data format conversion module. The configuration center module is used to: 1) receive and persist the JSON configuration data (i.e., tabular configuration file) uploaded by the front end, and classify and store it according to business identifiers (such as template ID and business type); 2) support version management of configuration data to ensure that historical configurations are traceable and rollbackable; and 3) provide version management and real-time configuration push capabilities to ensure that the dynamic export engine obtains the latest configuration. The dynamic export engine module includes: 1) Dynamic header builder: Retrieves the latest table configuration information (including header configuration information) for the corresponding business from the configuration center, and dynamically constructs the table structure (including header structure) based on the configuration information, including field order, column width, style, etc. 2) Bytecode entity generator: Based on reflection and bytecode enhancement technology, combined with EasyExcel annotation specifications, it automatically injects EasyExcel annotations (such as @ExcelProperty) to dynamically generate Java entity classes for import and export, realizing the binding of fields with Excel columns. 3) Adaptive data mapper: During import, it matches the data source according to the configured field ID and dynamically maps it to entity attributes; during export, it renders data according to the configured order and automatically filters hidden fields. The style adaptation and data format conversion module includes: 1) Style rendering engine (or style adapter): Supports flexible conversion of various data formats (such as date, number, boolean value), parses style rules in JSON, converts them into EasyExcel CellStyle objects, and dynamically applies them to the header and data cells. 2) Data Format Converter: Based on the configured format type (such as "yyyy-MM-dd", "#,##0.00"), automatically perform type conversion during data reading and writing to ensure the accuracy of data parsing.

[0069] The following explanation illustrates how the data in the above tables is processed, using specific scenarios as examples.

[0070] Company A needs to collect financial data from multiple subsidiaries every month and generate a standardized monthly report including an income statement, balance sheet, and cash flow statement. In the traditional model, each subsidiary's IT team needs to hard-code field mappings according to the group's template. Each month, due to business adjustments (such as adding a "R&D expense deduction" item), this requires 3-5 days of code modification, and data merging errors are easily caused by field misalignment. The steps corresponding to the above method are as follows:

[0071] 1. Front-end visual configuration:

[0072] (1) Company A's finance department defines a monthly report template via drag-and-drop on a web interface: a. Add a "Research and Development Expense Deduction" field, set the data format to BigDecimal and retain two decimal places. b. Adjust the field order: move "Operating Revenue" to the first row and hide non-core fields such as "Management Expenses - Travel Expenses". c. Configure the style: set the header background color to blue and add thousands separators to the amount fields. This method generates a structured JSON configuration containing field IDs, display names, sequential indexes, visibility, style rules, and data formats through drag-and-drop operations, replacing the traditional hard-coded Excel header definition method, allowing business personnel to adjust the header structure without coding.

[0073] (2) Generate JSON configuration fragments

[0074] {

[0075] "templateId":"finance_monthly_report",

[0076] "fields":[

[0077] {"name":"operatingRevenue","type":"NUMBER","format":"#,##0.00","visible":true,"order":1},

[0078] {"name":"rdTaxDeduction","type":"NUMBER","format":"#,##0.00","visible":true,"order":5}

[0079] ],

[0080] "styles":{"headerBgColor":"#0000FF","cellBorder":"1px solid#000"}

[0081] }

[0082] 2. Configuration Center Persistence: JSON configurations are automatically stored to the Nacos cluster (or database), with version numbers increasing from v1.0 to v2.1. Historical versions support one-click rollback.

[0083] 3. Dynamic Export Engine Execution: (1) The engine parses the latest configuration in real time and dynamically generates the Java entity class DynamicFinanceReport through Byte Buddy. The field order and type are completely consistent with JSON. (2) Combine the EasyExcel annotation @ExcelProperty to bind fields to Excel columns. The corresponding code is as follows: Figure 3 As shown. This step parses the JSON configuration through a dynamic export engine, then uses bytecode technology (Javassist / ASM) to create Java entity classes in real time and automatically injects EasyExcel annotations (such as @ExcelProperty and @ColumnWidth), decoupling the dynamic mapping between entity fields and Excel columns from the source code compilation stage.

[0084] 4. Data Export and Style Rendering: (1) After each subsidiary uploads its financial data, the system automatically maps it to the dynamically generated entity class. (2) When importing and exporting, the style adapter applies the JSON configuration to generate an Excel file with a blue header and thousands separator format. Cell borders are added using Apache POI to convert the style rules (font / color / border) in the JSON into EasyExcel's CellStyle object. The CellWriteHandler is registered and dynamically applied to the header and data cells to achieve configuration-driven visual rendering.

[0085] The above steps, through front-end visual configuration and dynamic bytecode generation technology, enable non-technical personnel to independently maintain complex Excel templates, reducing business model change response time from days to minutes. Simultaneously, a visual verification mechanism improves data accuracy to 99.7%, significantly reducing the operating costs and risks of enterprise-level reporting systems. Furthermore, a configuration-driven adaptive data mapping engine matches data columns based on field IDs in JSON during import or export, ignoring differences in Excel column order and naming, supporting multiple templates for the same business entity (e.g., financial template A has field order of [unit price, quantity], while sales template B has order of [quantity, discount price]). It also enables multi-version management and real-time push from the configuration center: including using a distributed configuration center (such as Nacos) to store JSON configurations, supporting version rollback, canary releases, and real-time push of changes to the dynamic engine, ensuring business adjustments take effect within seconds. It also includes an exception handling mechanism for data format conversion: when format conversion fails (e.g., incorrect date string format), it automatically reverts to the default format and logs the error, preventing global export interruptions due to single-point failures.

[0086] Figure 4 This is a structural diagram of a tabular data processing apparatus according to an embodiment of this application, such as... Figure 4 As shown, the device includes:

[0087] The receiving module 40 is used to receive a table configuration file sent by the target object, wherein the table configuration file contains configuration information for each field in the table;

[0088] Module 42 is used to determine the table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file;

[0089] The generation module 44 is used to generate entity classes that are bound to the table structure. The entity classes are bound to the column information in the table structure. The entity classes include annotation information, which is used to determine the mapping relationship between the fields in the entity classes and the columns in the table structure.

[0090] Mapping module 46 is used to map data in a table to fields corresponding to entity classes.

[0091] Through the receiving module 40, determining module 42, generating module 44 and mapping module 46 in the above-mentioned table data processing device, the goal of quickly responding to changes in business requirements is achieved. This realizes the technical effect of dynamic table processing with zero code modification and timely effectiveness, thereby solving the technical problem that traditional table processing mechanisms require frequent code modification and redeployment when business requirements are adjusted, resulting in high maintenance costs.

[0092] In the generation module of the aforementioned table data processing device, the generation module is further configured to receive a table export request sent by the target object; obtain the latest table configuration file based on the table export request; determine the first configuration information of the first field in the table structure based on the latest table configuration file, wherein the first field is any field in the table structure; and determine the entity class and annotation information corresponding to the first field based on the first configuration information, wherein the entity class includes at least one of the following: class name, field name, and field type.

[0093] In the generation module of the aforementioned table data processing device, the generation module is also used to obtain the request time of the table export request and the timestamps of all table configuration files in the database; the table configuration file with the largest difference between the timestamp and the request time is determined as the latest table configuration file.

[0094] In the generation module of the aforementioned table data processing device, the generation module is also used to obtain the version numbers of all table configuration files from the database; and to determine the table configuration file corresponding to the last updated version in the version number as the latest table configuration file.

[0095] The aforementioned table data processing device also includes a processing module 48, which is used to send a table export request to the database for business data query; receive query result data returned by the database, wherein the query result data is a list stored in the form of key-value pairs; and map the query result data to entity classes.

[0096] In the processing module of the aforementioned table data processing device, the processing module is also used to send a style rule request to the style adapter, wherein the style adapter is used to parse the style rules in the table configuration file; receive the cell style object returned by the style adapter, and generate a table file with the corresponding style based on the cell style object.

[0097] In the processing module of the aforementioned table data processing device, the processing module is further configured to receive a table import request sent by the target object, wherein the table import request includes a table template to be uploaded; obtain the entry corresponding to the field ID of the table template in the table import request, and parse the table template according to the entry corresponding to the field ID; map the parsed table data to the corresponding table file, and store the table file in the database.

[0098] It should be noted that, Figure 4 The device for processing the tabular data shown is used to perform... Figure 2 The method for processing tabular data shown above is also applicable to the device for processing tabular data, and will not be repeated here.

[0099] Figure 5 This is a technical structure diagram according to an embodiment of this application, such as... Figure 5 As shown, the architecture includes: storage layer, engine layer, configuration center layer, front-end visual configuration layer, and public layer.

[0100] The front-end visual configuration layer provides users with an intuitive interface, allowing non-technical users to customize the structure of Excel files through simple drag-and-drop and editing interactions. This includes, but is not limited to, the order of header fields, their visibility, style definitions, and data formats. Specific components are as follows:

[0101] 1. Field Management Panel: Provides management of Excel fields, supporting functions such as field sorting and visibility control. Includes: a. Sort Controller: Allows users to change the position of fields in Excel. b. Visibility Switch: Controls whether fields are displayed in Excel. c. Style Editor: Sets the visual style of fields, such as font, color, and borders.

[0102] 2. Format designer, including: date format selector, numeric format selector, character concatenation selector: used to customize the format display of different data types.

[0103] 3. Preview Window: Displays the immediate effect, helping users verify the correctness of the configuration. Error data can be highlighted with markers. The styles and formatting in the preview window are updated in real time by the real-time style renderer, reflecting the results of user operations.

[0104] The configuration center layer stores and manages dynamically generated configurations from the front-end configuration layer, ensuring data persistence, version management, and real-time push notifications. Specific functions include: 1. Storage: Saving configuration data uploaded from the front-end, such as JSON configuration files. 2. Version Control: Tracking configuration change history, supporting rollback and version management. 3. Push Notification: Immediately notifying the back-end dynamic export engine when configurations are updated, ensuring the latest configuration takes effect immediately.

[0105] The engine layer is responsible for parsing configurations, dynamically generating Java entity classes, and performing data import and export tasks. Specifically, it includes a dynamic export engine and a style & format adaptation engine. The dynamic export engine includes:

[0106] 1. Bytecode Generator: Uses bytecode technology (such as Javassist or ASM) to dynamically create Java entity classes, achieving flexible mapping with Excel columns. It includes: a class builder, an annotation injector, and a class loader. The class builder constructs the basic structure of the class based on configuration information; the annotation injector automatically injects the annotations required by EasyExcel, such as @ExcelProperty, into the class; and the class loader ensures that the dynamically generated class can be correctly loaded and used by the Java Virtual Machine.

[0107] 2. Data Mapper: Responsible for importing and exporting data, dynamically matching fields and data based on configuration information. This includes data acquisition, data mapping, and data population.

[0108] The style and format adaptation engine includes: 1. Style renderer: Applyes the style rules configured on the application front-end to ensure the accuracy of the generated Excel file format, including: header style generator, cell style generator, and content style generator. 2. Format renderer: Supports various data format conversions, such as date format converter, numeric format converter, etc., to ensure correct data parsing and display.

[0109] The storage layer primarily refers to the database (MySQL), used for persistent storage of business data and configuration information. The engine layer reads data from the storage layer and inserts the data into it.

[0110] The common layer covers general functions such as log printing, log storage, error reporting, and operation logging.

[0111] Figure 6 This is an operation timing flowchart according to an embodiment of this application, such as... Figure 6 As shown, it includes: configuration stage, export stage, and import stage.

[0112] During the configuration phase, users set styles / formats by dragging and dropping fields on the front-end configuration layer interface. These settings are converted into a JSON configuration file, which is stored in the front-end configuration layer. For example, this configuration could be {id:"amount"; title:"Amount", style:{...}}. Upon receiving the new configuration, the configuration center sends a notification to the dynamic export engine to ensure that the latest configuration is applied.

[0113] The export phase includes the following steps: 1. The user clicks "Export Report," triggering the entire export process; 2. Request Export (Configuration ID): The front-end configuration layer sends the configuration ID as a parameter to the back-end server's dynamic export engine to request the export of data under a specific configuration; 3. Fetch Latest Configuration: The back-end dynamic export engine fetches the latest header and style configurations related to the configuration ID from the configuration center; 4. Dynamically Generate Entity Classes (with EasyExcel annotations): Java entity classes are dynamically created using bytecode technology, automatically injecting annotations such as @ExcelProperty to achieve precise binding between fields and Excel columns; 5. Query Business Data: The dataset to be exported is obtained from the data source (such as a database); 6. Return a List <map>Data: The data source returns a data collection, which is a list stored in key-value pair format for easy subsequent mapping processing; 7. Mapping to dynamic entities by ID: The dynamic export engine will map the List... <map>The data in the table is mapped to the previously generated dynamic entity class, ensuring a one-to-one correspondence between the data and the header fields; 8. Request style rules: The dynamic export engine requests and parses specific style rules from the style adapter to determine the visual presentation of the Excel file; 9. Return CellStyle object: The style adapter returns the parsed specific cell style object to the dynamic export engine, facilitating the application of styles by the dynamic export engine; 10. Generate Excel file (apply styles + formatting): The dynamic export engine generates an Excel file with the correct styles based on the configuration and data; 11. Download file: The generated Excel file is provided to the user for download.

[0114] The import phase includes the following steps: 1. User uploads Excel template: The user uploads an Excel template or file containing the data to be imported through the front-end configuration layer interface; 2. Request parsing (configuration ID): The back-end server's dynamic export engine receives the uploaded file and configuration ID, and begins the parsing process; 3. Obtain format converter: Dynamically obtains a format converter (e.g., date converter) from the style adapter based on the data format requirements; 4. Return DateConverter, etc.: The format converter is used to ensure the uniformity and correctness of the data format; 5. Map data by configuration ID: The dynamic export engine parses the Excel data according to the configuration ID and maps it to the corresponding business entity in the Excel file; 6. Return List <map>Structure: The parsed data is stored in a list format for easy further processing; 7. Data persistence: The parsed data is stored in a database or other data storage system to complete the data import; 8. Import success notification: The data source sends a notification of successful import of the table data to the front-end configuration layer; 9. The front-end configuration layer displays a preview of the results, such as highlighting error data in red.

[0115] This application embodiment also provides an electronic device, which includes a memory and a processor. The memory is used to store program instructions; the processor is connected to the memory and is used to execute program instructions to perform the following functions: receiving a table configuration file sent by a target object, wherein the table configuration file contains configuration information for each field in the table; determining a table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file; generating an entity class bound to the table structure, wherein the entity class is bound to column information in the table structure, and the entity class includes annotation information used to determine the mapping relationship between the fields in the entity class and the columns in the table structure; and mapping the data in the table to the fields corresponding to the entity class.

[0116] It should be noted that the aforementioned electronic equipment is used to perform Figure 2 The processing method for the tabular data shown above is also applicable to this electronic device, and will not be repeated here.

[0117] This application embodiment also provides a non-volatile storage medium, which includes a stored computer program. The device containing the non-volatile storage medium executes the following method for processing tabular data by running the computer program: receiving a table configuration file sent by a target object, wherein the table configuration file contains configuration information for each field in the table; determining a table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file; generating an entity class bound to the table structure, wherein the entity class is bound to column information in the table structure, and the entity class includes annotation information used to determine the mapping relationship between fields in the entity class and columns in the table structure; and mapping data in the table to fields corresponding to the entity class.

[0118] It should be noted that the aforementioned non-volatile storage media is used for execution. Figure 2 The processing method for the tabular data shown above is also applicable to this non-volatile storage medium, and will not be repeated here.

[0119] This application also provides a computer program product, including computer instructions that, when executed by a processor, implement the steps of the table data processing method in various embodiments of this application.

[0120] This application also provides a computer program that, when executed by a processor, implements the steps of the table data processing method in various embodiments of this application.

[0121] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0122] In the above embodiments of this application, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0123] In the several embodiments provided in this application, it should be understood that the disclosed technical content can be implemented in other ways. The device embodiments described above are merely illustrative; for example, the division of units can be a logical functional division, and in actual implementation, there may be other division methods. For instance, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the displayed or discussed mutual coupling, direct coupling, or communication connection may be through some interfaces; the indirect coupling or communication connection between units or modules may be electrical or other forms.

[0124] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0125] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0126] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as a USB flash drive, read-only memory (ROM), random access memory (RAM), portable hard drive, magnetic disk, or optical disk.

[0127] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.< / map> < / map> < / map>

Claims

1. A method for processing tabular data, characterized in that, include: Receive a table configuration file sent by the target object, wherein the table configuration file contains configuration information for each field in the table; The table structure is determined based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file; Generate an entity class that is bound to the table structure, wherein the entity class is bound to the column information in the table structure, and the entity class includes annotation information, which is used to determine the mapping relationship between the fields in the entity class and the columns in the table structure; Map the data in the table to the fields corresponding to the entity class.

2. The method according to claim 1, characterized in that, Generate entity classes bound to the table structure, including: Receive the table export request sent by the target object; Based on the table export request, obtain the latest table configuration file; The first configuration information of the first field in the table structure is determined based on the latest table configuration file, wherein the first field is any field in the table structure; Based on the first configuration information, the entity class and annotation information corresponding to the first field are determined, wherein the entity class includes at least one of the following: class name, field name, and field type.

3. The method according to claim 2, characterized in that, Get the latest table configuration file, including: Get the request time of the table export request, and get the timestamps of all table configuration files in the database; The table configuration file with the largest difference between its timestamp and the requested time is determined as the latest table configuration file.

4. The method according to claim 2, characterized in that, Get the latest table configuration file, including: Retrieve the version numbers of all table configuration files from the database; The table configuration file corresponding to the last updated version in the version number is determined as the latest table configuration file.

5. The method according to claim 2, characterized in that, The method further includes: Send the table export request to the database for business data query; Receive query result data returned by the database, wherein the query result data is a list stored in the form of key-value pairs; The query result data is mapped to the entity class.

6. The method according to claim 2, characterized in that, The method further includes: Send a style rule request to the style adapter, wherein the style adapter is used to parse the style rules in the table configuration file; Receive the cell style object returned by the style adapter, and generate a table file with the corresponding style based on the cell style object.

7. The method according to claim 1, characterized in that, The method further includes: Receive a table import request sent by the target object, wherein the table import request includes a table template to be uploaded; Obtain the entry corresponding to the field ID of the table template in the table import request, and parse the table template based on the entry corresponding to the field ID; The parsed table data is mapped to the corresponding table file, and the table file is stored in the database.

8. A device for processing tabular data, characterized in that, include: The receiving module is used to receive a table configuration file sent by the target object, wherein the table configuration file contains configuration information for each field in the table; The determination module is used to determine the table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file; A generation module is used to generate entity classes that are bound to the table structure. The entity classes are bound to column information in the table structure. The entity classes include annotation information, which is used to determine the mapping relationship between fields in the entity classes and columns in the table structure. The mapping module is used to map data in the table to fields corresponding to the entity class.

9. An electronic device, characterized in that, include: Memory, used to store program instructions; A processor, connected to the memory, is configured to execute program instructions to perform the following functions: receiving a table configuration file sent by a target object, wherein the table configuration file contains configuration information for each field in the table; determining a table structure based on the table configuration file, wherein each cell in the table structure is configured according to the field order and specifications in the table configuration file; generating an entity class bound to the table structure, wherein the entity class is bound to column information in the table structure, the entity class includes annotation information used to determine the mapping relationship between fields in the entity class and columns in the table structure; and mapping data in the table to fields corresponding to the entity class.

10. A non-volatile storage medium, characterized in that, The non-volatile storage medium includes a stored computer program, wherein the device containing the non-volatile storage medium executes the tabular data processing method according to any one of claims 1 to 7 by running the computer program.

11. A computer program product comprising computer instructions, characterized in that, When the computer instructions are executed by the processor, they implement the method for processing tabular data as described in any one of claims 1 to 7.

Images