【Java项目】SpringBoot项目的多文件兼多线程上传下载

简介: 【Java项目】SpringBoot项目的多文件兼多线程上传下载

前言

我们的项目目前需要在一个相册中,上传多个的图片,因此,在一次的用户提交过程中,会有多张的图片需要被处理,那么此时,就需要有一个方法,来处理这多张文件。

很容易可以想到MultipartFile,我们在使用POST请求的时候就知道文件的单张上传都是POST请求加上一个@RequestParam的MultipartFile类型的文件。

如下

但是上面只能实现单张文件的上传,因此为了确保效率以及以及提交就能完成多文件的上传,需要把代码修改为如下状态,也就是请求参数为一个数组,这样子就能接受多文件的请求了

文件上传到本地代码编写

先最简单的介绍一下把文件保存到本地的代码编写

public static final String upload(String baseDir, MultipartFile file, String[] allowedExtension)
            throws FileSizeLimitExceededException, IOException, FileNameLengthLimitExceededException,
            InvalidExtensionException
    {   //判断文件名长度是否过长
        int fileNamelength = Objects.requireNonNull(file.getOriginalFilename()).length();
        if (fileNamelength > FileUploadUtils.DEFAULT_FILE_NAME_LENGTH)
        {
            throw new FileNameLengthLimitExceededException(FileUploadUtils.DEFAULT_FILE_NAME_LENGTH);
        }
        //判断文件的扩展类型是否合理
        assertAllowed(file, allowedExtension);
        //对文件名进行编码
        String fileName = extractFilename(file);
        //获取文件在本机的绝对地址
        String absPath = getAbsoluteFile(baseDir, fileName).getAbsolutePath();
        //将文件放到本机绝对地址
        file.transferTo(Paths.get(absPath));
        //返回文件名
        return getPathFileName(fileName);
    }
//比较重要的就是这个 他将会创建多级目录 并且把文件保存到对应的位置
private static final File getAbsoluteFile(String uploadDir, String fileName) throws IOException
    {
        File desc = new File(uploadDir + File.separator + fileName);
        if (!desc.exists())
        {
            if (!desc.getParentFile().exists())
            {
                desc.getParentFile().mkdirs();
            }
        }
        return desc.isAbsolute() ? desc : desc.getAbsoluteFile();
    }

文件上传之后,目录结构如下

其中文件目录结构指定位置为

全局线程池配置

我使用的SpringBoot版本为2.7.7,并且这是一个SpringCloud项目,因此,我对各种不同场景下的线程池进行了不同的配置,并且在需要使用到线程池的模块中直接映入这个线程池配置模块即可,代码如下,注意,这个代码是我自己编写的,很多类都是Java中没有的,你们按照自己的方法编写线程池配置即可

@AutoConfiguration
public class DynamicThreadPool {
    /**
     * 初始化线程池
     *
     * @return
     */
    @Bean("fileThreadPool")
    private static ThreadPoolExecutor buildThreadPoolExecutor() {
        return new ThreadPoolExecutor(3,
                3,
                60,
                TimeUnit.SECONDS,
                new ResizableCapacityLinkedBlockIngQueue<Runnable>(10),
                new NamedThreadFactory("file-thread-"),
                new ThreadPoolExecutor.DiscardPolicy());
    }
}

然后将这个类自动加载

实现多线程上传

其实实现多线程上传比较简单,很容易的就可以想到Thread类,ThreadPoolExecutor,Semaphore,CountdownLaunch,CompletableFuture,CyclicBarrier等各种解决方法。

这里先简单的列出CountDownLaunch配合ThreadPoolExecutor来实现多线程文件上传的方法

Semaphore

synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源,而Semaphore(信号量)可以用来控制同时访问特定资源的线程数量。Semaphore 的使用简单,我们这里假设有 N(N>5) 个线程来获取 Semaphore 中的共享资源,下面的代码表示同一时刻 N 个线程中只有 5 个线程能获取到共享资源,其他线程都会阻塞,只有获取到共享资源的线程才能执行。等到有线程释放了共享资源,其他阻塞的线程才能获取到。

