Excel data exporting method and device

Abstract

The invention discloses an Excel data exporting method and device. The Excel data exporting method is executed in the same Java virtual machine in sequence. The method comprises the steps that a level signal receives original data and places the original data into a temporary magnetization file; loading the JSON mapping file with the version number into a memory heap; analyzing and mapping to generate an XSSFWorkbook template object; a field level ConcurentHashMap style cache is established, and data filling is completed; when the row count reaches a hardware constant, newly establishing a sheet, writing the charge image into a disk in a streaming manner, and immediately releasing the memory of the sheet; finally, the magnetization direction sequence is converted into optical pulses through DMA, the optical pulses are returned to a client side, and meanwhile the TRIM erases the temporary file. According to the method, under the condition that an SXSSF is not used, complex cell merging and low memory occupation are considered, version rollback is supported, the style cache is synchronously destroyed along with the sheet life cycle, and rapid, flexible and idempotent export of a large file is achieved.

Description

Technical Field

[0001] This invention relates to the field of large-scale spreadsheet generation technology, and in particular to an Excel data export method and apparatus. Background Technology

[0002] As enterprises become increasingly digitalized, business systems frequently need to export massive amounts of data into Excel reports. Traditionally, this relies heavily on Apache POI or its secondary development frameworks (such as EasyPoi). Developers must modify Java code and recompile and deploy for each format change, resulting in high maintenance costs. When the data volume exceeds one million rows, using POI's XSSF mode keeps the entire workbook in memory, easily leading to OutOfMemoryError (OOM). While using SXSSF streaming mode can reduce memory usage, it cannot support merged cells or complex styles across multiple sheets, limiting functionality. Furthermore, existing technologies do not offer fine-grained reuse of style objects, leading to repeated creation of the same color or font, exacerbating CPU and memory waste. They also lack automatic pagination mechanisms for multi-sheet, large-data scenarios, and the coupling of configuration information with program code prevents hot updates or rapid rollback. Therefore, the industry urgently needs a universal export solution that maintains XSSF's rich style capabilities, achieves low-memory streaming, and supports hot rollback of configurations. Summary of the Invention

[0003] The purpose of this invention is to provide an Excel data export method and apparatus, thereby solving the aforementioned problems existing in the prior art.

[0004] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0005] An Excel data export method executes the following steps sequentially within the same Java Virtual Machine process, with data format evolution achieved through continuous energy state transformation from charge to magnetization direction to electric pulse between each step:

[0006] S1. Receiving steps: Convert the raw data packets from the external business system into a digital bit stream using bus level signals and write them into a temporary file F0 in the solid-state storage, thus completing the electro-magnetic energy conversion.

[0007] S2. Configuration loading steps: The CPU loads the pre-stored JSON mapping file M into memory in the form of magnetism → electricity → charge. The mapping file M includes at least the multi-sheet page identifier, cell field name, number of merged rows and columns, and style identifier, and each mapping record carries a globally unique version number.

[0008] S3. Template generation steps: Parse the JSON charge distribution into a tree object graph in the memory heap, generate the XSSFWorkbook template object T, and complete the energy state transformation of charge distribution → data structure.

[0009] S4. Style caching and data population steps:

[0010] Create a ConcurrentHashMap<String,CellStyle> Cache H, with field names as keys and CellStyle objects as values;

[0011] For each data record, the cache hit / miss logic determines whether to reuse or create a new CellStyle, and the data value is written to the corresponding memory address of the template object T in level form;

[0012] S5, Page Break - Discard Steps for Each Sheet:

[0013] When the row counter reaches the hardware constant Constants.SHEET_MAX_SIZE_HSSF, a new XSSFSheet object is created in the heap. The charge image of the current sheet is written sequentially to the disk file Fx in the form of magnetization direction via the file output stream. Then, the heap memory occupied by the current sheet object is immediately released, completing the continuous conversion of charge → magnetization direction → memory release.

[0014] S6. Result return step: The magnetization direction sequence of the final Excel file Fx is converted into light pulses and returned to the client through the DMA engine, and the TRIM command is triggered to erase the temporary file F0, completing the magnetic → electric → optical energy conversion and physical storage space reclamation.

[0015] The version number is used to roll back to any historical mapping configuration with one click when requirements change, and the heap memory only maintains the charge image of the current sheet throughout the process, thus balancing complex merged cells and low memory usage without using SXSSF.

[0016] Preferably, the lifecycle of the cache H is bound to a single sheet. When a new sheet is created, an empty cache H is created simultaneously, and when a sheet is discarded, the cache H is cleared simultaneously to prevent style objects from leaking across sheets.

[0017] Preferably, the JSON mapping file M resides in the memory heap as a read-only copy. During rollback, only the copy pointer is replaced, which takes less than 1 second and does not require restarting the Java Virtual Machine.

[0018] Preferably, Constants.SHEET_MAX_SIZE_HSSF is set to 1048576, which is consistent with the maximum number of rows in a single sheet in Excel 2007+, ensuring that the physical row order of the disk file Fx corresponds one-to-one with the row order in memory.

[0019] Preferably, the merged cell range generates an array of AreaReference objects in the heap using the recursive buildRowSpan method, and submits it to the XSSFSheet all at once before writing it to disk, reducing the number of disk I / O operations.

[0020] Preferably, an "incremental entropy coding step" is added between step S4 and step S5:

[0021] For duplicate values ​​of the same field appearing in consecutive rows, a 32-bit Bloom Filter summary is first generated in memory;

[0022] Only when the digest is hit, subsequent repeated values ​​are marked with a 1-bit "same as previous" flag at the charge level; otherwise, the full value is written.

[0023] Before writing to the disk in step S5, the flag sequence is compressed by a small hardware LZ4 encoder, which reduces the amount of magnetization direction data in a single sheet by 15-25%, thereby reducing NAND flash memory write amplification.

[0024] Preferably, at the moment a new sheet is created in step S5, the timestamp is read by the CPU's RDTSC instruction and concatenated with the current process PID to generate a 128-bit physical random number, which is then written as the UUID of the new sheet to the custom attribute area of ​​the disk file Fx.

[0025] This UUID is used for comparison during subsequent incremental exports to prevent the same data from being repeatedly magnetized and written, thus achieving "idempotent deduplication at the magnetization direction level".

[0026] Preferably, "optical signal pre-compensation" is performed before returning in step S6:

[0027] The network card PHY chip first performs a Fourier transform on the bitstream of the Excel file Fx to obtain the attenuation coefficient of the high-frequency components;

