java实现断点续传、分片上传、文件快传

**Java 实现断点续传、分片上传、文件快传**

在实际的开发中，我们经常会遇到需要上传大型文件的情况，例如图片、视频等。然而，这些文件往往非常庞大，导致上传过程缓慢甚至失败。为了解决这个问题，我们可以使用断点续传、分片上传和文件快传技术。

###1. 断点续传断点续传是指在上传过程中遇到错误或网络中断时，可以从上一次成功的位置继续上传，而不是重新开始，从而提高了上传效率。

#### Java 实现断点续传示例代码

javaimport java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class BreakPointUpload {
 public static void main(String[] args) throws IOException {
 //上传文件路径 String uploadFilePath = "D:test.txt";
 // 断点续传文件路径 String breakPointFilePath = "D:break_point.txt";
 //读取断点续传文件 File breakPointFile = new File(breakPointFilePath);
 if (breakPointFile.exists()) {
 // 从断点续传文件中读取上一次成功的位置 long lastSuccessPosition = readLastSuccessPosition(breakPointFile);
 //上传文件 uploadFile(uploadFilePath, breakPointFile, lastSuccessPosition);
 } else {
 // 如果没有断点续传文件，则直接上传 uploadFile(uploadFilePath, null, -1L);
 }
 }

 /**
 * 从断点续传文件中读取上一次成功的位置 *
 * @param breakPointFile 断点续传文件 * @return 上一次成功的位置 */
 private static long readLastSuccessPosition(File breakPointFile) throws IOException {
 //读取断点续传文件中的内容 InputStream inputStream = new FileInputStream(breakPointFile);
 byte[] bytes = new byte[1024];
 int len;
 // 找到上一次成功的位置 long lastSuccessPosition = -1L;
 while ((len = inputStream.read(bytes)) != -1) {
 String str = new String(bytes,0, len);
 if (str.contains("success")) {
 lastSuccessPosition = Long.parseLong(str.split("s+")[2]);
 break;
 }
 }
 // 关闭输入流 inputStream.close();
 return lastSuccessPosition;
 }

 /**
 *上传文件 *
 * @param uploadFilePath上传文件路径 * @param breakPointFile 断点续传文件 * @param lastSuccessPosition 上一次成功的位置 */
 private static void uploadFile(String uploadFilePath, File breakPointFile, long lastSuccessPosition) throws IOException {
 //读取上传文件 FileInputStream fileInputStream = new FileInputStream(uploadFilePath);
 // 写入断点续传文件 FileOutputStream fileOutputStream = new FileOutputStream(breakPointFile, true);
 byte[] bytes = new byte[1024];
 int len;
 while ((len = fileInputStream.read(bytes)) != -1) {
 if (lastSuccessPosition == -1L || lastSuccessPosition <=0L) {
 // 如果没有上一次成功的位置，则直接写入 fileOutputStream.write(bytes,0, len);
 } else {
 // 如果有上一次成功的位置，则从该位置开始写入 int writeLen = (int) Math.min(lastSuccessPosition, len);
 fileOutputStream.write(bytes,0, writeLen);
 // 更新上一次成功的位置 lastSuccessPosition -= writeLen;
 }
 }
 // 关闭输入流和输出流 fileInputStream.close();
 fileOutputStream.close();
 }
}

javaimport java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class SliceUpload {
 public static void main(String[] args) throws IOException {
 //上传文件路径 String uploadFilePath = "D:test.txt";
 // 分片大小（字节）
 int sliceSize =1024 *1024; //1MB //读取上传文件 FileInputStream fileInputStream = new FileInputStream(uploadFilePath);
 // 写入分片文件 FileOutputStream[] fileOutputStreams = new FileOutputStream[10];
 for (int i =0; i < 10; i++) {
 int start = i * sliceSize;
 int end = Math.min((i +1) * sliceSize, fileInputStream.available());
 // 写入分片文件 File sliceFile = new File("D:slice_" + (i +1) + ".txt");
 fileOutputStreams[i] = new FileOutputStream(sliceFile);
 byte[] bytes = new byte[end - start];
 fileInputStream.read(bytes,0, end - start);
 fileOutputStreams[i].write(bytes,0, end - start);
 // 关闭输出流 fileOutputStreams[i].close();
 }
 // 关闭输入流 fileInputStream.close();
 }
}

javaimport java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FastUpload {
 public static void main(String[] args) throws IOException {
 //上传文件路径 String uploadFilePath = "D:test.txt";
 // 快传协议版本 int protocolVersion =1;
 //读取上传文件 FileInputStream fileInputStream = new FileInputStream(uploadFilePath);
 // 写入快传文件 FileOutputStream fastFileOutputStream = new FileOutputStream("D:fast_upload.txt");
 byte[] bytes = new byte[1024];
 int len;
 while ((len = fileInputStream.read(bytes)) != -1) {
 // 写入快传文件 fastFileOutputStream.write(bytes,0, len);
 // 更新快传进度 System.out.println("上传进度：" + (len / (1024 *1024.0)) + "MB");
 }
 // 关闭输入流和输出流 fileInputStream.close();
 fastFileOutputStream.close();
 }
}