// 初始共享资源数量
final Semaphore semaphore = new Semaphore(5);
// 获取1个许可
semaphore.acquire();
// 释放1个许可
semaphore.release();
public List<String> uploadloadFileMultiples(MultipartFile[] files) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        Semaphore semaphore = new Semaphore(files.length);
        for (int i = 0; i < files.length; i++) {
            try {
                semaphore.acquire();
                MultipartFile file = files[i];
                //TODO 使用CountDownLaunch或者ComplatableFuture或者Semaphore
                //来完成多线程的文件上传
                fileThreadPool.submit(() -> {
                    try {
                        String url = uploadFile(file);
                        list.add(url);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {
                        //表示一个文件已经被完成
                        semaphore.release();
                    }
                });
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return list;
    }

CountDownLaunch

CountDownLatch 有什么用?

CountDownLatch 允许 count 个线程阻塞在一个地方,直至所有线程的任务都执行完毕。CountDownLatch 是一次性的,计数器的值只能在构造方法中初始化一次,之后没有任何机制再次对其设置值,当 CountDownLatch 使用完毕后,它不能再次被使用。

在这个项目中,我们要读取处理 3个文件,这 3个任务都是没有执行顺序依赖的任务,但是我们需要返回给用户的时候将这几个文件的处理的结果进行统计整理。为此我们定义了一个线程池和 count 为3的CountDownLatch对象 。使用线程池处理读取任务,每一个线程处理完之后就将 count-1,调用CountDownLatch对象的 await()方法,直到所有文件读取完之后,才会接着执行后面的逻辑。

代码比较简单,也很好理解,也就是每一个文件拷贝完毕之后,调用countDownLaunch的countDown方法将计数器-1即可。

同时,由于是多线程拷贝,并且我需要保存每一次拷贝的返回结果,因此,就使用到了CopyOnWriteArrayList来保证并发情况下的数据集合不被丢失修改。

@Autowired
    @Qualifier("fileThreadPool")
    private ThreadPoolExecutor fileThreadPool;
    /**
     * 实现多文件多线程上传
     *
     * @param files 要上传的文件
     * @return 返回恋爱日志信息
     */
    @ApiOperation(value = "多附件上传-纯附件上传", notes = "多附件上传")
    @ResponseBody
    @PostMapping("/uploadFiles")
    public R<LoveLogs> handleFileUpload(@RequestParam("files") MultipartFile[] files) {
        LoveLogs loveLogs = new LoveLogs();
        String[] urls = new String[files.length];
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        CountDownLatch countDownLatch = new CountDownLatch(files.length);
        for (int i = 0; i < files.length; i++) {
            try {
                 获取文件名
                //String fileName = file.getOriginalFilename();
                 拼接文件保存路径
                //String filePath = "D:/uploads/" + fileName;
                 保存文件到本地
                //file.transferTo(new File(filePath));
                MultipartFile file = files[i];
                //String url = sysFileService.uploadFile(file);
                //urls[i] = url;
                //TODO 使用CountDownLaunch或者ComplatableFuture或者Semaphore
                //来完成多线程的文件上传
                fileThreadPool.submit(() -> {
                    try {
                        String s = sysFileService.uploadFile(file);
                        list.add(s);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {
                        //表示一个文件已经被完成
                        countDownLatch.countDown();
                    }
                });
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        try {
            //阻塞直到所有的文件完成复制
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //统计每个文件的url
        String photoUrls = String.join(",", list);
        loveLogs.setUrls(photoUrls);
        //返回结果
        return R.ok(loveLogs);
    }

CyclicBarrier

CyclicBarrier 和 CountDownLatch 非常类似,它也可以实现线程间的技术等待,但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CountDownLatch 的实现是基于 AQS 的,而 CycliBarrier 是基于 ReentrantLock(ReentrantLock 也属于 AQS 同步器)和 Condition 的。CyclicBarrier 的字面意思是可循环使用(Cyclic)的屏障(Barrier)。它要做的事情是:让一组线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活。

CyclicBarrier 内部通过一个 count 变量作为计数器,count 的初始值为 parties 属性的初始化值,每当一个线程到了栅栏这里了,那么就将计数器减 1。如果 count 值为 0 了,表示这是这一代最后一个线程到达栅栏,就尝试执行我们构造方法中输入的任务。

//每次拦截的线程数
private final int parties;
//计数器
private int count;
• 1
• 2
• 3
• 4
public List<String> uploadloadFileMultipled(MultipartFile[] files) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        CyclicBarrier cyclicBarrier = new CyclicBarrier(files.length);
        for (int i = 0; i < files.length; i++) {
            try {
                MultipartFile file = files[i];
                //TODO 使用CountDownLaunch或者ComplatableFuture或者Semaphore
                //来完成多线程的文件上传
                fileThreadPool.submit(() -> {
                    try {
                        String url = uploadFile(file);
                        list.add(url);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {
                        //表示一个文件已经被完成
                        try {
                            //进入await
                            cyclicBarrier.await(10,TimeUnit.SECONDS);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        } catch (BrokenBarrierException e) {
                            throw new RuntimeException(e);
                        } catch (TimeoutException e) {
                            throw new RuntimeException(e);
                        }
                    }
                });
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return list;
    }

实测

然后就是上传多个文件,并且发送请求了,下面是一个简单的请求模板,可以发现我上传完毕文件之后,他返回给我了本地的这个文件的位置,当然,这个文件的url地址啥的你们自己与前端对接完毕即可,我这里是多个url直接封装在一起并且使用英文逗号作为分隔符,具体情况自定义即可。

文件回显

文件的下载回显也比较简单,只要给出文件对应的位置,然后直接去本地加载即可。

这里文件回显暂时不做多线程优化,等后期项目需要了在做

/**
     * 文件下载
     *
     * @param name     文件名称
     * @param response 响应流
     */
    @GetMapping("/download")
    public void download(@RequestParam String name, HttpServletResponse response) {
        //FileInputStream fis = null;
        //ServletOutputStream os = null;
        try (FileInputStream fis = new FileInputStream(new File(name));
             ServletOutputStream os = response.getOutputStream()) {
            //输入流,通过输入流读取文件内容
            //fis = new FileInputStream(new File( name));
            //输出流,通过输出流将文件写回浏览器,在浏览器展示图片
            //os = response.getOutputStream();
            //设置响应的数据的格式
            response.setContentType("image/jpeg");
            int len = 0;
            byte[] buffre = new byte[1024 * 10];
            while ((len = fis.read(buffre)) != -1) {
                os.write(buffre, 0, len);
                os.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }




相关文章
|
28天前
|
数据采集 Java API
Jsoup库能处理多线程下载吗?
Jsoup库能处理多线程下载吗?
|
7天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
9天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
9天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
1月前
|
Java 开发者 微服务
Spring Boot 入门:简化 Java Web 开发的强大工具
Spring Boot 是一个开源的 Java 基础框架,用于创建独立、生产级别的基于Spring框架的应用程序。它旨在简化Spring应用的初始搭建以及开发过程。
54 6
Spring Boot 入门:简化 Java Web 开发的强大工具
|
18天前
|
存储 JavaScript 前端开发
基于 SpringBoot 和 Vue 开发校园点餐订餐外卖跑腿Java源码
一个非常实用的校园外卖系统,基于 SpringBoot 和 Vue 的开发。这一系统源于黑马的外卖案例项目 经过站长的进一步改进和优化,提供了更丰富的功能和更高的可用性。 这个项目的架构设计非常有趣。虽然它采用了SpringBoot和Vue的组合,但并不是一个完全分离的项目。 前端视图通过JS的方式引入了Vue和Element UI,既能利用Vue的快速开发优势,
91 13
|
9天前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
85 2
|
2月前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景,并结合代码示例和实用技巧,帮助开发者有效避免这些陷阱,提升并发程序的稳定性和性能。 ####
|
2月前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
26天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱,并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手,逐步深入到具体的代码示例,帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者,都能从中获得有价值的见解和建议。 ####