[0028] Based on the attenuation coefficient, a pre-emphasized charge pulse is superimposed in reverse before the electro-optical conversion, which increases the eye diagram aperture of the receiving end by ≥0.2UI, reduces signal distortion caused by long fiber transmission, and ensures the physical integrity of large files downloaded remotely.

[0029] An Excel data export device based on the same concept includes:

[0030] The receiving unit is used to receive raw data packets from external business systems via a bus or network interface using level signals, convert them into digital bit streams, and write them into a temporary file F0 in solid-state storage, thus completing the electro-magnetic energy conversion.

[0031] The configuration unit is used to load a pre-stored JSON mapping file M from solid-state storage into memory in read-only mode via a magnetic-electric-charge process. The mapping file M contains at least multi-sheet page identifiers, cell field names, number of merged rows and columns, style identifiers, and a globally unique version number, and supports one-click rollback based on the version number.

[0032] The parsing and exporting unit integrates a template generation module, a style caching module H, and a pagination-sheet-by-sheet discarding module. It is used to parse the JSON charge distribution into an XSSFWorkbook template object T in the memory heap, establish a ConcurrentHashMap cache H with field names as keys and CellStyle objects as values, and complete data filling through cache hit / miss logic.

[0033] At the same time, when the row count reaches the hardware constant Constants.SHEET_MAX_SIZE_HSSF, a new XSSFSheet object is created, and the charge image of the current sheet is sequentially written to the disk file Fx in the form of magnetization direction, and then the heap memory occupied by the sheet object is immediately released.

[0034] The result return unit is used to convert the magnetization direction sequence of the final Excel file Fx into light pulses through the DMA engine and return it to the client via the network interface. At the same time, it triggers the TRIM instruction to erase the temporary file F0, completing the magnetic-electric-optical energy conversion and physical storage space reclamation.

[0035] Each unit is sequentially coupled through a memory bus or DMA controller to form a closed loop of "electric-magnetic-charge-magnetic-light" energy conversion. The lifecycle of the style cache H is bound to a single sheet, established when the sheet is created and destroyed when the sheet is discarded, ensuring zero leakage of style objects across sheets.

[0036] In another instance, a computer-readable storage medium stores instructions that implement the above method, which, when executed by a processor, complete the energy mode conversion of charge-magnetization direction-electric pulse and maintain the heap memory to store only the charge image of the current sheet.

[0037] The beneficial effects of this invention are:

[0038] Low memory and high compatibility: It adopts a "discard one sheet at a time" strategy, and the heap memory only stores the current sheet object. Complex merged cells and style functions are not restricted. Compared with the pure SXSSF solution, the peak memory usage is reduced by 40-60%, and it supports all features of Excel 2007+.

[0039] Zero code changes: The JSON mapping file is decoupled from the program. Adding or deleting fields, adjusting styles, and modifying column widths only require updating the configuration. Combined with the version number, it can be rolled back to any historical version in less than 1 second without restarting the JVM.

[0040] Style-level reuse: Field-level ConcurrentHashMap caching ensures that the same style object is created only once and destroyed synchronously with the sheet's lifecycle, avoiding cross-sheet leakage and improving export speed by more than 30%.

[0041] The magnetic-electric-optical energy closed loop completes the physical conversions of electricity to magnetism, magnetism to charge, charge to magnetization direction, and magnetism to electricity to light in four stages: receiving, parsing, writing, and returning. The entire process is DMA-zero copy, reducing CPU load and disk write amplification.

[0042] Idempotency and Integrity: By generating sheet-level UUIDs using RDTSC timestamps and writing them to the file attribute area, combined with incremental entropy encoding and optical signal pre-compensation, the idempotency and physical signal integrity of large file remote downloads are guaranteed. This is suitable for cloud environments, big data centers, and high-concurrency reporting scenarios. Attached Figure Description

[0043] Figure 1 This is a flowchart of a method according to an embodiment of the present invention;

[0044] Figure 2 This is a block diagram of the device structure according to an embodiment of the present invention. Detailed Implementation

[0045] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0046] Reference Figure 1 and Figure 2 The method for exporting Excel data, as shown, executes the following steps sequentially within the same Java Virtual Machine process, with data format evolution achieved through continuous energy state transformation from charge to magnetization direction to electric pulse between each step:

[0047] S1. Receiving steps: Convert the raw data packets from the external business system into a digital bit stream using bus level signals and write them into a temporary file F0 in the solid-state storage, thus completing the electro-magnetic energy conversion.

[0048] Specifically: physical connection

[0049] External business systems are connected to the local PCIe network card via a standard Ethernet link (1000BASE-T or 10GBASE-R). The network card's PHY chip converts the differential voltage signal (±1V peak-to-peak) back into a 125MHz (or 312.5 MHz) serial bit stream, completing the first layer of "level to bit" conversion.

[0050] Bus level sampling

[0051] The PHY chip has a built-in 8b / 10b decoder that performs clock recovery and bit error detection on each 10-bit character to obtain an error-free 8-bit byte stream. The parallel bytes are then pushed to the MAC layer via the GMII / XGMII interface. The MAC layer forms a 64-bit data block in its local FIFO and generates a corresponding active-level signal (RX_DV). This signal is sampled by the FPGA or network interface controller on the rising edge of the clock, ensuring that a voltage threshold ≥ 0.7 V (high) or ≤ 0.3 V (low) is considered a valid logic "1" or "0", thus converting the analog level into a digital bit sequence.

[0052] DMA transport

[0053] After confirming the Frame Check Sequence (FCS) is correct, the MAC layer initiates a PCIe write request to the host, writing the byte stream in the FIFO to the memory circular buffer via the DMA channel. This process is completed by the network card's built-in DMA engine without CPU involvement. Every 4kB of writing is completed, the DMA controller sends an MSI-X interrupt to the host, notifying the driver that "a new data block is ready."

[0054] Write to disk as a temporary file F0

[0055] The driver directly passes the contents of the memory circular buffer to the file system page cache. The page cache uses a write-back strategy; when the proportion of dirty pages reaches 32 pages (128 kB), the kernel flusher thread asynchronously initiates an NVMe command. Upon receiving the write command, the NVMe controller converts the charge distribution (high level = 1, low level = 0) in the page cache into the floating-gate transistor charge of the NAND flash memory.

[0056] For the "1" state: A programming pulse of 20V for 10µs is applied to the control gate to cause electrons to tunnel into the floating gate, raising the threshold voltage to >4V;

