Android实现大文件分块上传的完整方案_Android

一、问题背景与核心思路

1.1 场景痛点

当 android 客户端需要上传 500mb 的大文件到服务器，而服务器表单限制为 2mb 时，传统的直接上传方案将完全失效。此时需要设计一套分块上传机制，将大文件拆分为多个小块，突破服务器限制。

1.2 核心思路

分块上传 + 服务端合并：

将文件切割为 ≤2mb 的块
逐块上传至服务器
服务端接收后按顺序合并

二、android 客户端实现细节

2.1 分块处理与上传流程

完整代码实现（kotlin）

// fileuploader.kt
object fileuploader {
    // 分块大小（1.9mb 预留安全空间）
    private const val chunk_size = 1.9 * 1024 * 1024 

    suspend fun uploadlargefile(context: context, file: file) {
        val fileid = generatefileid(file) // 生成唯一文件标识
        val totalchunks = calculatetotalchunks(file)
        val uploadedchunks = loadprogress(context, fileid) // 加载已上传分块记录

        fileinputstream(file).use { fis ->
            for (chunknumber in 0 until totalchunks) {
                if (uploadedchunks.contains(chunknumber)) continue

                val chunkdata = readchunk(fis, chunknumber)
                val islastchunk = chunknumber == totalchunks - 1

                try {
                    uploadchunk(fileid, chunknumber, totalchunks, chunkdata, islastchunk)
                    saveprogress(context, fileid, chunknumber) // 记录成功上传的分块
                } catch (e: exception) {
                    handleretry(fileid, chunknumber) // 重试逻辑
                }
            }
        }
    }

    private fun readchunk(fis: fileinputstream, chunknumber: int): bytearray {
        val skipbytes = chunknumber * chunk_size
        fis.channel().position(skipbytes.tolong())

        val buffer = bytearray(chunk_size)
        val bytesread = fis.read(buffer)
        return if (bytesread < buffer.size) buffer.copyof(bytesread) else buffer
    }
}

关键技术点解析

1.唯一文件标识生成：通过文件内容哈希（如 sha-256）确保唯一性

fun generatefileid(file: file): string {
    val digest = messagedigest.getinstance("sha-256")
    file.inputstream().use { is ->
        val buffer = bytearray(8192)
        var read: int
        while (is.read(buffer).also { read = it } > 0) {
            digest.update(buffer, 0, read)
        }
    }
    return digest.digest().tohex()
}

2.进度持久化存储：使用 sharedpreferences 记录上传进度

private fun saveprogress(context: context, fileid: string, chunk: int) {
    val prefs = context.getsharedpreferences("upload_progress", mode_private)
    val key = "${fileid}_chunks"
    val existing = prefs.getstringset(key, mutablesetof()) ?: mutablesetof()
    prefs.edit().putstringset(key, existing + chunk.tostring()).apply()
}

2.2 网络请求实现（retrofit + kotlin coroutine）

// uploadservice.kt
interface uploadservice {
    @multipart
    @post("api/upload/chunk")
    suspend fun uploadchunk(
        @part("fileid") fileid: requestbody,
        @part("chunknumber") chunknumber: requestbody,
        @part("totalchunks") totalchunks: requestbody,
        @part("islast") islast: requestbody,
        @part chunk: multipartbody.part
    ): response<uploadresponse>
}

// 上传请求封装
private suspend fun uploadchunk(
    fileid: string,
    chunknumber: int,
    totalchunks: int,
    chunkdata: bytearray,
    islast: boolean
) {
    val service = retrofitclient.create(uploadservice::class.java)
    
    val requestfile = chunkdata.torequestbody("application/octet-stream".tomediatype())
    val chunkpart = multipartbody.part.createformdata(
        "chunk", 
        "chunk_${chunknumber}", 
        requestfile
    )

    val response = service.uploadchunk(
        fileid = fileid.torequestbody(),
        chunknumber = chunknumber.tostring().torequestbody(),
        totalchunks = totalchunks.tostring().torequestbody(),
        islast = islast.tostring().torequestbody(),
        chunk = chunkpart
    )

    if (!response.issuccessful) {
        throw ioexception("upload failed: ${response.errorbody()?.string()}")
    }
}

三、服务端实现（spring boot 示例）

3.1 接收分块接口

@restcontroller
@requestmapping("/api/upload")
public class uploadcontroller {
    
    @value("${upload.temp-dir:/tmp/uploads}")
    private string tempdir;
    
