SpringBoot 上传下载文件

已于 2024-09-03 17:17:44 修改
阅读量2.4k 收藏 15
点赞数 9
分类专栏： 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);
    }
}

三、文件校验

1. application.yml

# 上传文件配置
file:
  image:
    # 1MB(字节)
    size: 1048576
    format: png,jpg,jpeg,gif
  video:
    # 30MB(字节)
    size: 31457280
    format: mp4

2. 校验方法

@Service
public class FileService {

	@Value("#{'${file.image.format}'.split(',')}")
    private List<String> imageFormat;

    @Value("#{'${file.video.format}'.split(',')}")
    private List<String> videoFormat;

    @Value("${file.image.size}")
    private Long imageSize;

    @Value("${file.video.size}")
    private Long videoSize;
 
 	public void upload(MultipartFile file) {
        String suffix = fileCheck(file);
        ... ...
    }

	/**
     * 上传文件校验
     *
     * @param file 文件
     * @return 后缀
     */
    public String fileCheck(MultipartFile file) {
        if (file.isEmpty()) {
            System.out.println("上传文件不能为空");
        }
    
        // 文件名
        String fileName = file.getOriginalFilename();
        // 文件大小（单位：字节）
        long fileSize = file.getSize();
        if (StringUtils.isBlank(fileName)) {
            System.out.println("文件错误");
        }
        
        // 获取文件的后缀名
        String suffix = fileName.substring(fileName.lastIndexOf("."));
        if (StringUtils.isBlank(suffix)) {
            System.out.println("文件格式错误");
        }
        suffix = suffix.substring(1).toLowerCase();
        
        if (imageFormat.contains(suffix)) {
            if (fileSize > imageSize) {
                System.out.println("图片不能大于" + videoSize / (1024 * 1024) + "M");
            }
        } else if (videoFormat.contains(suffix)) {
            if (fileSize > videoSize) {
                System.out.println("视频不能大于" + videoSize / (1024 * 1024) + "M");
            }
        } else {
            System.out.println("文件格式错误");
        }
        return suffix;
    }
 }
SpringBoot返回文件让前端下载的几种方式
m0_67393827的博客
02-15 426
一定要搞清楚和的区别，如果搞不清楚的，可以和字符流进行映射，，换成这样你就知道读取内容需要使用Reader，写入需要使用Writer了。返回给前端的是输出流，不需要你显示的去返回（），这样会报错。
springboot上传下载文件
05-06
springboot上传下载文件，基于springmvc，commons-io等组建。能实现上传和下载功能
springboot 各种文件下载方式（最全）
最新发布
yuan19997的博客
04-21 287
【代码】springboot 各种文件下载方式（最全）
SpringBoot文件上传和下载
热门推荐
程序员小王的博客
11-26 1万+
SpringBoot文件上传和下载 一、SpringBoot文件上传 1、SpringMVC文件上传 1、Client处理 选择文件 （1）form表单 选择文件 method="post" （2）enctype="multipart/form-data" (3) 准备文件框<input type="file" name="upload"> 2、服务端准备存储上传文件的目录 新建文件夹 项目/webapp/upload文件 3、开发文件上传Controller public
Springboot 文件上传、文件下载
howeres的博客
10-03 2423
【代码】Springboot 文件上传、文件下载。
SpringBoot文件上传下载
WinnerBear的博客
08-04 7903
上传下载
基于springboot实现的文件下载上传
05-08
利用springboot实现用户注册登录，完善个人资料，文件上传和文件下载，查看自己上传的文件，还有后台管理功能。数据库文件在压缩包中。
SpringBoot实现文件上传和下载.docx
12-10
对于文件下载，可以创建一个`DownloadController`，使用`@GetMapping`处理GET请求。当用户点击链接下载文件时，控制器会调用`StorageService`的`loadAsResource`方法，将文件转换为`Resource`对象，然后使用`...
springboot 管理ftp文件系统，上传，下载，ftp
06-07
7. **文件下载** 下载文件则通过调用`get`或`retrieve`方法实现，指定远程文件路径和本地保存位置。`retrieve`方法会返回一个`InputStreamResource`，可以直接写入文件。 8. **处理目录** `FtpTemplate`也支持...
SpringBoot(31) 整合MinIO实现文件上传与下载
08-17
在本教程中，我们将深入探讨如何使用SpringBoot框架与MinIO进行集成，以实现文件的上传和下载功能。SpringBoot以其简洁的配置和强大的功能深受Java开发者喜爱，而MinIO则是一个高性能的对象存储服务器，适合处理大...
文件上传下载服务springboot实现
10-27
下载文件: 运行jersey-server, 不设置端口的情况下，默认为8080，springboot jar运行方式下默认端口为9000 ...文件路径分割符号请用/替代\...上传下载文件大小在工程jersey-server的配置文件application.properties里设置
SpringBoot上传文件实例下载
03-11
SpringBoot 单文件上传、批量文件上传。SpringMVC 也可以用。
springboot整合vue实现上传下载文件
08-25
在上面的代码中，我们使用了axios.post方法来实现文件上传，并使用axios.get方法来实现文件下载。我们还使用了Blob对象来创建文件下载的URL。 我们可以使用SpringBoot和Vue来实现文件上传和下载功能。这两个框架...
Spring Boot 实现文件上传下载功能
weixin_44814196的博客
10-24 2595
进入前端页面的 URL 为 http://localhost:8080/upload.html。该部分代码为 [2.2 文件上传功能实现](###2.2 文件上传功能实现) 的前端实现。文件下载则只是简单的 GET 请求。现有的 Web 框架都内置了处理文件上传的功能。指定了文件在请求体中的键，后端服务器将通过这个名称来获取文件数据。是用来表示上传的文件，服务器会自动解析该文件并进行处理。，并选择一个文件进行上传。将文件上传的具体逻辑抽象到一个。将文件上传的具体逻辑抽象到一个。请求，下载指定的文件。
spring boot 文件上传下载
记录点滴
10-27 1455
1、在application.properties中添加文件上传的配置信息 在1.x版本中application.properties中的配置信息如下 #文件上传配置 spring.http.multipart.maxFileSize=50Mb spring.http.multipart.maxRequestSize=50Mb 在2.x版本中application.properti...
Spring Boot | Spring Boot中进行 “文件上传” 和 “文件下载”
m0_70720417的博客
04-14 4970
目录: 一、SpringBoot中进行 " 文件上传" : 1.编写 "文件上传" 的 “表单页面” 2.在全局配置文件中添加文件上传的相关配置 3.进行文件上传处理，实现 "文件上传" 功能 4.效果测试 二、SpringBoot中进行 "文件下载" : “英文名称” 文件下载 : 1.添加文件下载工具依赖 2.定制文件下载页面 3.编写文件下载处理方法 4.效果测试 “中文名称” 文件下载 : 1.添加文件下载工具依赖 2.定制文件下载页面 3.编写文件下载处理方法 4.效果测试 .....
Spring Boot 文件上传与下载
这个需求，做不了
11-03 1342
Spring MVC Spring Boot 文件上传下载以及上传下载的大小限制
springboot 上传下载文件
07-27
要实现Spring Boot和Vue的文件上传和下载，可以考虑使用前后端分离的方式，前端Vue通过axios或者其他HTTP客户端发送请求到后端Spring Boot的上传或者下载接口，后端通过MultipartFile将文件上传到服务器或者从服务器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值