添加高效的随机文件访问工具类及其单元测试

zen-core/src/main/kotlin/com/gxzc/zen/common/util/FileUtil.kt

@@ -1,9 +1,11 @@
 package com.gxzc.zen.common.util
 
 import com.gxzc.zen.common.properties.UploadProperties
+import com.gxzc.zen.common.util.io.BufferedRandomAccessFile
 import java.io.File
 import java.io.FileInputStream
 import java.io.IOException
+import java.io.InputStream
 import java.nio.ByteBuffer
 
 /**
@@ -14,39 +16,35 @@ import java.nio.ByteBuffer
  */
 object FileUtil {
 
-    private var uploadProperties = SpringContextHolder.getBean(UploadProperties::class.java)
-        get() {
-            if (field == null) {
-                field = SpringContextHolder.getBean(UploadProperties::class.java)
-            }
-            return field
-        }
+    private val uploadProperties: UploadProperties by lazy { SpringContextHolder.getBean(UploadProperties::class.java)!! }
 
     /**
-     * 获取 文件首尾chunk+lastModifiedTime 拼接起来的md5
+     * 获取 文件首+尾chunk
+     * 拼接起来的md5
      */
-    fun md5HeadTail(path: String, chunkSize: Int?): String {
+    fun md5HeadTail(path: String, chunkSize: Int? = uploadProperties.chunkSize?.toInt()): String {
         val file = File(path)
         return transientMd5HeadTail(file, chunkSize)
     }
 
     /**
-     * 获取 文件首尾chunk+lastModifiedTime 拼接起来的md5
+     * 获取 文件首+尾chunk
+     * 拼接起来的md5
      */
-    fun md5HeadTail(file: File, chunkSize: Int?): String {
+    fun md5HeadTail(file: File, chunkSize: Int? = uploadProperties.chunkSize?.toInt()): String {
         return transientMd5HeadTail(file, chunkSize)
     }
 
     private fun transientMd5HeadTail(file: File, size: Int?): String {
         var chunkSize = size
         if (chunkSize == null) {
-            chunkSize = uploadProperties!!.chunkSize!!.toInt()
+            chunkSize = uploadProperties.chunkSize!!.toInt()
         }
         val fc = FileInputStream(file).channel
         val fileSize = fc.size()
 
         val buffer = ByteBuffer.allocate(chunkSize)
-        val lastModified = file.lastModified() / 1000 * 1000 // 由于jdk8的bug导致在linux上读取修改时间丢失精度
+        //        val lastModified = file.lastModified() / 1000 * 1000 // 由于jdk8的bug导致在linux上读取修改时间丢失精度
         val chunks = Math.ceil(1.0 * fileSize / chunkSize).toInt() // 分块总数
 
         var currentPos = 0 * chunkSize * 1L
@@ -90,15 +88,62 @@ object FileUtil {
         fc.close() // 关闭文件流
 
         return if (retBuffer != null) {
-            val timeByteArray = ByteBuffer.allocate(8).putLong(lastModified).array()
-            timeByteArray.reverse()
-
-            retBuffer.put(timeByteArray)
-
+            //            val timeByteArray = ByteBuffer.allocate(8).putLong(lastModified).array()
+            //            timeByteArray.reverse()
+            //
+            //            retBuffer.put(timeByteArray)
             MD5Util.encodeMd5(retBuffer.array())
         } else {
             ""
         }
+    }
+
+    /**
+     * 将文件写入指定路径
+     * 优化过的RandomAccessFile
+     */
+    fun writeFile(ins: InputStream, outputPath: String): File {
+        val brafWriteFile = BufferedRandomAccessFile(outputPath, "rw", 10)
 
+        ins.use {
+            brafWriteFile.use {
+                val buf = ByteArray(4096)
+                var readcount = ins.read(buf)
+                while (readcount != -1) {
+                    brafWriteFile.write(buf, 0, readcount)
+                    readcount = ins.read(buf)
+                }
+            }
+        }
+        return File(brafWriteFile.filename)
+    }
+
+    /**
+     * 将文件写入指定路径
+     * 优化过的RandomAccessFile
+     */
+    fun writeFile(path: String, outputPath: String): File {
+        return writeFile(File(path), outputPath)
+    }
+
+    /**
+     * 将文件写入指定路径
+     * 优化过的RandomAccessFile
+     */
+    fun writeFile(file: File, outputPath: String): File {
+        val brafReadFile = BufferedRandomAccessFile(file)
+        val brafWriteFile = BufferedRandomAccessFile(outputPath, "rw", 10)
+
+        brafReadFile.use {
+            brafWriteFile.use {
+                val buf = ByteArray(4096)
+                var readcount = brafReadFile.read(buf)
+                while (readcount != -1) {
+                    brafWriteFile.write(buf, 0, readcount)
+                    readcount = brafReadFile.read(buf)
+                }
+            }
+        }
+        return File(brafWriteFile.filename)
     }
 }

zen-core/src/main/kotlin/com/gxzc/zen/common/util/io/BufferedRandomAccessFile.kt

@@ -0,0 +1,216 @@
+package com.gxzc.zen.common.util.io
+
+import java.io.File
+import java.io.IOException
+import java.io.RandomAccessFile
+
+/**
+ * 加入缓冲机制的 <br>
+ * 随机文件访问 <br>
+ * 效率速度为 RandomAccessFile 的 5倍左右,大文件更高
+ * 占用空间 <= 30MB (4096)
+ * @author NorthLan
+ * @date 2018/5/24
+ * @url https://noahlan.com
+ */
+open class BufferedRandomAccessFile(name: String, mode: String = "r", bufbitlen: Int = DEFAULT_BUFFER_BIT_LEN) : RandomAccessFile(name, mode) {
+    companion object {
+        private val DEFAULT_BUFFER_BIT_LEN = 10
+        private val DEFAULT_BUFFER_SIZE = 1 shl DEFAULT_BUFFER_BIT_LEN
+    }
+
+    private var buf: ByteArray
+    private var bufbitlen: Int = 0
+    private var bufsize: Int = 0
+    private var bufmask: Long = 0
+    private var bufdirty: Boolean = false
+    private var bufusedsize: Int = 0
+    private var curpos: Long = 0
+
+    private var bufstartpos: Long = 0
+    private var bufendpos: Long = 0
+    private var fileendpos: Long = 0
+
+    private var append: Boolean = false
+    var filename: String
+    var initfilelen: Long = 0
+
+    constructor(file: File) : this(file.path, "r", DEFAULT_BUFFER_BIT_LEN)
+    constructor(name: String, bufbitlen: Int) : this(name, "r", bufbitlen)
+    constructor(file: File, bufbitlen: Int) : this(file.path, "r", bufbitlen)
+    constructor(file: File, mode: String) : this(file.path, mode, DEFAULT_BUFFER_BIT_LEN)
+    constructor(file: File, mode: String, bufbitlen: Int) : this(file.path, mode, bufbitlen)
+
+    init {
+        this.append = mode == "r" != true
+
+        this.filename = name
+        this.initfilelen = super.length()
+        this.fileendpos = this.initfilelen - 1
+        this.curpos = super.getFilePointer()
+
+        if (bufbitlen < 0) {
+            throw IllegalArgumentException("bufbitlen size must >= 0")
+        }
+
+        this.bufbitlen = bufbitlen
+        this.bufsize = 1 shl bufbitlen
+        this.buf = ByteArray(this.bufsize)
+        this.bufmask = (this.bufsize.toLong() - 1L).inv()
+        this.bufdirty = false
+        this.bufusedsize = 0
+        this.bufstartpos = -1
+        this.bufendpos = -1
+    }
+
+    private fun flushbuf() {
+        if (this.bufdirty) {
+            if (super.getFilePointer() != this.bufstartpos) {
+                super.seek(this.bufstartpos)
+            }
+            super.write(this.buf, 0, this.bufusedsize)
+            this.bufdirty = false
+        }
+    }
+
+    private fun fillbuf(): Int {
+        super.seek(this.bufstartpos)
+        this.bufdirty = false
+        return super.read(this.buf)
+    }
+
+    fun read(pos: Long): Byte {
+        if (pos < this.bufstartpos || pos > this.bufendpos) {
+            this.flushbuf()
+            this.seek(pos)
+
+            if (pos < this.bufstartpos || pos > this.bufendpos) {
+                throw IOException()
+            }
+        }
+        this.curpos = pos
+        return this.buf[(pos - this.bufstartpos).toInt()]
+    }
+
+    fun write(bw: Byte): Boolean {
+        return this.write(bw, this.curpos)
+    }
+
+    fun append(bw: Byte): Boolean {
+        return this.write(bw, this.fileendpos + 1)
+    }
+
+    fun write(bw: Byte, pos: Long): Boolean {
+        if (pos >= this.bufstartpos && pos <= this.bufendpos) { // write pos in buf
+            this.buf[(pos - this.bufstartpos).toInt()] = bw
+            this.bufdirty = true
+
+            if (pos == this.fileendpos + 1) { // write pos is append pos
+                this.fileendpos++
+                this.bufusedsize++
+            }
+        } else { // write pos not in buf
+            this.seek(pos)
+
+            if (pos >= 0 && pos <= this.fileendpos && this.fileendpos != 0L) { // write pos is modify file
+                this.buf[(pos - this.bufstartpos).toInt()] = bw
+
+            } else if (pos == 0L && this.fileendpos == 0L || pos == this.fileendpos + 1) { // write pos is append pos
+                this.buf[0] = bw
+                this.fileendpos++
+                this.bufusedsize = 1
+            } else {
+                throw IndexOutOfBoundsException()
+            }
+            this.bufdirty = true
+        }
+        this.curpos = pos
+        return true
+    }
+
+    override fun write(b: ByteArray, off: Int, len: Int) {
+        val writeendpos = this.curpos + len - 1
+
+        if (writeendpos <= this.bufendpos) { // b[] in cur buf
+            System.arraycopy(b, off, this.buf, (this.curpos - this.bufstartpos).toInt(), len)
+            this.bufdirty = true
+            this.bufusedsize = (writeendpos - this.bufstartpos + 1).toInt() //(int)(this.curpos - this.bufstartpos + len - 1);
+
+        } else { // b[] not in cur buf
+            super.seek(this.curpos)
+            super.write(b, off, len)
+        }
+
+        if (writeendpos > this.fileendpos)
+            this.fileendpos = writeendpos
+
+        this.seek(writeendpos + 1)
+    }
+
+    override fun read(b: ByteArray, off: Int, len: Int): Int {
+        var ret = len
+        var readendpos = this.curpos + ret - 1
+        if (readendpos <= this.bufendpos && readendpos <= this.fileendpos) { // read in buf
+            System.arraycopy(this.buf, (this.curpos - this.bufstartpos).toInt(), b, off, len)
+        } else { // read b[] size > buf[]
+            if (readendpos > this.fileendpos) { // read b[] part in file
+                ret = (this.length() - this.curpos + 1).toInt()
+            }
+            super.seek(this.curpos)
+            ret = super.read(b, off, ret)
+            readendpos = this.curpos + ret - 1
+        }
+        this.seek(readendpos + 1)
+        return ret
+    }
+
+    override fun write(b: ByteArray) {
+        this.write(b, 0, b.size)
+    }
+
+    override fun read(b: ByteArray): Int {
+        return this.read(b, 0, b.size)
+    }
+
+    override fun seek(pos: Long) {
+        if (pos < this.bufstartpos || pos > this.bufendpos) { // seek pos not in buf
+            this.flushbuf()
+
+            if (pos >= 0 && pos <= this.fileendpos && this.fileendpos != 0L) { // seek pos in file (file length > 0)
+                this.bufstartpos = pos and this.bufmask
+                this.bufusedsize = this.fillbuf()
+            } else if (pos == 0L && this.fileendpos == 0L || pos == this.fileendpos + 1) { // seek pos is append pos
+                this.bufstartpos = pos
+                this.bufusedsize = 0
+            }
+            this.bufendpos = this.bufstartpos + this.bufsize - 1
+        }
+        this.curpos = pos
+    }
+
+    override fun length(): Long {
+        return this.max(this.fileendpos + 1, this.initfilelen)
+    }
+
+    override fun setLength(newLength: Long) {
+        if (newLength > 0) {
+            this.fileendpos = newLength - 1
+        } else {
+            this.fileendpos = 0
+        }
+        super.setLength(newLength)
+    }
+
+    override fun getFilePointer(): Long {
+        return this.curpos
+    }
+
+    private fun max(a: Long, b: Long): Long {
+        return if (a > b) a else b
+    }
+
+    override fun close() {
+        this.flushbuf()
+        super.close()
+    }
+}

zen-core/src/test/kotlin/com/gxzc/zen/io/BufferedRandomAccessFileTest.kt

@@ -0,0 +1,70 @@
+package com.gxzc.zen.io
+
+import com.gxzc.zen.common.util.io.BufferedRandomAccessFile
+import org.junit.Test
+
+/**
+ *
+ * @author NorthLan
+ * @date 2018/9/1
+ * @url https://noahlan.com
+ */
+class BufferedRandomAccessFileTest {
+
+    @Test
+    fun test() {
+        val readfilelen: Long
+        val brafReadFile = BufferedRandomAccessFile("D:\\gradle-4.9-bin.zip")
+        val brafWriteFile = BufferedRandomAccessFile("D:\\gradle-4.9-bin-bak.zip", "rw", 10)
+
+        readfilelen = brafReadFile.initfilelen
+
+        val buf = ByteArray(4096)
+        var readcount: Int = brafReadFile.read(buf)
+
+        var start = System.currentTimeMillis()
+
+        while (readcount != -1) {
+            brafWriteFile.write(buf, 0, readcount)
+            readcount = brafReadFile.read(buf)
+        }
+
+        brafWriteFile.close()
+        brafReadFile.close()
+
+        println("BufferedRandomAccessFile Copy & Write File: "
+                + brafReadFile.filename
+                + "    FileSize: "
+                + java.lang.Integer.toString(readfilelen.toInt() shr 4096)
+                + " (KB)    "
+                + "Spend: "
+                + (System.currentTimeMillis() - start).toDouble() / 1000
+                + "(s)")
+
+        val fdin = java.io.FileInputStream("D:\\gradle-4.9-bin.zip")
+        val bis = java.io.BufferedInputStream(fdin, 4096)
+        val dis = java.io.DataInputStream(bis)
+
+        val fdout = java.io.FileOutputStream("D:\\gradle-4.9-bin-bak2.zip")
+        val bos = java.io.BufferedOutputStream(fdout, 4096)
+        val dos = java.io.DataOutputStream(bos)
+
+        start = System.currentTimeMillis()
+
+        for (i in 0 until readfilelen) {
+            dos.write(dis.readByte().toInt())
+        }
+
+        dos.close()
+        dis.close()
+
+        println("DataBufferedios Copy & Write File: "
+                + brafReadFile.filename
+                + "    FileSize: "
+                + java.lang.Integer.toString(readfilelen.toInt() shr 4096)
+                + " (KB)    "
+                + "Spend: "
+                + (System.currentTimeMillis() - start).toDouble() / 1000
+                + "(s)")
+    }
+}