Method and device for implementing IO stream data partition verification of database based on JAVA
By using dynamic block partitioning and sliding window caching mechanisms, combined with embedded verification tags, the real-time performance and positioning accuracy issues of existing data verification methods are resolved, resulting in a high-efficiency, low-consumption data verification system suitable for file transfer and cloud storage scenarios.
Patent Information
- Application Number
- CN202511402341.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-09-28
- Publication Date
- 2025-12-12
AI Technical Summary
Existing data verification methods cannot meet the requirements of real-time performance, large file processing capabilities, and positioning accuracy, resulting in the system's inability to correct errors in real time, the risk of memory overflow during large file verification, and high repair costs.
A Java-based IO stream data partitioning verification method is adopted, which realizes real-time error detection and accurate location of data stream through dynamic block processing, sliding window caching mechanism and embedded verification flags.
It achieves real-time data verification, low memory usage, and high-precision positioning, reducing system latency and repair costs, and supporting efficient processing of large files.
Smart Images
Figure CN121116705A_ABST
Abstract
Description
TECHNICAL FIELD
[0001] The present application relates to the technical field of data verification, and in particular to an IO stream data partition verification method and device based on JAVA for realizing a database. BACKGROUND
[0002] The background of I / O stream data verification originates from the core requirement for data integrity and accuracy in the data transmission process. Early file transmission only relied on basic IO operations (such as FileInputStream), and lacked a verification mechanism, which led to data damage when the network fluctuated or the storage medium failed. For example, when transmitting a 10MB file, part of the data packet may be lost due to TCP packeting, and this cannot be detected. Initially, file size comparison or last modification timestamp was used for data verification, but this method can only detect whether data is missing and cannot detect whether the content has been tampered with. Later, MD5 / SHA-1 hash value verification was introduced to solve the content-level consistency verification problem, and block CRC32 verification was developed for large files to achieve local error positioning. However, these data verification methods cannot locate the specific damaged block.
[0003] There are three main problems with current data verification methods: first, the verification delay is high, as the hash value needs to be calculated based on the full amount of data, which makes it impossible to implement real-time error correction; second, the memory usage is large, and the full-load file method severely limits the processing capacity of large files; finally, the positioning accuracy is low, and the overall verification mode cannot accurately locate the damaged position. These defects have serious consequences: high delay makes the system unable to discover and correct errors in real time during transmission; large memory usage makes large file verification face the risk of memory overflow; and low positioning accuracy significantly increases the data repair cost, as full retransmission or repair is required.
[0004] Therefore, the existing data verification method cannot meet the current requirements for verification real-time, large file processing capacity, and positioning accuracy, which is not conducive to the integrity and accuracy of data transmission. SUMMARY
[0005] The embodiments of the present application provide an IO stream data partition verification method and device based on JAVA for realizing a database, which is used to solve the technical problem that the existing data verification method cannot meet the current requirements for verification real-time, large file processing capacity, and positioning accuracy.
[0006] The embodiments of the present application adopt the following technical solutions: On the one hand, the embodiments of the present application provide an IO stream data partition verification method based on JAVA for realizing a database, which comprises: obtaining an IO input stream to be verified; wherein the IO input stream is a data stream in which external data is read into memory or memory data is output to a storage device; The IO input stream is dynamically divided into a plurality of target data blocks, and the size of the target data block can be adaptively adjusted according to the data stream content. A preset check algorithm is used to generate a corresponding binding check code for the target data block, and an embedded check mark is added to each target data block; wherein the embedded check mark contains the position identification of the target data block and the inter-block association information. Based on the sliding window buffer mechanism, the target data block is processed through a fixed-size ring memory buffer. According to the actual check code of the target data block and the binding check code, it is judged whether the target data block is damaged. If there is a damaged data block, the specific damaged data block is located based on the embedded check mark.
[0007] In a feasible implementation, the IO input stream is dynamically divided into a plurality of target data blocks, and the size of the target data block can be adaptively adjusted according to the data stream content, specifically including: A sliding window processor is constructed based on JAVA, and the window buffer, current position pointer and fingerprint calculation parameters of the sliding window processor are initialized; the size of the window buffer is preset according to the data stream processing requirement; When the bytes of the IO input stream are sequentially input into the sliding window processor, the window buffer is updated and the current fingerprint is calculated; The oldest byte in the window buffer is removed, the influence of the old byte on the current fingerprint is calculated and the old byte is removed from the current fingerprint, and then the newly input byte is added to the window buffer, and the updated current fingerprint is recalculated; A preset fingerprint matching condition is set, when the updated current fingerprint meets the fingerprint matching condition, the data stream before the current window buffer is divided into an independent data block, and the cycle is repeated until the IO input stream is divided.
[0008] In a feasible implementation, for the target data block, a preset check algorithm is used to generate a corresponding binding check code, specifically including: For each target data block, the CRC32 check algorithm interface of JAVA is called, the unique check code is calculated based on the byte content of the target data block, and the check code is bound with the corresponding target data block to form a binding check code; A plurality of check threads are started, each thread is responsible for processing the check code generation of one or more target data blocks, and the number of threads is dynamically adjusted according to the CPU core number.
[0009] In a feasible implementation, the position identification of the embedded check mark contains the starting byte offset, the ending byte offset and the data block number of the target data block in the IO input stream. The inter-block association information is a dependent value obtained by associatively calculating the check code of the current target data block and the check code of the previous target data block, so that the current target data block and the previous target data block form a check dependent chain, and the continuity check of the data stream is ensured.
[0010] In a feasible implementation, the target data block is processed by a fixed-size ring memory buffer based on a sliding window buffer mechanism, and specifically includes the following steps. A fixed-size ring memory buffer is constructed based on a JAVA ByteBuffer, the ring memory buffer includes a read pointer, a write pointer, a flag bit and a fixed capacity, and thread safety of data reading and writing is realized by a synchronization lock; The type of the ring memory buffer is selected according to the hardware resource configuration: if the IO performance needs to be improved, a direct buffer is selected; if the memory management needs to be simplified, a heap buffer is selected; When data is written, the target data block is written into the ring memory buffer through the write pointer, and when the write pointer reaches the end of the ring memory buffer, the write pointer is circularly moved to the start position of the ring memory buffer for continuous writing; When data is read, the current target data block to be processed is loaded from the ring memory buffer through the read pointer, and the read pointer is moved after reading is completed; the sliding window is marked and reset through the flag bit to record the sliding position of the window.
[0011] In a feasible implementation, the method further includes the following steps. The memory occupation of the ring memory buffer is monitored in real time, and the memory usage is calculated; When the memory usage is higher than a preset safety threshold, the capacity of the ring buffer is automatically reduced to reduce the memory occupation; When the memory usage is lower than the preset safety threshold, the initial capacity of the ring buffer is restored to ensure the data processing efficiency.
[0012] In a feasible implementation, whether the target data block is damaged is judged according to the actual check code of the target data block and the binding check code, and specifically includes the following steps. The target data block taken out of the ring memory buffer is transmitted to a check comparison module, and the actual check code of the target data block is compared with the binding check code in the check comparison module; If the two are consistent, the target data block is not damaged; If the two are inconsistent, it is judged that the target data block is damaged.
[0013] In a feasible implementation, if there is a damaged data block, the specific damaged data block is located based on the embedded check flag, and specifically includes the following steps. calculating a full volume check code of the IO input stream and comparing it with a preset standard full volume check code; if the two are consistent, determining that there is no damaged data block and returning an empty list; If the two are inconsistent, dividing the IO input stream into multiple regions, obtaining a standard region check code and an actual region check code of each region, comparing whether the two are consistent, and screening out abnormal regions with inconsistent check codes; Traversing each abnormal region, obtaining the binding check code and the actual block check code of all target data blocks in the region, and comparing whether the two are consistent; Recording the data block numbers with inconsistent check codes, forming a damaged data block list and returning, and completing the accurate positioning of the damaged data block.
[0014] In a feasible implementation, if there is a damaged data block, after locating the specific damaged data block based on the embedded check mark, the method further comprises: If there is no damaged data block, integrating the target data blocks that pass the verification into an IO output stream, and completing the partition verification of the IO input stream data; If there is a damaged data block, integrating the target data blocks that pass the verification into an IO output stream, and returning the damaged data block list to the user after binding.
[0015] On the other hand, the embodiment of the present application also provides an IO stream data partition verification device for a database based on JAVA, which comprises: at least one processor; and a memory in communication connection with the at least one processor; wherein the memory stores instructions executable by the at least one processor, so that the at least one processor can execute: obtaining an IO input stream to be verified; wherein the IO input stream is a data stream of external data read into memory or memory data output to a storage device; performing dynamic block processing on the IO input stream to divide the continuous data stream into multiple target data blocks; the size of the target data block can be adaptively adjusted according to the data stream content; for the target data block, a preset check algorithm is used to generate a corresponding binding check code, and an embedded check mark is added to each target data block; wherein the embedded check mark contains the position identification of the target data block and the inter-block association information; based on a sliding window caching mechanism, the target data block is processed through a fixed-size ring memory buffer; judging whether the target data block is damaged according to the actual check code of the target data block and the binding check code; If there is a damaged data block, then locate the specific damaged data block based on the embedded check mark.
[0016] Compared with the prior art, the IO stream data partition verification method and device based on JAVA to realize the database provided by the embodiment of the application have the following beneficial effects: In view of the defects existing in the prior data stream check technology, the application proposes three innovative countermeasures: Firstly, the dynamic block check technology is adopted to divide the data into blocks that can be independently checked, so as to realize real-time error detection; then the sliding window buffer mechanism is introduced to process the data stream through the fixed-size memory window, so as to break through the memory limit of large files; finally, the embedded check mark system is designed to attach the check information to each data block, so as to realize accurate positioning of the damaged position. These technologies jointly constitute a new type of data check system with high efficiency, low consumption and high accuracy.
[0017] In view of the pain points of the traditional IO stream data verification, the application realizes multi-dimensional technical breakthrough through the core technologies such as dynamic block, sliding window buffer and embedded check mark: the data blocks can be independently checked without waiting for the full data, and the multi-thread parallel check is also supported, so as to realize real-time error detection. The sliding window relies on the ring buffer to only cache the current data block to be processed, and in combination with the dynamic window shrinkage strategy, the risk of memory overflow is avoided. The embedded check mark contains the data block position and associated information, the hierarchical positioning algorithm first finds the abnormal area and then locks the damaged block, so as to reduce the repair cost. The application can be widely applied to file transmission, cloud storage check and other scenes, and has advanced technology and practical application value. BRIEF DESCRIPTION OF DRAWINGS
[0018] In order to more clearly illustrate the technical solutions in the embodiments of the application or the prior art, the following will briefly introduce the drawings needed to be used in the embodiment or prior art description. Obviously, the drawings in the following description only some embodiments of the application, and for those skilled in the art, other drawings can also be obtained without creative labor. In the drawings: Figure 1 A flow chart of the IO stream data partition verification method based on JAVA to realize the database provided by the embodiment of the application is provided. Figure 2 A structure schematic diagram of the IO stream data partition verification device based on JAVA to realize the database provided by the embodiment of the application is provided. DETAILED DESCRIPTION
[0019] In order to make the person skilled in the art better understand the technical solutions in the present application, the technical solutions in the embodiments of the present application will be described clearly and completely in the following with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only a part of the embodiments of the present application, not all. Based on the embodiments of the present application, all other embodiments obtained by those skilled in the art without creative labor should belong to the scope of protection of the present application.
[0020] The embodiment of the present application provides an IO stream data partition verification method based on JAVA, as shown in the figure, the IO stream data partition verification method based on JAVA specifically includes steps S101-S106: Figure 1 S101, obtaining the IO input stream to be verified; wherein the IO input stream is a data stream of external data read to the memory or memory data output to the storage device. Dynamic block processing is performed on the IO input stream, and the continuous data stream is divided into a plurality of target data blocks; the size of the target data block can be adaptively adjusted according to the data stream content.
[0021] Specifically, first, the IO data stream to be verified is obtained. The IO input stream can be a data stream of external data read to the memory or memory data output to the storage device.
[0022] Further, a sliding window processor is constructed based on JAVA, and the window buffer, the current position pointer and the fingerprint calculation parameters of the sliding window processor are initialized; the size of the window buffer is preset according to the data stream processing requirement.
[0023] Further, when the bytes of the IO input stream are input to the sliding window processor in sequence, the window buffer is updated and the current fingerprint is calculated. The oldest byte in the window buffer is removed, the influence of the old byte on the current fingerprint is calculated and the old byte is removed from the current fingerprint, and then the newly input byte is added to the window buffer, and the updated current fingerprint is recalculated.
[0024] Further, the fingerprint matching condition is preset, when the updated current fingerprint meets the fingerprint matching condition, the data stream before the current window buffer is divided into an independent data block, and the cycle is repeated until the IO input stream is blocked.
[0025] S102, for the target data block, a preset verification algorithm is used to generate a corresponding binding verification code, and an embedded verification mark is added to each target data block; wherein the embedded verification mark contains the position identification of the target data block and the inter-block association information.
[0026] Specifically, for each target data block, a JAVA CRC32 check algorithm interface is called to calculate a unique check code based on the byte content of the target data block, and the check code is bound to the corresponding target data block to form a bound check code.
[0027] Further, a plurality of check threads are started, each thread being responsible for processing the check code generation of one or more target data blocks, and the number of threads is dynamically adjusted according to the number of CPU cores.
[0028] As a feasible implementation, the position identification of the embedded check mark includes the starting byte offset, the ending byte offset and the data block number of the target data block in the IO input stream. The inter-block association information is a dependent value obtained by associating and calculating the check code of the current target data block and the check code of the previous target data block, so that the current target data block and the previous target data block form a check dependent chain, and the continuity check of the data stream is ensured.
[0029] S103, based on the sliding window buffer mechanism, the target data block is processed through a fixed-size ring memory buffer.
[0030] Specifically, a fixed-size ring memory buffer is constructed based on JAVA ByteBuffer; the ring memory buffer includes a read pointer, a write pointer, a mark bit and a fixed capacity, and thread safety of data reading and writing is realized through a synchronization lock.
[0031] Further, according to the hardware resource configuration, the type of the ring memory buffer is selected: if the IO performance needs to be improved, a direct buffer is selected; if the memory management needs to be simplified, a heap buffer is selected.
[0032] Further, when data is written into the ring memory buffer, the target data block is written into the ring memory buffer through the write pointer, and when the write pointer reaches the end of the ring memory buffer, the write is continued to the starting position of the ring memory buffer. When reading data, the current target data block to be processed is loaded from the ring memory buffer through the read pointer, and the read pointer is moved after reading is completed; the sliding window position is recorded through the mark bit to realize the marking and resetting of the sliding window.
[0033] As a feasible implementation, during data processing, a dynamic load balancing mechanism is further included: the hardware resource state is monitored in real time, the hardware resource state includes CPU usage, memory occupancy and IO read / write rate. The number of check threads is adjusted according to the CPU usage: when the CPU usage is lower than a preset threshold, the number of check threads is increased; when the CPU usage is higher than the preset threshold, the number of check threads is reduced. The data block blocking granularity is adjusted according to the memory occupancy: when the memory occupancy is lower than a preset threshold, the blocking granularity is increased; when the memory occupancy is higher than the preset threshold, the blocking granularity is reduced.
[0034] As another possible implementation, the memory occupation of the ring memory buffer is monitored in real time, and the memory usage is calculated. When the memory usage is higher than a preset safety threshold, the capacity of the ring buffer is automatically reduced to reduce the memory occupation. When the memory usage is lower than the preset safety threshold, the initial capacity of the ring buffer is restored to ensure the data processing efficiency.
[0035] As a possible implementation, the ring memory buffer further comprises a pre-reading pipeline mechanism: when the sliding window reads the current data block through the read pointer, an asynchronous pre-reading thread is started; the asynchronous pre-reading thread loads the subsequent data block to be processed in advance to the idle area of the ring buffer according to the position of the write pointer; after the current data block is processed, the subsequent data block cached in the ring memory buffer is directly read through the read pointer, and the IO data loading delay is hidden.
[0036] S104, judging whether the target data block is damaged according to the actual check code of the target data block and the binding check code; if there is a damaged data block, locating the specific damaged data block based on the embedded check mark.
[0037] Specifically, the target data block taken out of the ring memory buffer is transmitted to the check comparison module, and the actual check code of the target data block is compared with the binding check code in the check comparison module.
[0038] If the two are consistent, the target data block is not damaged; if the two are not consistent, the target data block is judged to be damaged.
[0039] Further, the total check code of the IO input stream is calculated and compared with the preset standard total check code; if the two are consistent, it is determined that there is no damaged data block, and an empty list is returned. If the two are not consistent, the IO input stream is divided into multiple regions, the standard regional check code and the actual regional check code of each region are obtained, and whether the two are consistent is compared to screen out abnormal regions with inconsistent check codes.
[0040] Further, each abnormal region is traversed, the binding check code and the actual block check code of all target data blocks in the region are obtained, and whether the two are consistent is compared. The data block number with inconsistent check codes is recorded to form a damaged data block list and returned, and the accurate positioning of the damaged data block is completed.
[0041] Finally, if there is no damaged data block, the target data block that passes the verification is integrated into the IO output stream to complete the partition verification of the IO input stream data; if there is a damaged data block, the target data block that passes the verification is integrated into the IO output stream, and the damaged data block list is bound and returned to the user.
[0042] In addition, the embodiment of the present application also provides an IO stream data partition verification device for a database based on JAVA, as shown inFigure 2 The IO stream data partition verification device based on JAVA implementation specifically comprises: at least one processor; and a memory connected with the at least one processor in communication; wherein, The memory stores instructions executable by the at least one processor, so that the at least one processor can perform: acquire an IO input stream to be verified; wherein, the IO input stream is a data stream of external data read to the memory or memory data output to a storage device; perform dynamic block processing on the IO input stream to divide the continuous data stream into a plurality of target data blocks; the size of the target data block can be adaptively adjusted according to the data stream content; for the target data block, a preset check algorithm is used to generate a corresponding binding check code, and an embedded check mark is added for each target data block; wherein, the embedded check mark contains the position identification of the target data block and the inter-block association information; based on a sliding window caching mechanism, the target data block is processed through a fixed-size ring memory buffer; according to the actual check code of the target data block and the binding check code, it is judged whether the target data block is damaged; if there is a damaged data block, the specific damaged data block is located based on the embedded check mark.
[0043] Each embodiment in the present application is described in a progressive manner, and the same and similar parts between each embodiment can be referred to each other. Each embodiment mainly explains the difference from other embodiments. Especially, for the device, equipment, non-volatile computer storage medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and the related parts can be referred to the part of the method embodiment.
[0044] The above describes a specific embodiment of the present application. In addition, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multi-task processing and parallel processing are possible or can be advantageous.
[0045] The above only describes the embodiments of the present application and is not used to limit the present application. The embodiments of the present application can have various changes and variations for those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the embodiments of the present application shall be included in the protection scope of the present application.
Claims
1. A method for verifying IO stream data partition based on JAVA implementation database, characterized in that, The method comprises: acquiring an IO input stream to be verified; wherein the IO input stream is a data stream of external data read into memory or memory data output to a storage device; performing dynamic block processing on the IO input stream to divide the continuous data stream into a plurality of target data blocks; the size of the target data block can be adaptively adjusted according to the data stream content; for the target data block, a preset check algorithm is used to generate a corresponding binding check code, and an embedded check mark is added for each target data block; wherein the embedded check mark contains the position identifier of the target data block and the inter-block association information; based on a sliding window buffer mechanism, the target data block is processed through a fixed-size ring memory buffer; according to the actual check code of the target data block and the binding check code, it is judged whether the target data block is damaged; if there is a damaged data block, the specific damaged data block is located based on the embedded check mark.
2. The IO stream data partition verification method based on JAVA implementation database according to claim 1, characterized in that, The dynamic block processing on the IO input stream divides the continuous data stream into a plurality of target data blocks, specifically including: a sliding window processor is constructed based on JAVA, and the window buffer, the current position pointer and the fingerprint calculation parameters of the sliding window processor are initialized; the size of the window buffer is preset according to the data stream processing requirement; when the bytes of the IO input stream are input into the sliding window processor in turn, the window buffer is updated and the current fingerprint is calculated; the oldest byte in the window buffer is removed, the influence of the old byte on the current fingerprint is calculated and the old byte is removed from the current fingerprint, and then the newly input byte is added to the window buffer, and the updated current fingerprint is recalculated; a preset fingerprint matching condition is set, when the updated current fingerprint meets the fingerprint matching condition, the data stream before the current window buffer is divided into an independent data block, and the cycle is repeated until the IO input stream is divided.
3. The method of claim 1, wherein the method is implemented based on JAVA. For the target data block, a preset check algorithm is used to generate a corresponding binding check code, specifically including: for each target data block, the CRC32 check algorithm interface of JAVA is called, a unique check code is calculated based on the byte content of the target data block, and the check code is bound with the corresponding target data block to form a binding check code; start a plurality of check threads, each thread is responsible for processing the check code generation of one or more target data blocks, and the number of threads is dynamically adjusted according to the number of CPU cores.
4. The method of claim 1, wherein the method is implemented based on JAVA. The position identifier of the embedded check mark contains the starting byte offset, the ending byte offset and the data block number of the target data block in the IO input stream; the inter-block association information is a dependent value obtained by associating and calculating the check code of the current target data block with the check code of the previous target data block, so that the current target data block and the previous target data block form a check dependent chain, and the continuity of the data stream is ensured.
5. The method of claim 1, wherein the method is implemented based on JAVA, and the method further comprises: Based on the sliding window buffer mechanism, the target data block is processed through a fixed-size ring memory buffer, specifically including: The fixed-size ring memory buffer is constructed based on a JAVA-based ByteBuffer; the ring memory buffer includes a read pointer, a write pointer, a flag bit, and a fixed capacity, and thread safety of data reading and writing is achieved through a synchronization lock; According to a hardware resource configuration, a type of the ring memory buffer is selected: if IO performance needs to be improved, a direct buffer is selected; if memory management needs to be simplified, an in-heap buffer is selected; When data is written, a target data block is written into the ring memory buffer through the write pointer; when the write pointer reaches the end of the ring memory buffer, the write pointer is circularly moved to the start of the ring memory buffer to continue writing; When data is read, a current target data block to be processed is loaded from the ring memory buffer through the read pointer; after reading is completed, the read pointer is moved; a sliding window position is recorded through the flag bit to achieve marking and resetting of the sliding window.
6. The IO stream data partition verification method based on JAVA implementation database of claim 5, wherein, The method further includes: Real-time monitoring of memory occupation of the ring memory buffer is performed, and a memory usage rate is calculated; When the memory usage rate is higher than a preset safety threshold, the capacity of the ring buffer is automatically reduced, and memory occupation is reduced; When the memory usage rate is lower than the preset safety threshold, the initial capacity of the ring buffer is restored, and data processing efficiency is ensured.
7. The method of claim 1, wherein the method is implemented based on JAVA. According to the actual check code of the target data block and the binding check code, whether the target data block is damaged is determined, and the determination specifically includes: The target data block taken out of the ring memory buffer is transmitted to a check comparison module, and the actual check code of the target data block is compared with the binding check code in the check comparison module; If the two are consistent, the target data block is not damaged; If the two are inconsistent, it is determined that the target data block is damaged.
8. The method of claim 1, wherein the method is implemented based on JAVA. If there is a damaged data block, the specific damaged data block is located based on the embedded check mark, and the locating specifically includes: A total check code of the IO input stream is calculated, and is compared with a preset standard total check code; if the two are consistent, it is determined that there is no damaged data block, and an empty list is returned; If the two are inconsistent, the IO input stream is divided into multiple regions, a standard regional check code and an actual regional check code of each region are obtained, and whether the two are consistent is compared to screen out an abnormal region with inconsistent check codes; Each abnormal region is traversed, the binding check code and the actual block check code of all target data blocks in the region are obtained, and whether the two are consistent is compared; A damaged data block list is formed by recording the data block numbers with inconsistent check codes, and is returned to complete accurate positioning of the damaged data block.
9. A method for verifying database IO stream data partitioning based on JAVA according to claim 8, characterized in that, After the specific damaged data block is located based on the embedded check mark if there is a damaged data block, the method further includes: If there is no damaged data block, the target data block that passes the verification is integrated into an IO output stream to complete partition verification of the IO input stream data; If there is a damaged data block, the target data block that passes the verification is integrated into an IO output stream, and the damaged data block list is bound and returned to a user.
10. A device for verifying partitioning of IO stream data of a database based on JAVA, characterized in that, The device includes: at least one processor; and a memory connected to the at least one processor in communication; wherein The memory stores instructions capable of being executed by the at least one processor, so that the at least one processor can execute the JAVA-based database IO stream data partition verification method according to any one of claims 1-9.