java多线程分片下载文件

简介: java多线程分片下载文件
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
@Slf4j
public class SliceUtil {
    /**
     * 分片大小
     */
    public final static long PER_PAGE = (long) 1024 * 1024;
    private static final RestTemplate REST_TEMPLATE = new RestTemplate();
    /**
     * 根据分片下载
     *
     * @param downloadUrl
     * @param start
     * @param end
     * @return
     */
    public static ResponseEntity<byte[]> getFileContentByUrlAndPosition(String downloadUrl, long start, long end) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.set("Range", "bytes=" + start + "-" + end);
        org.springframework.http.HttpEntity<Object> httpEntity = new org.springframework.http.HttpEntity<>(httpHeaders);
        return REST_TEMPLATE.exchange(downloadUrl, HttpMethod.GET, httpEntity, byte[].class);
    }
    /**
     * 下载
     *
     * @param tempPath
     * @param downloadUrl
     * @param sliceInfo
     * @param fName
     */
    public static void download(String tempPath, String downloadUrl, SliceInfo sliceInfo, String fName) {
        log.info("下载分片文件:{},分片序号 {}", fName, sliceInfo.getPage());
        // 创建一个分片文件对象
        File file = new File(tempPath, sliceInfo.getPage() + "-" + fName);
        if (file.exists() && file.length() == PER_PAGE) {
            log.info("此分片文件 {} 已存在", sliceInfo.getPage());
            return;
        }
        try (FileOutputStream fos = new FileOutputStream(file);) {
            ResponseEntity<byte[]> responseEntity = SliceUtil.getFileContentByUrlAndPosition(downloadUrl, sliceInfo.getStart(), sliceInfo.getEnd());
            byte[] body = responseEntity.getBody();
            if (body != null && body.length == 0) {
                log.warn("分片文件:{},没有内容", file.getName());
                return;
            }
            // 将分片内容写入临时存储分片文件
            fos.write(body);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 合并文件
     *
     * @param tempPath
     * @param fName
     * @param page
     */
    public static void mergeFileTranTo(String tempPath, String fName, long page) {
        try (FileChannel channel = new FileOutputStream(new File(tempPath, fName)).getChannel()) {
            for (long i = 1; i <= page; i++) {
                File file = new File(tempPath, i + "-" + fName);
                FileChannel fileChannel = new FileInputStream(file).getChannel();
                long size = fileChannel.size();
                for (long left = size; left > 0; ) {
                    left -= fileChannel.transferTo((size - left), left, channel);
                }
                fileChannel.close();
                file.delete();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 分片页信息
 */
@Data
public class SlicePageInfo {
    private CopyOnWriteArrayList<SliceInfo> sliceInfoList;
    private Long page;
}
import lombok.AllArgsConstructor;
import lombok.Data;
/**
 * 文件分片信息
 */
@Data
@AllArgsConstructor
public class SliceInfo {
    private long start;
    private long end;
    private long page;
}
import com.ruoyi.common.utils.spring.SpringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.Objects;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import static com.ruoyi.download.slice.SliceUtil.PER_PAGE;
@Slf4j
public class DownLoadEngine {
    // 原生线程池
    // private static final ExecutorService executorService = ExecutorFactory.newFixedExecutorService(5);
    // 若依线程池
    private static ThreadPoolTaskExecutor executorService = SpringUtils.getBean("threadPoolTaskExecutor");
    /**
     * 分片下载
     *
     * @param downloadUrl 下载链接
     * @param tempPath    临时文件路径
     * @param fileName    文件名称
     */
    public static void downloadSlice(String downloadUrl, String tempPath, String fileName) {
        //大小探测
        ResponseEntity<byte[]> responseEntity = SliceUtil.getFileContentByUrlAndPosition(downloadUrl, 0, 1);
        HttpHeaders headers = responseEntity.getHeaders();
        String rangeBytes = headers.getFirst("Content-Range");
        if (Objects.isNull(rangeBytes)) {
            log.error("url:{},不支持分片下载", downloadUrl);
            return;
        }
        long allBytes = Long.parseLong(rangeBytes.split("/")[1]);
        log.info("文件总大小:{}M", allBytes / 1024.0 / 1024.0);
        //分页
        SlicePageInfo slicePageInfo = splitPage(allBytes);
        CountDownLatch countDownLatch = new CountDownLatch(Math.toIntExact(slicePageInfo.getPage()));
        CountDownLatch mainLatch = new CountDownLatch(1);
        executorService.execute(() -> {
            try {
                countDownLatch.await();
                SliceUtil.mergeFileTranTo(tempPath, fileName, slicePageInfo.getPage());
                mainLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        for (SliceInfo sliceInfo : slicePageInfo.getSliceInfoList()) {
            executorService.submit(() -> {
                SliceUtil.download(tempPath, downloadUrl, sliceInfo, fileName);
                countDownLatch.countDown();
            });
        }
        try {
            mainLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    /**
     * 文件分片
     *
     * @param allBytes 文件总大小
     * @return /
     */
    public static SlicePageInfo splitPage(long allBytes) {
        CopyOnWriteArrayList<SliceInfo> list = new CopyOnWriteArrayList<>();
        long size = allBytes;
        long left = 0;
        long page = 0;
        while (size > 0) {
            long start = 0;
            long end;
            start = left;
            //分页
            if (size < PER_PAGE) {
                end = left + size;
            } else {
                end = left += PER_PAGE;
            }
            size -= PER_PAGE;
            page++;
            if (start != 0) {
                start++;
            }
            log.info("页码:{},开始位置:{},结束位置:{}", page, start, end);
            final SliceInfo sliceInfo = new SliceInfo(start, end, page);
            list.add(sliceInfo);
        }
        SlicePageInfo slicePageInfo = new SlicePageInfo();
        slicePageInfo.setSliceInfoList(list);
        slicePageInfo.setPage(page);
        return slicePageInfo;
    }
}
@Test
@DisplayName("大文件分片下载")
public void downloadSliceFile() {
    DownLoadEngine.downloadSlice("https://dldir1.qq.com/qqfile/qq/PCQQ9.6.1/QQ9.6.1.28732.exe", "D:/temp", "qq.exe");
}


相关文章
|
17小时前
|
关系型数据库 MySQL Java
|
4天前
|
监控 Java API
Java并发编程之线程池深度解析
【7月更文挑战第14天】在Java并发编程领域,线程池是提升性能、管理资源的关键工具。本文将深入探讨线程池的核心概念、内部工作原理以及如何有效使用线程池来处理并发任务,旨在为读者提供一套完整的线程池使用和优化策略。
|
4天前
|
安全 Java 开发者
Java并发编程中的线程安全性与性能优化
在Java编程中,处理并发问题是至关重要的。本文探讨了Java中线程安全性的概念及其在性能优化中的重要性。通过深入分析多线程环境下的共享资源访问问题,结合常见的并发控制手段和性能优化技巧,帮助开发者更好地理解和应对Java程序中的并发挑战。 【7月更文挑战第14天】
|
6天前
|
Java 调度
java中线程的6种状态
java中线程的6种状态
|
6天前
|
算法 Java 开发者
Java中的多线程编程技巧与实践
在现代软件开发中,多线程编程成为提升应用程序性能和响应能力的关键技术之一。本文将深入探讨Java语言中多线程编程的基础概念、常见问题及其解决方案,帮助开发者更好地理解和应用多线程技术。 【7月更文挑战第12天】
9 0
|
7天前
|
存储 安全 算法
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第72天】 在现代软件开发中,尤其是Java应用开发领域,并发编程是一个无法回避的重要话题。随着多核处理器的普及,合理利用并发机制对于提高软件性能、响应速度和资源利用率具有重要意义。本文旨在探讨Java并发编程的核心概念、线程安全的策略以及性能优化技巧,帮助开发者构建高效且可靠的并发应用。通过实例分析和理论阐述,我们将揭示在高并发环境下如何平衡线程安全与系统性能之间的关系,并提出一系列最佳实践方法。
|
7天前
|
Java 调度
Java线程的六种状态
Java线程有六种状态: 初始(NEW)、运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)、终止(TERMINATED)。
23 1
|
6天前
|
缓存 Linux 编译器
【Linux】多线程——线程概念|进程VS线程|线程控制(下)
【Linux】多线程——线程概念|进程VS线程|线程控制(下)
15 0
|
6天前
|
存储 Linux 调度
【Linux】多线程——线程概念|进程VS线程|线程控制(上)
【Linux】多线程——线程概念|进程VS线程|线程控制(上)
16 0
|
8天前
|
设计模式 并行计算 安全
Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
12 0

热门文章

最新文章