SpringBoot 上传下载文件

已于 2024-07-12 17:27:58 修改
阅读量600 收藏 7
点赞数 8
分类专栏： SpringBoot 文章标签： spring boot 后端 java
于 2023-12-11 14:28:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baihaibo1024/article/details/134925125
版权

一、本地服务器上传下载

1. pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.6.3</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.15.0</version>
</dependency>

2. application.yml

spring:
  servlet:
    multipart:
      max-request-size: 500MB
      max-file-size: 500MB

3. 创建接口类

import org.apache.commons.io.FileUtils;
import org.springframework.http.ContentDisposition;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

@RestController
public class FileController {

    /**
     * 文件上传到服务器
     */
    @PostMapping(value = "/upload", produces = MediaType.APPLICATION_JSON_VALUE)
    public void upload(@RequestPart("file") MultipartFile file) {
        try {
            String filePath = "d:/" + file.getOriginalFilename();
            File writeFile = new File(filePath);
            FileUtils.copyInputStreamToFile(file.getInputStream(), writeFile);
            // TODO: 文件上传后自定义处理
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 本地文件下载到客户端
     */
    @PostMapping(value = "/down", produces = MediaType.APPLICATION_JSON_VALUE)
    public void down(@RequestParam("fileName") String fileName, HttpServletResponse response) {

        // TODO: 文件在服务器中的绝对路径
        String filePath = "d:/" + fileName;
        try (InputStream inputStream = new FileInputStream(filePath); ServletOutputStream outputStream = response.getOutputStream();) {
            response.reset();
            response.addHeader("Content-Type", MediaType.APPLICATION_OCTET_STREAM_VALUE);
            ContentDisposition disposition = ContentDisposition.builder("attachment")
                    .filename(new String(URLEncoder.encode(fileName, "UTF-8")
                            .getBytes(StandardCharsets.UTF_8), StandardCharsets.ISO_8859_1)).build();
            response.addHeader("Content-Disposition", disposition.toString());

            byte[] buffer = new byte[1024];
            int len;
            while ((len = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 网络文件下载到客户端
     */
    @PostMapping(value = "/netDown", produces = MediaType.APPLICATION_JSON_VALUE)
    public void netDown(@RequestParam("net") String net, @RequestParam("fileName") String fileName, HttpServletResponse response) {
        InputStream inputStream = null;
        ServletOutputStream outputStream = null;
        try {
            URL url = new URL(net);
            URLConnection connection = url.openConnection();
            inputStream = connection.getInputStream();
            response.reset();

            response.addHeader("Content-Type", connection.getContentType());
            ContentDisposition disposition = ContentDisposition.builder("attachment")
                    .filename(new String(URLEncoder.encode(fileName, "UTF-8")
                            .getBytes(StandardCharsets.UTF_8), StandardCharsets.ISO_8859_1)).build();
            response.addHeader("Content-Disposition", disposition.toString());

            outputStream = response.getOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

二、Minio 上传下载

1. pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>3.2.6</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.34</version>
</dependency>
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.2.2</version>
    <exclusions>
        <exclusion>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </exclusion>
        <exclusion>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

2. application.yml

server:
  port: 8888

minio:
  # 对象存储服务的 URL
  endpoint: http://127.0.0.1:9001/
  # 用户名
  accessKey: admin
  # 密码
  secretKey: 12345678
  # 桶名称
  bucketName: test

3. 创建配置类

MinioProperties

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * Minio 参数
 */
@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProperties {

    /**
     * Minio 连接地址
     */
    private String endpoint;

    /**
     * 用户名
     */
    private String accessKey;

    /**
     * 密码
     */
    private String secretKey;

    /**
     * 桶名称
     */
    private String bucketName;
}

MinioConfig

import io.minio.MinioClient;
import jakarta.annotation.Resource;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Minio 配置类
 */
@Configuration
@EnableConfigurationProperties(MinioProperties.class)
public class MinioConfig {

    @Resource
    private MinioProperties minioProperties;

    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(minioProperties.getEndpoint())
                .credentials(minioProperties.getAccessKey(), minioProperties.getSecretKey())
                .build();
    }
}

4. 创建工具类

MinioUtils

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.*;

/**
 * Minio 工具类
 */
@Component
public class MinioUtils {

    @Resource
    private MinioClient minioClient;

    /**
     * 创建 Bucket
     */
    public void createBucket(String bucketName) {
        try {
            if (bucketExists(bucketName)) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 获取全部 bucket
     */
    public List<String> getAllBuckets() {
        List<String> list = null;
        try {
            final List<Bucket> buckets = minioClient.listBuckets();
            list = new ArrayList<>(buckets.size());
            for (Bucket bucket : buckets) {
                list.add(bucket.name());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }


    /**
     * 根据 bucketName 获取信息
     */
    public Optional<Bucket> getBucket(String bucketName) {
        try {
            return minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
        } catch (Exception e) {
            e.printStackTrace();
            return Optional.empty();
        }
    }


    /**
     * 文件上传
     */
    public Map<String, Object> uploadFile(String bucketName, MultipartFile[] file) {
        List<String> orgfileNameList = new ArrayList<>(file.length);
        for (MultipartFile multipartFile : file) {
            String fileName = multipartFile.getOriginalFilename();
            orgfileNameList.add(fileName);
            try {
                InputStream in = multipartFile.getInputStream();
                minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(fileName)
                        .stream(in, multipartFile.getSize(), -1).contentType(multipartFile.getContentType())
                        .build());
                in.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        Map<String, Object> data = new HashMap<>();
        data.put("bucketName", bucketName);
        data.put("fileName", orgfileNameList);
        return data;
    }


    /**
     * 获取上传文件的完整路径
     *
     * @param bucketName 桶名称
     * @param fileName   文件名
     */
    public String getPresetObjectUrl(String bucketName, String fileName) {
        // 验证桶是否存在在
        final boolean validationBucket = bucketExists(bucketName);
        if (!validationBucket) {
            return null;
        }
        // 验证文件是否存在
        final boolean validationFileName = doFileNameExist(bucketName, fileName);
        if (!validationFileName) {
            return null;
        }
        String url = null;
        try {
            // 获取桶和文件的完整路径
            url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .bucket(bucketName).object(fileName).method(Method.GET).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return url;
    }


    /**
     * 创建文件夹或目录
     *
     * @param bucketName 存储桶
     * @param objectName 目录路径
     */
    public Map<String, String> putDirObject(String bucketName, String objectName) {
        try {
            if (!bucketExists(bucketName)) {
                return null;
            }
            final ObjectWriteResponse response = minioClient.putObject(
                    PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                                    new ByteArrayInputStream(new byte[]{}), 0, -1)
                            .build());
            Map<String, String> map = new HashMap<>();
            map.put("etag", response.etag());
            map.put("versionId", response.versionId());
            return map;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 判断文件是否存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件夹名称（去掉 /）
     */
    public boolean doFolderExist(String bucketName, String objectName) {
        boolean exist = false;
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir()) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }


    /**
     * 文件下载
     */
    public void downloadFile(HttpServletResponse response, String bucketName, String fileName) {
        if (!doFileNameExist(bucketName, fileName)) {
            return;
        }
        InputStream in = null;
        try {
            StatObjectResponse stat = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
            response.setContentType(stat.contentType());
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
            IOUtils.copy(in, response.getOutputStream());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    /**
     * 删除文件
     *
     * @param bucketName bucket名称
     * @param fileName   文件名称
     */
    public void deleteFile(String bucketName, String fileName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 批量文件删除
     *
     * @param bucketName bucket名称
     * @param fileNames  文件名
     */
    public void deleteBatchFile(String bucketName, List<String> fileNames) {
        try {
            List<DeleteObject> objects = new LinkedList<>();
            for (String fileName : fileNames) {
                objects.add(new DeleteObject(fileName));
            }
            Iterable<Result<DeleteError>> results =
                    minioClient.removeObjects(
                            RemoveObjectsArgs.builder().bucket(bucketName).objects(objects).build());
            for (Result<DeleteError> result : results) {
                DeleteError error = result.get();
                System.out.println("删除失败" + error);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 判断文件是否存在
     */
    private boolean doFileNameExist(String bucketName, String fileName) {
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }


    /**
     * 验证 bucketName 是否存在
     */
    private boolean bucketExists(String bucketName) {
        boolean flag = true;
        try {
            flag = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }
}

5. 创建业务类

MinioController

import com.cnbai.utils.MinioUtils;
import io.minio.messages.Bucket;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;
import java.util.Map;
import java.util.Optional;

@RestController
public class MinioController {

    @Resource
    private MinioUtils minioUtils;

    /**
     * 创建 Bucket
     */
    @GetMapping("/createBucket")
    public void createBucket(String bucketName) {
        minioUtils.createBucket(bucketName);
    }


    /**
     * 获取全部 Bucket
     */
    @GetMapping("/getAllBuckets")
    public List<String> getAllBuckets() {
        return minioUtils.getAllBuckets();
    }


    /**
     * 根据 bucketName 获取信息
     */
    @GetMapping("/getBucket")
    public Optional<Bucket> getBucket(String bucketName) {
        return minioUtils.getBucket(bucketName);
    }


    /**
     * 判断文件是否存在
     */
    @GetMapping("/doFolderExist")
    public boolean doFolderExist(String bucketName, String fileName) {
        return minioUtils.doFolderExist(bucketName, fileName);
    }


    /**
     * 创建文件夹或目录
     */
    @GetMapping("/putDirObject")
    public Map<String, String> putDirObject(String bucketName, String fileName) {
        return minioUtils.putDirObject(bucketName, fileName);
    }


    /**
     * 上传文件
     */
    @PostMapping("/uploadFiles")
    public Map<String, Object> uploadFiles(String bucketName, @RequestParam(name = "file") MultipartFile[] file) {
        return minioUtils.uploadFile(bucketName, file);
    }


    /**
     * 获取上传文件的完整浏览路径
     */
    @GetMapping("/getPresetObjectUrl")
    public String getPresetObjectUrl(@RequestParam(name = "filename") String filename) {
        return minioUtils.getPresetObjectUrl("test", filename);
    }


    /**
     * 文件下载
     */
    @GetMapping("/downloadFile")
    public void downloadFile(HttpServletResponse response, @RequestParam("fileName") String fileName) {
        minioUtils.downloadFile(response, "test", fileName);
    }


    /**
     * 删除单个文件
     */
    @DeleteMapping("/deleteFile")
    public void deleteFile(String bucketName, String fileName) {
        minioUtils.deleteFile(bucketName, fileName);
    }


    /**
     * 批量删除文件
     */
    @DeleteMapping("/deleteBatchFile")
    public void deleteBatchFile(String bucketName, @RequestParam("fileNames") List<String> fileNames) {
        minioUtils.deleteBatchFile(bucketName, fileNames);
    }
}
baihb1024
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot文件上传下载
HealerJean梦想博客
04-26 335
前言 博主github 博主个人博客http://blog.healerjean.com 习惯了使用OSS傻瓜式上传，是不是都快忘记写原生的上传了，今天小米的项目中需要用一下，所以之类简单总结下 吧 MultipartFile file 方法名字 内容 file.getContentType() image/png file.getOriginalFilename() AAAA...
SpringBoot 文件上传与下载
ycfxhsw的博客
09-20 110
前端页面 <!DOCTYPE html> <html xmlns:th="http://www.thymeleaf.org"> <head> <meta http-equiv="Content-type" content="text/html; charset=UTF-8"> <title>文件上传</title> </head> <body> <form method=
SpringBoot实现文件上传和下载.docx
12-10
SpringBoot实现文件上传和下载
Spring Boot实现文件上传与下载
热门推荐
null
03-27 6万+
上面接口是要下载logs文件夹下日志文件，以log_20190218.log日志文件为例，浏览器直接访问 http://127.0.0.1:8090/springbootdemo/log/download/log_20190218.log 即可完成下载。上面我们上传文件的客户端为HTML页面，但我们实际生产中未必是WebAPP，这时我们可以通过模拟发送浏览器HTTP请求来实现上传文件。点击选择文件打开文件选择页面，选中需要上传的文件后，点击提交，返回如下则为文件上传成功。点击提交，返回如下则为上传成功。
Spring Boot中的文件下载实现
最新发布
微赚淘客系统开发者博客
06-27 672
文件下载是Web应用程序中常见的功能之一，特别是在需要向用户提供生成的报告、用户上传的文件或其他动态生成的内容时。Spring Boot提供了简单而强大的方式来处理文件下载，同时提供了安全性和性能的保证。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨一下在Spring Boot中如何实现文件下载的技术细节和最佳实践。系统将返回一个包含文件内容的响应，并自动提示下载。方法处理下载请求，根据请求的文件名构建文件路径，并创建一个。
SpringBoot实现文件上传和下载实现全过程（值得珍藏）
01-21
Spring Boot是一个开源的Java框架，用于快速创建独立、可运行的、生产级别的Spring应用程序。它简化了Spring应用程序的创建和部署，使得开发人员能够专注于业务逻辑而不是繁琐的配置工作。 Spring Boot实现文件上传和下载过程如下： 文件上传： 添加Web依赖，创建一个Controller类。 添加处理文件上传的POST请求方法，使用MultipartFile接收上传文件。 验证文件，保存到服务器文件系统。 返回响应给客户端。 文件下载： 创建Controller类，添加处理文件下载的GET请求方法。 根据请求参数找到要下载的文件，设置响应头信息。 将文件作为响应体返回给客户端。 添加权限控制（可选）。 这个过程需要注意安全性和性能问题，例如验证上传文件来源、防止恶意文件上传、优化读写性能等。
SpringBoot实现文件上传和下载
qq_55896432的博客
09-29 2万+
本文主要讲了文件上传和下载的实现方式。关键是文件下载后端多种实现方式以及前端通过window.open、ajax和axios实现文件下载。
Springboot实现文件下载的方式
weixin_39557697的博客
10-09 3420
【代码】Springboot实现文件下载的方式。
springboot如何实现文件下载呢？
qq_25073223的博客
11-18 5367
springboot实现文件下载的方法分享
springboot：各种下载文件的方式
拒绝熬夜啊的博客
06-02 2万+
springboot：各种下载文件的方式
文件上传下载服务springboot实现
10-27
下载文件: 运行jersey-server, 不设置端口的情况下，默认为8080，springboot jar运行方式下默认端口为9000 ...文件路径分割符号请用/替代\...上传下载文件大小在工程jersey-server的配置文件application.properties里设置
springboot上传下载文件
05-06
对于文件下载功能，Spring MVC同样提供了便捷的方法。创建一个`@GetMapping`方法，返回一个` ResponseEntity`对象，设置适当的HTTP头信息和文件内容。以下是一个示例： ```java @GetMapping("/download") public ...
SpringBoot实现文件上传和下载功能源码
12-10
`handleFileDownload`方法负责提供文件下载服务。它创建一个`ResponseEntity`，设置`Content-Disposition`头为"attachment"，这样浏览器会弹出下载对话框。通过`InputStreamResource`，我们可以将文件流直接返回给...
SpringBoot实现文件下载
polo2044的专栏
07-04 1万+
本文纯属转载，主要是为了方便后续参考和继续使用，转载自博客Spring Boot项目实现下载项目根目录下指定目录(doc)里的文件。 代码参考如下： 一、接收页面下载的请求，开始下载项目中的文件 @RequestMapping("downloadFile") @ResponseBody public void Download(HttpServletResponse response) {...
SpringBoot 如何实现文件上传和下载
IT徐师兄
05-27 6439
在本文中，我们介绍了Spring Boot如何实现文件上传和下载，包括依赖、配置、Controller和模板的编写。通过本文，您应该能够了解文件上传和下载在Spring Boot中的实现方式，并可以使用相应的代码示例进行实践。Spring Boot提供了简单且易于使用的方式来实现文件上传和下载，这对于许多Web应用程序来说是非常重要的功能。在实现文件上传和下载时，需要注意安全性和文件大小的限制，并根据实际需求进行相应的配置。
springboot文件下载
weixin_35755188的博客
01-06 2399
Spring Boot 文件下载是指从 Web 应用程序中下载文件的过程。 要在 Spring Boot 中实现文件下载功能，你需要做以下几件事： 在 Spring Boot 项目中添加对 Servlet 和 Apache Commons FileUpload 的依赖。 创建一个控制器方法来处理文件下载请求。 使用 ResponseEntity 对象将文件内容和相关信息作为响应返回给客户端。...
SpringBoot实现文件下载的几种方式
开始的博客
10-14 5万+
1. 将文件以流的形式一次性读取到内存，通过响应输出流输出到前端 2. 将输入流中的数据循环写入到响应输出流中，而不是一次性读取到内存，通过响应输出流输出到前端 3. 下载网络文件到本地 4. 网络文件获取到服务器后，经服务器处理后响应给前端...
SpringBoot下载文件的正确方式~
dubulingbo的博客
03-18 1万+
Spring Boot 在文件流下载时，加入异常报警，更具灵活性
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值