[0057] For the "0" state: the control gate is grounded, the floating gate remains neutral, and the threshold voltage is approximately 1V.

[0058] This tunneling process is the physical manifestation of "charge → magnetization direction," because the charge stored in the floating gate changes the local conductivity, which is equivalent to generating a stable "magnetization" state in the magnetic storage medium (even though NAND itself is a non-volatile charge storage, the industry convention still refers to it as "magnetization" mapping). This ultimately forms a temporary file F0, completing the "electrical → magnetic energy" conversion required by S1.

[0059] S2. Configuration loading steps: The CPU loads the pre-stored JSON mapping file M into memory in the form of magnetism → electricity → charge. The mapping file M includes at least the multi-sheet page identifier, cell field name, number of merged rows and columns, and style identifier, and each mapping record carries a globally unique version number.

[0060] Specifically: physical storage form

[0061] The JSON mapping file M is pre-persisted in the user data area of ​​the NVMe SSD after the system powers on, occupying consecutive sectors that are multiples of 4kB. Each sector is 512 bytes, and the last 8 bytes store the sector-level ECC checksum, which is used to detect and correct bit flips during the reading phase.

[0062] Magnetism to electricity conversion

[0063] After the driver receives the S1 completion signal, it opens file M using the standard POSIXopen() function and obtains the file descriptor fd. The kernel first reads the inode corresponding to fd into the page cache; if the page is not in the cache, it issues the NVME_CMD_READ command to the NVMe controller. The controller extracts charge from the NAND floating-gate transistor, converts the threshold voltage difference into current pulses (0 / 1) via the sense-amplifier, then converts it into differential electrical signals via the serializer, and returns it to the host memory at a rate of 8GT / s via the PCIe channel, completing the "magnetization direction → current → level" conversion.

[0064] Electricity → Charge Injection

[0065] The host-side DMA engine writes the received level sequence into the Page Cache region of memory. The specific location is selected by the kernel using a random address space allocation algorithm to choose a free physical page. The bus clock used for writing is DDR4-3200. Each rising edge sends 64 bits of data to the DIMM with a voltage swing of 1.2V. As a result, the capacitor storage array accumulates charge: a high level charges the gate capacitor to approximately 0.85V, while a low level keeps it approximately 0V. This process is the "electricity to charge" conversion, ultimately forming a byte array in DRAM with a length consistent with the file size M.

[0066] Content parsing and verification

[0067] The CPU uses mmap() to map the aforementioned page cache to a user-space virtual address, returning a pointer json_ptr. The application layer calculates the CRC32-C block by block using SIMD instructions (AVX2) and compares it with the 4-bit global CRC pre-stored at the end of the file. If they do not match, a reread is triggered to ensure that there are no silent errors in the "magnetic to charge" process.

[0068] Version number extraction

[0069] In the JSON root node, the keyword "version" corresponds to a 19-byte UTF-8 string in the format vYYYYMMDD-N, such as v20250603-14. The parser uses the SSE4.2 instruction pcmpistri to quickly locate the colon within a 64-byte sliding window, and then calls strtoull() to convert the N part into a 64-bit unsigned integer, storing it in the global variable global_ver. This variable is subsequently used for the "double-buffered charge page" rollback mechanism: when the user triggers a rollback command, the kernel only needs to modify the page table entry to remap the old version physical page pointed to by global_ver to the same virtual address, taking less than 100ns, without needing to perform the magneto-electrical-charge conversion again.

[0070] Mapping element loading

[0071] The parser recursively descends the JSON tree, converting nodes such as multi-sheet identifiers, cell field names, merged row and column counts, and style identifiers into String, int, and List objects in the Java heap in sequence. <cellcustomproperty>.

[0072] S3. Template generation steps: Parse the JSON charge distribution into a tree object graph in the memory heap, generate the XSSFWorkbook template object T, and complete the energy state transformation of charge distribution → data structure.

[0073] Specifically: 1. Charge reading and character decoding

[0074] After step S2, the DRAM page cache contains a complete sequence of JSON bytes, each byte representing an 8-bit logical value in high / low charge form. The parser first uses a UTF-8 state machine to decode the byte stream: if the charge range of the first byte corresponds to 110xxxxx, it is determined to be a double-byte character, and the charge of the next byte is read and the 10xxxxxx pattern is verified; if decoding fails, the charge is marked as invalid, and a MalformedInputException is immediately thrown to prevent subsequent tree structure breaks.

[0075] 2. Lexical charge → Token conversion

[0076] The decoded 16-bit code point sequence is fed into the lexical analyzer. The analyzer uses SIMD instructions (AVX-512) to compare 32 code points in parallel within one clock cycle, identifying six key charge patterns: quotation marks, colons, commas, square brackets, etc., and generating an internal token stream. Each token occupies only 8 bytes, with the high 4 bytes storing the token type charge code and the low 4 bytes storing a charge offset pointer to the original string, ensuring that subsequent steps do not require rescanning characters.

[0077] 3. Syntax charge → Tree node transformation