    @postmapping("/chunk")
    public responseentity<?> uploadchunk(
        @requestparam string fileid,
        @requestparam int chunknumber,
        @requestparam int totalchunks,
        @requestparam boolean islast,
        @requestpart("chunk") multipartfile chunk) {
        
        // 创建临时目录
        path tempdirpath = paths.get(tempdir, fileid);
        if (!files.exists(tempdirpath)) {
            try {
                files.createdirectories(tempdirpath);
            } catch (ioexception e) {
                return responseentity.status(500).body("create dir failed");
            }
        }
        
        // 保存分块
        path chunkfile = tempdirpath.resolve("chunk_" + chunknumber);
        try {
            chunk.transferto(chunkfile);
        } catch (ioexception e) {
            return responseentity.status(500).body("save chunk failed");
        }
        
        // 如果是最后一块则触发合并
        if (islast) {
            asyncmergefile(fileid, totalchunks);
        }
        
        return responseentity.ok().build();
    }
    
    @async
    public void asyncmergefile(string fileid, int totalchunks) {
        // 实现合并逻辑
    }
}

3.2 合并文件实现

private void mergefile(string fileid, int totalchunks) throws ioexception {
    path tempdir = paths.get(this.tempdir, fileid);
    path outputfile = paths.get("/data/final", fileid + ".dat");
    
    try (outputstream out = new bufferedoutputstream(files.newoutputstream(outputfile))) {
        for (int i = 0; i < totalchunks; i++) {
            path chunk = tempdir.resolve("chunk_" + i);
            files.copy(chunk, out);
        }
        out.flush();
    }
    
    // 清理临时文件
    fileutils.deletedirectory(tempdir.tofile());
}

四、技术对比与方案选择

方案	优点	缺点	适用场景
传统表单上传	实现简单	受限于服务器大小限制	小文件上传（<2mb）
分块上传	突破大小限制，支持断点续传	实现复杂度较高	大文件上传（>100mb）
第三方云存储sdk	无需自行实现，功能完善	依赖第三方服务，可能有费用产生	需要快速集成云存储的场景

五、关键实现步骤总结

1.客户端分块切割

确定分块大小（建议略小于限制值）
生成唯一文件id（基于文件内容哈希）
实现可恢复的上传进度记录

2.分块上传

使用多部分表单上传每个分块
携带分块元数据（序号/总数/文件id）
实现超时重试机制

3.服务端处理

按文件id创建临时存储目录
验证分块完整性（可选md5校验）
原子性合并操作

4.可靠性增强

断点续传支持
网络异常自动重试
上传完整性校验

六、注意事项与优化建议

1.分块大小优化

建议设置为 服务器限制值 * 0.95（如 1.9mb）
测试不同分块大小对传输效率的影响

2.并发控制

可并行上传多个分块（需服务端支持）
合理控制并发数（建议 3-5 个并行）

3.安全防护

添加身份验证（jwt token）
限制单个文件的最大分块数
使用 https 加密传输

4.服务端优化

设置合理的临时文件清理策略
使用异步合并操作避免阻塞请求线程
实现分块哈希校验（示例代码见下方）

分块校验示例（服务端）：

// 计算分块md5
string receivedhash = digestutils.md5hex(chunk.getinputstream());
if (!receivedhash.equals(clientprovidedhash)) {
    throw new invalidchunkexception("chunk hash mismatch");
}

七、扩展方案：第三方云存储集成

对于不想自行实现分块上传的场景，可考虑以下方案：

阿里云oss分片上传

val oss = ossclient(context, endpoint, credentialprovider)
val request = initiatemultipartuploadrequest(bucketname, objectkey)
val uploadid = oss.initmultipartupload(request).uploadid

// 上传分片
val partetags = mutablelistof<partetag>()
for (i in chunks.indices) {
    val uploadpartrequest = uploadpartrequest(
        bucketname, objectkey, uploadid, i+1).apply {
        partcontent = chunks[i]
    }
    partetags.add(oss.uploadpart(uploadpartrequest).partetag)
}

// 完成上传
val completerequest = completemultipartuploadrequest(
    bucketname, objectkey, uploadid, partetags)
oss.completemultipartupload(completerequest)

aws s3 transferutility

transferutility transferutility = transferutility.builder()
    .s3client(s3client)
    .context(context)
    .build();

multiplefileupload upload = transferutility.uploaddirectory(
    bucketname, 
    remotedir, 
    localdir, 
    new objectmetadataprovider() {
        @override
        public void provideobjectmetadata(file file, objectmetadata metadata) {
            metadata.setcontenttype("application/octet-stream");
        }
    });

upload.settransferlistener(new uploadlistener());