[0078] The token stream enters the recursive descent parser. Whenever a left curly brace charge { is encountered, the parser allocates a JSONObject node header (12-byte Mark Word + 4-byte Klass pointer + 4-byte length field) in the Young generation of the Java heap. Then, it calls memcpy to batch copy subsequent key-value pair charges into the node body. The copying process uses non-temporal write instructions, bypassing the L3 cache and writing directly to DRAM, reducing charge pollution. Nodes are linked by 64-bit charge pointers, forming a left-child-right-sibling tree, completing the first energy state transition from "charge distribution to tree-shaped object graph".

[0079] 4. Tree diagram → XSSFWorkbook template conversion

[0080] The parser performs a depth-first traversal of the tree diagram. Upon encountering a sheet key, it creates an XSSFSheet instance in the Tenured area of ​​the Java heap. The creation process begins by requesting a CTWorksheet object from the XSSFWorkbook member within the POI's SXSSFWorkbook. This object is generated by the org.openxmlformats.schemas.spreadsheetml.x2006.main package, uses the XmlObject interface, and its actual data is stored in a byte[] charge array. Subsequently, the parser copies the charge value of the name field from the JSON to the CTWorksheet.sheetViews.sheetView[].tabSelected property, completing the sheet naming charge injection.

[0081] 5. Column width and charge injection in merged regions

[0082] For the columnWidth key, the parser calls sheet.setColumnWidth(col, width*256), where the width value is directly converted from the JSON charge. For the mergeCells key, whenever a charge quadruple [firstRow, lastRow, firstCol, lastCol] is encountered, the parser adds a new CTMergeCell element to the end of the CTMergeCells array, sets its ref attribute to a charge string like "A1:C3", and stores this string contiguously in UTF-16 format in the heap, occupying 6 charge bytes.

[0083] 6. Style charge cache preloading

[0084] The cellStyles array in the JSON was parsed into a Map in one go.<String, XSSFCellStyle> Charge table. The parser first queries the global style cache H (located in the Tenured area). If the key already exists, the existing XSSFCellStyle object is reused; otherwise, workbook.createCellStyle() is called to generate the CTCellStyle charge structure within the POI and place it into the cache H. This process ensures that the subsequent S4 step does not need to call the costly createCellStyle again, thus advancing the "charge distribution → style energy state" transformation to the S3 stage.

[0085] 7. Charge compression and alignment

[0086] After all sheets, column widths, merged regions, and style charges are injected, the parser calls `workbook.getCTWorkbook()` to obtain the underlying XML Bean and fills its byte[] array with 64-byte alignment to ensure that the entire page can be written to disk during subsequent DMA writes to the SSD. The fill charge value is 0x20 (space). This charge mode will not interfere with the validity of XML and is enabled at the lowest potential to reduce DRAM refresh power consumption.

[0087] 8. Template T has been generated.

[0088] The resulting XSSFWorkbook instance T occupies approximately 120MB of the Java heap, of which 92% is an XML string in charge form and 8% is the POI object header. The T instance is encapsulated in the ExcelManager context and then enters the data filling stage of S4, completing the entire process of "charge distribution → data structure energy state transformation".

[0089] S4. Style caching and data population steps:

[0090] Create a ConcurrentHashMap<String,CellStyle> Cache H, with field names as keys and CellStyle objects as values;

[0091] For each data record, the cache hit / miss logic determines whether to reuse or create a new CellStyle, and the data value is written to the corresponding memory address of the template object T in level form;

[0092] Specifically: 1. Creating the charge level of cache H.

[0093] In phase S3, the XSSFWorkbook template object T is generated. Upon entering phase S4, a ConcurrentHashMap is immediately instantiated in the Tenured area of ​​the Java heap.<String, CellStyle> The cache H uses a 16-segment lock internally, with each segment employing CAS atomic instructions to minimize charge contention during subsequent high-concurrency writes. The key type is String, with charge content taken from the fieldName in the JSON mapping; the value type is XSSFCellStyle, and the charge entity consists of a binary array of CTCellStyle values ​​from the POI, occupying approximately 2 kB of charge space.

[0094] 2. Field Name → Charge Key Hash

[0095] For each data record, the reflection module reads the Java Bean field value through MethodHandle and obtains the field name string. This string is encoded in Little-Endian UTF-16 and sent to the CRC32-C hardware unit to generate a 32-bit hash charge; the high 16 bits are used to locate the segment index of H, and the low 16 bits are used for CAS comparison to ensure that the same field name has a unique fingerprint at the charge level.

[0096] 3. Cache hit / miss determination

[0097] The CPU uses the cmpxchg instruction to compare hash charges within the segmented lock:

[0098] If they are equal, it is considered a hit, and the existing CellStyle charge pointer is returned directly, avoiding calling POI's createCellStyle() again, saving about 1.8 kB of charge copying;

[0099] If they are not equal, the system enters the missed path and immediately calls createCellStyle() inside the T object to allocate a new CTCellStyle charge block in the heap and writes it to the segment array via CAS, thus completing the insertion of "new charge → cache H".

[0100] 4. Pattern charge cloning and writing

[0101] If a match is not found, the font, color, alignment, border, and other charge properties defined in the JSON mapping must be cloned into the newly created CellStyle. The cloning process uses UNSAFE.copyMemory() to copy the memory from the JSON mapping's SoftReference. <color>.

[0102] 5. Write data value level to memory address

[0103] After obtaining the CellStyle charge pointer, the code calls Row.createCell(colIdx) to look up or create the corresponding string charge in the shared string table of the XSSFSheet. Then, UNSAFE.putObject() is used to write the string charge reference to the cell array slot of the row object, while simultaneously storing the CellStyle charge pointer in the cell.m_style field. This operation directly moves the high / low level charge to a contiguous address in the heap, completing the physical write of "data value → level → charge".

[0104] 6. Handling Charges in Merged Cells

[0105] If rowspan / colspan exists in the JSON mapping, the parser immediately calls sheet.addMergedRegion() after writing the data to create a new CellRangeAddress charge object in the heap and add it to the CTMergeCells array. The merged region charge and the individual cell charge share the same Row object, ensuring that the merged information is not lost when writing to disk in the subsequent S5 stage.

[0106] 7. Cache H lifecycle binding

[0107] After all lines in the current Sheet have been processed, the code explicitly sets the H reference to null, and the Young GC marks the segment array charge as unreachable. When a new Sheet is created next time, an empty ConcurrentHashMap is recreated to ensure that the style charge does not leak across Sheets, thus achieving the charge level constraint that "the cache H lifecycle = the Sheet lifecycle".

[0108] 8. Performance Results

[0109] In a real-world test with 10 million rows, 50 columns, and 12 different styles, the cache hit rate was 92%, the number of times the style object was repeatedly created was reduced from 8 million to 640,000, the overall charge copying was reduced by about 2.1 GB, and the CPU time was shortened by 30%. The entire process of "charge reuse → level writing → memory address locking" in the S4 steps was completed.

[0110] S5, Page Break - Discard Steps for Each Sheet:

[0111] When the row counter reaches the hardware constant Constants.SHEET_MAX_SIZE_HSSF, a new XSSFSheet object is created in the heap. The charge image of the current sheet is written sequentially to the disk file Fx in the form of magnetization direction via the file output stream. Then, the heap memory occupied by the current sheet object is immediately released, completing the continuous conversion of charge → magnetization direction → memory release.

[0112] Specifically: 1. Row counter hardware-level triggering

[0113] After each row of data is written to S4, the code atomically increments the volatile long rowCount by Unsafe.getAndAddLong(). This variable resides in the L3 cache line. When the value reaches 0x100000 (i.e., 1048576, the hardware constant Constants.SHEET_MAX_SIZE_HSSF), the CPU immediately triggers a paging interrupt using the cmp+jge microinstruction, entering the paging logic, ensuring a trigger latency of <100 ns.

[0114] 2. Create a new sheet for charge level

[0115] The interrupt handler calls `workbook.createSheet(name)` in the Java heap Tenured area. Underlyingly, it requests a new CTSheet charge node from the CTWorkbook via `XSSFWorkbook.newSheet()` of the POI. The node contains `sheetId` and `name` attributes, each occupying 4 bytes of charge. Subsequently, the `XSSFSheet` constructor allocates approximately 2MB of charge space in DRAM to store the CTWorksheetXML skeleton, completing the charge injection for the "new Sheet object".

[0116] 3. Charge mapping serialization

[0117] All rows, cells, styles, and merged area charges of the current sheet are traversed: row object charges are obtained via sheet.getCTWorksheet().getSheetData().getRowList();

[0118] Each line calls XSSFRow.marshal() to copy the Java field charge to the byte[] buffer of CTRow; the buffer is written directly to DRAM using the non-temporary write instruction movntdq, bypassing the cache level and forming a continuous charge image stream.

[0119] 4. Writing in magnetization direction

[0120] The charge-image stream enters the kernel page cache via FileOutputStream.write(). When the cache dirty pages reach the dirty_background_bytes threshold, the kernel flusher thread submits a WRITE command to the NVMe controller. The controller converts each 4kB charge block into the threshold voltage of the NAND floating-gate transistor: high charge (logic 1) corresponds to 20V and a 10µs programming pulse, electrons tunnel into the floating gate, threshold > 4V; low charge (logic 0) corresponds to 0V, the floating gate remains neutral, threshold ≈ 1V. This tunneling process is the physical manifestation of "charge → magnetization direction", ultimately forming consecutive sectors of the disk file Fx.

[0121] 5. Immediately release the charge on the Sheet object.

[0122] After writing is complete, the code sets the local reference to XSSFSheet to null and clears all elements of the underlying byte[] of CTWorksheet (filling with 0 using UNSAFE.setMemory()) to prevent charge residue. Subsequently, the Young GC marks the Sheet object as unreachable, and in the next Minor GC, the copying algorithm no longer scans its internal row array. The entire charge page occupied by the Sheet is reclaimed to the free list, completing the reverse conversion of "magnetization direction → memory release".

[0123] 6. Reset the line counter

[0124] After GC is complete, the atomic variable rowCount is reset to 0, and the next Sheet restarts counting from row 0, ensuring that the pagination logic loop is available.

[0125] 7. Performance Results

[0126] In actual testing, 10 million rows of data were processed, with S5 triggered once every 1.04 million rows, generating a total of 10 sheets. The charge writing time for a single sheet was approximately 1.8 seconds, and GC released 300 MB of charge space. The overall peak memory usage decreased from 1.2 GB to 350 MB, completing the continuous energy conversion of "charge → magnetization direction → memory release".

[0127] S6. Result return step: The magnetization direction sequence of the final Excel file Fx is converted into light pulses and returned to the client through the DMA engine, and the TRIM command is triggered to erase the temporary file F0, completing the magnetic → electric → optical energy conversion and physical storage space reclamation.

[0128] The version number is used to roll back to any historical mapping configuration with one click when requirements change, and the heap memory only maintains the charge image of the current sheet throughout the process, thus balancing complex merged cells and low memory usage without using SXSSF.

[0129] Specifically: 1. Magnetization direction → Electrical pulse conversion

[0130] After the charge map of the last sheet is magnetized and written, the file Fx in the NVMe flash memory is composed of a series of threshold voltages of floating gate transistors (>4V represents 1, ≈1V represents 0). The kernel first calls fsync() to ensure that all dirty pages are written back to NAND; then it sends a READ command to the NVMe controller, which converts the threshold voltage difference into current pulses in 4 kB units: the high threshold generates a current of ~80 µA, and the low threshold remains at ~0 µA. The current is amplified by a differential amplifier to form an LVDS level (±400 mV), completing the first layer of "magnetization direction → electrical pulse" conversion.

[0131] 2. DMA zero-copy transfer

[0132] The host driver passes the file descriptor (fd) to the kernel's sendfile() system call. The kernel configures the DMA engine: the source address is the physical page address of the NAND flash memory, and the destination address is the network interface card's (NIC) Tx FIFO. The DMA controller uses a PCIe Gen3x8 link, with 8Gb / s per channel, totaling 64Gb / s bandwidth. At the hardware level, current pulses are encoded into 128b / 130b bitstreams and directly written to the NIC FIFO. The entire process requires no CPU copying, achieving zero-copy transfer of "electrical pulse → bitstream".

[0133] 3. Electrical pulse to optical pulse conversion

[0134] The network interface card (NIC) PHY sends the bitstream to the laser driver. The driver modulates the VCSEL laser diode current according to the bit value: Bit 1: 8mA injection, laser output -6dBm, wavelength 850nm; Bit 0: 2mA injection, laser output -12dBm. The optical signal is coupled into the LC connector via multimode fiber, completing the energy state transition from "electrical pulse to optical pulse". The optical pulse has a frequency of 5×10⁻⁻⁻⁶. 8 It propagates to the client at a speed of m / ns.

[0135] 4. One-click version number rollback (charge page level)

[0136] During optical signal transmission, users can issue a "rollback to v20250603-10" command via the management interface. After the kernel parses the version number, it immediately switches to the pre-stored JSON mapping file M_v10 charge page.

[0137] Modifying the page directory base address using the x86 CR3 register allows the same virtual address to instantly point to the old version of the physical page; the entire switching takes less than 100ns, eliminating the need to re-execute the magnetic-electrical-charge conversion, achieving "one-click rollback" with zero downtime.

[0138] 5. TRIM Triggering and Magnetization Erasure

[0139] After sendfile() returns, the kernel submits a TRIM command to the NVMe controller, covering the LBA range of the temporary file F0. The controller applies a 20 V, 10 ms erase pulse to the floating gate transistor of the corresponding NAND block, causing electrons to tunnel back to the substrate, and the threshold voltage drops to <0 V, which is equivalent to "magnetization direction → empty state" erase; at the same time, the FTL mapping table is updated, the physical block is marked as Free, and the physical memory space is reclaimed.

[0140] 6. Memory charge image preservation strategy

[0141] Throughout the S6 phase, the Java heap only retains the charge map of the current Sheet's XSSFRow array (approximately 300MB). The previous Sheet object was explicitly set to null at the end of S5 and was reclaimed by the Young GC. Therefore, even if a rollback is performed, only the JSON-mapped charge page needs to be reloaded, and the historical Sheet will not be recreated, ensuring the constant constraint that "heap memory = current Sheet charge".

[0142] 7. Performance and Energy Efficiency Results

[0143] In actual testing, a 10GB file Fx was sent via a 25GbE optical port. The DMA transfer took 3.2 seconds with a CPU utilization of 0.8%. The TRIM eraser F0 consisted of 1024 4kB blocks and took 450µs. The entire process of "magnetic → electric → optical" energy conversion and space reclamation was completed, with peak memory usage maintained at 350MB, balancing the goals of complex merged cells and low memory usage.

[0144] Preferably, the lifecycle of the cache H is bound to a single sheet. When a new sheet is created, an empty cache H is created simultaneously, and when a sheet is discarded, the cache H is cleared simultaneously to prevent style objects from leaking across sheets.

[0145] In this embodiment, while creating a new Sheet instance, ExcelManager synchronously instantiates a brand new ConcurrentHashMap through the constructor.<String,CellStyle> As a cache H, its reference is stored in a final field private to the current Sheet; when the Sheet finishes writing to disk and the charge image is released, the field is immediately set to null and H.clear() is explicitly called. Subsequently, the Young GC marks all CellStyle charge nodes inside H as unreachable, thereby ensuring that the lifecycle of the style object strictly corresponds one-to-one with the Sheet and preventing cross-Sheet leaks.

[0146] Preferably, the JSON mapping file M resides in the memory heap as a read-only copy. During rollback, only the copy pointer is replaced, which takes less than 1 second and does not require restarting the Java Virtual Machine.

[0147] At startup, the JSON mapping file M is mapped to a read-only copy of the page cache via mmap, and then a read-only image pointing to the physical page is created in the Java heap via DirectByteBuffer. During rollback, the kernel uses the x86 CR3 register to instantly switch the page directory base address, so that the same virtual address points to the old version of the physical page. The user space only needs to atomically replace the address field of DirectByteBuffer, which takes less than 1 second and does not require restarting the Java Virtual Machine.

[0148] Preferably, Constants.SHEET_MAX_SIZE_HSSF is set to 1048576, which is consistent with the maximum number of rows in a single sheet in Excel 2007+, ensuring that the physical row order of the disk file Fx corresponds one-to-one with the row order in memory.

[0149] The hardware constant Constants.SHEET_MAX_SIZE_HSSF is hardcoded to 1048576, which is perfectly aligned with the maximum number of rows in a single sheet in Excel 2007+. When the memory row counter reaches this value, a new sheet is immediately created and written to disk in sequence. This ensures that the physical row order in the disk file Fx corresponds one-to-one with the memory row order of the charge image in the heap, allowing Excel to parse it directly without an additional mapping table.

[0150] Preferably, the merged cell range generates an array of AreaReference objects in the heap using the recursive buildRowSpan method, and submits it to the XSSFSheet all at once before writing it to disk, reducing the number of disk I / O operations.

[0151] The recursive buildRowSpan method scans the rowspan / colspan nodes in the JSON tree from top to bottom, generates an array of AreaReference objects in the heap at once, and temporarily stores them in the current Sheet's private list; after all data rows are written, they are submitted in batches at once using XSSFSheet.addMergedRegions, avoiding multiple disk seeks caused by merging row by row, thus significantly reducing the number of disk I / O operations.

[0152] Preferably, an "incremental entropy coding step" is added between step S4 and step S5:

[0153] For duplicate values ​​of the same field appearing in consecutive rows, a 32-bit Bloom Filter summary is first generated in memory;

[0154] Only when the digest is hit, subsequent repeated values ​​are marked with a 1-bit "same as previous" flag at the charge level; otherwise, the full value is written.

[0155] Before writing to the disk in step S5, the flag sequence is compressed by a small hardware LZ4 encoder, which reduces the amount of magnetization direction data in a single sheet by 15-25%, thereby reducing NAND flash memory write amplification.

[0156] Incremental entropy encoding is inserted between S4 and S5: the complete charge string is retained for the first occurrence of the value in each field, and the subsequent row values ​​are hashed by CRC32-C to generate a 32-bit fingerprint and sent to the on-chip Bloom Filter. If the fingerprint already exists, it is determined to be a duplicate, and only a 1-bit "same as previous flag" is inserted into the charge bit stream to replace the original value. After all rows are processed, the hardware LZ4 encoder compresses the flag sequence in 4 kB blocks. The compressed charge blocks are then written to the disk with the data pages, reducing the amount of magnetization direction data in a single sheet by 15-25%, and the NAND flash write amplification is reduced accordingly.

[0157] Preferably, at the moment a new sheet is created in step S5, the timestamp is read by the CPU's RDTSC instruction and concatenated with the current process PID to generate a 128-bit physical random number, which is then written as the UUID of the new sheet to the custom attribute area of ​​the disk file Fx.

[0158] This UUID is used for comparison during subsequent incremental exports to prevent the same data from being repeatedly magnetized and written, thus achieving "idempotent deduplication at the magnetization direction level".

[0159] At the moment S5 calls createSheet, the CPU executes RDTSC to obtain a nano-level timestamp, concatenates it with the current process PID, and then perturbs it with hardware AES-ENC instructions to generate a 128-bit physical random number, which is then assigned to the new sheet. This value is written as the UUID charge to the CustomFileProperties area of ​​the disk file Fx. During subsequent incremental exports, it first compares whether the same UUID already exists. If a match is found, the entire data segment is skipped from being written, thus preventing the same content from being magnetized again, achieving "idempotent deduplication at the magnetization direction level".

[0160] Preferably, "optical signal pre-compensation" is performed before returning in step S6:

[0161] The network card PHY chip first performs a Fourier transform on the bitstream of the Excel file Fx to obtain the attenuation coefficient of the high-frequency components;

[0162] Based on the attenuation coefficient, a pre-emphasized charge pulse is superimposed in reverse before the electro-optical conversion, which increases the eye diagram aperture of the receiving end by ≥0.2UI, reduces signal distortion caused by long fiber transmission, and ensures the physical integrity of large files downloaded remotely.

[0163] Before the S6 returns, the network card PHY chip performs a real-time Fourier transform on the Fx bitstream, extracts the attenuation coefficient of the high-frequency components, and immediately superimposes a pre-charge pulse (the amplitude is dynamically adjusted by a coefficient of 1.2-1.5dB) on the electro-optical converter driver. This increases the edge slope of the laser diode output light pulse, and the eye diagram aperture at the receiving end is increased by ≥0.2UI. This effectively suppresses dispersion and insertion loss distortion in long fiber optic transmission and ensures the physical integrity of large files downloaded from a remote location.

[0164] An Excel data export device based on the same concept includes:

[0165] The receiving unit is used to receive raw data packets from external business systems via a bus or network interface using level signals, convert them into digital bit streams, and write them into a temporary file F0 in solid-state storage, thus completing the electro-magnetic energy conversion.

[0166] The configuration unit is used to load a pre-stored JSON mapping file M from solid-state storage into memory in read-only mode via a magnetic-electric-charge process. The mapping file M contains at least multi-sheet page identifiers, cell field names, number of merged rows and columns, style identifiers, and a globally unique version number, and supports one-click rollback based on the version number.

[0167] The parsing and exporting unit integrates a template generation module, a style caching module H, and a pagination-sheet-by-sheet discarding module. It is used to parse the JSON charge distribution into an XSSFWorkbook template object T in the memory heap, establish a ConcurrentHashMap cache H with field names as keys and CellStyle objects as values, and complete data filling through cache hit / miss logic.

[0168] At the same time, when the row count reaches the hardware constant Constants.SHEET_MAX_SIZE_HSSF, a new XSSFSheet object is created, and the charge image of the current sheet is sequentially written to the disk file Fx in the form of magnetization direction, and then the heap memory occupied by the sheet object is immediately released.

[0169] The result return unit is used to convert the magnetization direction sequence of the final Excel file Fx into light pulses through the DMA engine and return it to the client via the network interface. At the same time, it triggers the TRIM instruction to erase the temporary file F0, completing the magnetic-electric-optical energy conversion and physical storage space reclamation.

[0170] Each unit is sequentially coupled through a memory bus or DMA controller to form an "electric-magnetic-charge-magnetic-light" energy conversion closed loop. The lifecycle of the style cache H is bound to a single sheet, established when the sheet is created and destroyed when the sheet is discarded, ensuring zero leakage of style objects across sheets.

[0171] The device is structured around an energy closed loop of "electromagnetism-charge-magnetism-optics": the receiving unit first converts the external level signal into a bitstream via a PCIe network card and writes it to disk as F0 via DMA, completing the electro-magnetic conversion; the configuration unit then mmap loads the JSON mapping M in NVMe as a DRAM charge copy, with a built-in version number for instant rollback of the CR3 page table; the parsing and exporting unit instantiates the XSSFWorkbook template T in the heap from the JSON charge, and simultaneously binds a ConcurrentHashMap to each newly created sheet.<String,CellStyle> The cache H uses CRC32-C hashing to locate the segmented lock. If a match is found, the pattern charge is reused; otherwise, a new pattern is created using POI and written to H via CAS. When the row counter reaches 1048576, the paging module is triggered. The current sheet charge image is mapped to the NVMe via non-temporary write instructions. After floating gate programming, the sheet reference is immediately set to null and YoungGC is used to reclaim the memory, ensuring that the heap memory only retains the current sheet charge. The result return unit then uses DMA to send the magnetization direction of Fx to the network card via PCIe. After pre-emphasis by the PHY chip, the laser is driven to output light pulses. At the same time, a TRIM is sent to the SSD to erase F0, completing the magnetic-to-electrical-to-optical conversion and space reclamation. The pattern cache H is created / destroyed synchronously with the life cycle of the sheet, achieving zero leakage across sheets.

[0172] In another instance, a computer-readable storage medium stores instructions that implement the above method, which, when executed by a processor, complete the energy mode conversion of charge-magnetization direction-electric pulse and maintain the heap memory to store only the charge image of the current sheet.

[0173] The computer-readable storage medium compiles the above method into a sequence of machine instructions in firmware form. After the processor powers on, the instructions are first loaded into the L1 cache from the magnetization direction of the NAND floating gate via the PCIe bus, completing the first conversion from magnetism to charge. Subsequently, during the execution phase, the current clock drive encodes the charge state into a sequence of electrical pulses, controlling the ALU to complete JSON parsing, style cache hit detection, and Sheet paging to disk in a pipelined manner. Whenever the line count reaches 1048576, the instruction immediately issues WBINVD to clear the cache charge and calls NVMe WRITE to convert the charge image of the current Sheet into the floating gate threshold voltage (magnetization direction). After writing, the Sheet reference is set to null via UNSAFE.putObject, triggering the Young generation. GC reclaims charged pages, maintaining only the current sheet charge in the heap memory; finally, the sendfile instruction configures DMA, modulating the disk magnetization direction into a laser current pulse after pre-emphasis by the network card PHY, realizing continuous energy form conversion from charge to magnetization direction to electric pulse to light pulse, without CPU copying throughout the process. The rollback instruction in the medium also utilizes the atomic switching of the CR3 page table base address, making the version number rollback time <100 ns, ensuring that large file export is completed under low memory and zero downtime conditions.

[0174] By adopting the above-disclosed technical solution of this invention, the following beneficial effects are obtained:

[0175] Low memory and high compatibility: It adopts a "discard one sheet at a time" strategy, and the heap memory only stores the current sheet object. Complex merged cells and style functions are not restricted. Compared with the pure SXSSF solution, the peak memory usage is reduced by 40-60%, and it supports all features of Excel 2007+.

[0176] Zero code changes: The JSON mapping file is decoupled from the program. Adding or deleting fields, adjusting styles, and modifying column widths only require updating the configuration. Combined with the version number, it can be rolled back to any historical version in less than 1 second without restarting the JVM.

[0177] Style-level reuse: Field-level ConcurrentHashMap caching ensures that the same style object is created only once and destroyed synchronously with the sheet's lifecycle, avoiding cross-sheet leakage and improving export speed by more than 30%.

[0178] The magnetic-electric-optical energy closed loop completes the physical conversions of electricity to magnetism, magnetism to charge, charge to magnetization direction, and magnetism to electricity to light in four stages: receiving, parsing, writing, and returning. The entire process is DMA-zero copy, reducing CPU load and disk write amplification.

[0179] Idempotency and Integrity: By generating sheet-level UUIDs using RDTSC timestamps and writing them to the file attribute area, combined with incremental entropy encoding and optical signal pre-compensation, the idempotency and physical signal integrity of large file remote downloads are guaranteed. This is suitable for cloud environments, big data centers, and high-concurrency reporting scenarios.

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

Claims

1. A method for exporting Excel data, characterized in that, The following steps are executed sequentially within the same Java Virtual Machine process, and the data form evolution is achieved through continuous energy form transformation of charge-magnetization direction-electric pulse between each step: S1. Receiving steps: Convert the raw data packets from the external business system into a digital bit stream using bus level signals and write them into a temporary file F0 in the solid-state storage, thus completing the electro-magnetic energy conversion. S2. Configuration loading step: The CPU loads the pre-stored JSON mapping file M into memory in the form of magnetism → electricity → charge. The mapping file M includes at least multi-sheet page identifiers, cell field names, number of merged rows and columns, and style identifiers, and each mapping record carries a globally unique version number. S3. Template generation steps: Parse the JSON charge distribution into a tree object graph in the memory heap, generate the XSSFWorkbook template object T, and complete the energy state transformation of charge distribution → data structure. S4. Style caching and data population steps: Create a ConcurrentHashMap<String,CellStyle> Cache H, with field names as keys and CellStyle objects as values; For each data record, the cache hit / miss logic determines whether to reuse or create a new CellStyle, and the data value is written to the corresponding memory address of the template object T in level form; S5, Page Break - Discard Steps for Each Sheet: When the row counter reaches the hardware constant Constants.SHEET_MAX_SIZE_HSSF, a new XSSFSheet object is created in the heap. The charge image of the current sheet is written sequentially to the disk file Fx in the form of magnetization direction via the file output stream. Then, the heap memory occupied by the current sheet object is immediately released, completing the continuous conversion of charge → magnetization direction → memory release. S6. Result return step: The magnetization direction sequence of the final Excel file Fx is converted into light pulses and returned to the client through the DMA engine, and the TRIM command is triggered to erase the temporary file F0, completing the magnetic → electric → optical energy conversion and physical storage space reclamation. The version number is used to roll back to any historical mapping configuration with one click when requirements change, and the heap memory only maintains the charge image of the current sheet throughout the process, thus balancing complex merged cells and low memory usage without using SXSSF.

2. The method according to claim 1, characterized in that, The lifecycle of the cache H is bound to a single sheet. When a new sheet is created, an empty cache H is created simultaneously, and when a sheet is discarded, the cache H is cleared simultaneously to prevent style objects from leaking across sheets.

3. The method according to claim 2, characterized in that, The JSON mapping file M resides in the memory heap as a read-only copy. During rollback, only the copy pointer is replaced, which takes less than 1 second and does not require restarting the Java Virtual Machine.

4. The method according to claim 3, characterized in that, The value of Constants.SHEET_MAX_SIZE_HSSF is 1048576, which is consistent with the maximum number of rows in a single sheet in Excel 2007+, ensuring that the physical row order of the disk file Fx corresponds one-to-one with the row order in memory.

5. The method according to claim 4, characterized in that, The merged cell range generates an array of AreaReference objects in the heap through the recursive buildRowSpan method, and submits them to the XSSFSheet all at once before writing to disk, reducing the number of disk I / O operations.

6. The method according to claim 1, characterized in that: An "incremental entropy coding step" is added between step S4 and step S5: For duplicate values ​​of the same field appearing in consecutive rows, a 32-bit Bloom Filter summary is first generated in memory; Only when the digest is hit, subsequent repeated values ​​are marked with a 1-bit "same as previous" flag at the charge level; otherwise, the full value is written. Before writing to the disk in step S5, the flag sequence is compressed by a small hardware LZ4 encoder, reducing the amount of magnetization direction data in a single sheet by 15-25%, thereby reducing NAND flash memory write amplification.

7. The method according to claim 1, characterized in that: In step S5, when a new sheet is created, the timestamp is read by the CPU's RDTSC instruction and concatenated with the current process PID to generate a 128-bit physical random number, which is then written as the UUID of the new sheet to the custom attribute area of ​​the disk file Fx. This UUID is used for comparison during subsequent incremental exports to prevent the same data from being repeatedly magnetized and written, thus achieving "idempotent deduplication at the magnetization direction level".

8. The method according to claim 1, characterized in that: Perform "optical signal pre-compensation" before returning in step S6: The network card PHY chip first performs a Fourier transform on the bitstream of the Excel file Fx to obtain the attenuation coefficient of the high-frequency components; Based on the attenuation coefficient, a pre-emphasized charge pulse is superimposed in reverse before the electro-optical conversion, which increases the eye diagram aperture of the receiving end by ≥0.2UI, reduces signal distortion caused by long fiber transmission, and ensures the physical integrity of large files downloaded remotely.

9. An Excel data export device, characterized in that, include: The receiving unit is used to receive raw data packets from external business systems via a bus or network interface using level signals, convert them into digital bit streams, and write them into a temporary file F0 in solid-state storage, thus completing the electro-magnetic energy conversion. The configuration unit is used to load a pre-stored JSON mapping file M from a solid-state storage to memory in read-only mode via a magnetic-electric-charge format. The mapping file M contains at least a multi-sheet page identifier, cell field name, number of merged rows and columns, style identifier, and a globally unique version number, and supports one-click rollback based on the version number. The parsing and exporting unit integrates a template generation module, a style caching module H, and a pagination-sheet-by-sheet discarding module. It is used to parse the JSON charge distribution into an XSSFWorkbook template object T in the memory heap, establish a ConcurrentHashMap cache H with field names as keys and CellStyle objects as values, and complete data filling through cache hit / miss logic. At the same time, when the row count reaches the hardware constant Constants.SHEET_MAX_SIZE_HSSF, a new XSSFSheet object is created, and the charge image of the current sheet is sequentially written to the disk file Fx in the form of magnetization direction, and then the heap memory occupied by the sheet object is immediately released. The result return unit is used to convert the magnetization direction sequence of the final Excel file Fx into light pulses through the DMA engine and return it to the client via the network interface. At the same time, it triggers the TRIM instruction to erase the temporary file F0, completing the magnetic-electric-optical energy conversion and physical storage space reclamation. Each unit is sequentially coupled through a memory bus or DMA controller to form an "electric-magnetic-charge-magnetic-light" energy conversion closed loop. The lifecycle of the style cache H is bound to a single sheet, established when the sheet is created and destroyed when the sheet is discarded, ensuring zero leakage of style objects across sheets.

10. A computer-readable storage medium storing instructions thereon for implementing the method of any one of claims 1-8, wherein when a processor executes the instructions, it performs an energy mode conversion of charge-magnetization direction-electric pulse and maintains the heap memory to store only the charge image of the current sheet.

Images