Minio文件上传（去重实现‘秒传功能‘）超详细保姆级别教程（Java技术栈）

已于 2025-07-15 21:08:01 修改
阅读量853 收藏 27
点赞数 12
CC 4.0 BY-SA版权
文章标签： java minio docker
于 2025-07-15 15:12:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_87416698/article/details/149352829

一、docker安装

  • 打开服务器

sudo tee /etc/docker/daemon.json <<-'EOF'

{

    "registry-mirrors": [

        "https://mirror.ccs.tencentyun.com",

        "https://docker.m.daocloud.io",

        "https://docker.mirrors.ustc.edu.cn",

        "https://docker.nju.edu.cn"

    ]

}

EOF

复制这条命令注意这里缩进，否则无法正常执行！！！！

  • 重启docker服务：sudo systemctl daemon-reload

                sudo systemctl restart docker

                                   sudo systemctl enable docker

查看版本号：docker --version

 按顺序执行命令即可，由于我已经安装过了，就不赘述了。最终执行 docker --version命令，出现版本号就表示安装成功了。如下图。

二、编写docker-compose.yaml文件

version: '1.0'

services:

  minio:

    image: minio/minio:latest

    container_name: minio

    network_mode: host

    restart: always

    environment:

        #账号

      MINIO_ACCESS_KEY: root

        #密码

      MINIO_SECRET_KEY: root123456

    volumes:

      - /usr/local/minio/data:/data

      - /usr/local/minio/config:/root/.minio

    command: ["server", "/data", "--console-address=:9001", "--address=:9000"]

由于我使用的是目录挂载方式，需要手动创建config及data目录，在启动前需执行以下两条命令。

mkdir -p /usr/loca/minio/config

mkdir -p /usr/loca/minio/data

 在docker-compose.yaml所在目录下执行docker compose up -d命令 即可启动

docker ps 命令可查看minio容器是否运行成功

 可以看到minio已经成功运行了。如启用了防火墙需开放9000，9001端口

systemctl start firewalld  启动防火墙

systemctl enable firewalld 开机自启

firewall-cmd --permanent --add-port=9000/tcp  开放9000端口

firewall-cmd --permanent --add-port=9001/tcp  开放9001端口

firewall-cmd --reload  重载防火墙配置

firewall-cmd --list-ports 查看已开放端口

 执行上面命令后通过 firewall-cmd --list-ports 命令 可查看已开放端口

 这样你的minio环境就部署完毕。可通过你宿主的ip访问9000端口，出现如下界面就说明你成功部署了。如访问失败，请仔细查阅文档，是否配置有误。

三、配置编写

3.1 application.yml

accessKey:账号
secretKey:密码
bucketName:存储桶名
imgSize:文件大小
fileSize:文件大小
endpoint:ip地址

3.2 Maven核心配置

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.4.5</version>
</parent>
<dependencies>
       <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.7</version>
        </dependency>
</dependencies>

四、MinioConfig配置类编写

package yjh.config;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import yjh.utils.MinIOUtils;

@Data
@Configuration
@ConfigurationProperties(prefix = "minio") //这里对应配置文件minio,属性名需要和配置文件一致
public class MinIoConfig {
    @Schema(description = "MinIO服务地址")
    private  String endpoint;
    @Schema(description = "MinIO存储桶")
    private  String bucketName;
    @Schema(description = "MinIO用户名")
    private  String accessKey;
    @Schema(description = "MinIO密码")
    private  String secretKey;
    @Schema(description = "图片大小限制")
    private  Integer imgSize;
    @Schema(description = "文件大小限制")
    private  Integer fileSize;
    //注册工具类，对Minio进行初始化
    @Bean
    public MinIOUtils creatMinioClient() {
        return new MinIOUtils(endpoint, bucketName, accessKey, secretKey, imgSize, fileSize);
    }
}

五、MinioUtils工具类编写

package yjh.utils;

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;

/**
 * MinIO工具类
 */
@Slf4j
public class MinIOUtils {

    @Schema(description = "MinIO客户端")
    private static MinioClient minioClient;
    @Schema(description = "MinIO服务地址")
    private static String endpoint;
    @Schema(description = "MinIO存储桶")
    private static String bucketName;
    @Schema(description = "MinIO用户名")
    private static String accessKey;
    @Schema(description = "MinIO密码")
    private static String secretKey;
    @Schema(description = "图片大小限制")
    private static Integer imgSize;
    @Schema(description = "文件大小限制")
    private static Integer fileSize;


    private static final String SEPARATOR = "/";

    public MinIOUtils() {
        createMinioClient();
    }

    public MinIOUtils(String endpoint, String bucketName, String accessKey, String secretKey, Integer imgSize, Integer fileSize) {
        MinIOUtils.endpoint = endpoint;
        MinIOUtils.bucketName = bucketName;
        MinIOUtils.accessKey = accessKey;
        MinIOUtils.secretKey = secretKey;
        MinIOUtils.imgSize = imgSize;
        MinIOUtils.fileSize = fileSize;
        createMinioClient();
    }

    /**
     * 创建基于Java端的MinioClient
     */
    public void createMinioClient() {
        try {
            if (null == minioClient) {
                log.info("开始创建 MinioClient...");
                minioClient = MinioClient
                                .builder()
                                .endpoint(endpoint)
                                .credentials(accessKey, secretKey)
                                .build();
                createBucketIfNotExists(bucketName);
                log.info("创建完毕 MinioClient...");
            }
        } catch (Exception e) {
            log.error("MinIO服务器异常：{}", e);
        }
    }

    /**
     * 获取上传文件前缀路径
     * @return
     */
    public static String getBasisUrl() {
        return endpoint + SEPARATOR + bucketName + SEPARATOR;
    }

    /******************************  Operate Bucket Start  ******************************/


    /**
     * 启动SpringBoot容器的时候初始化Bucket
     * 如果没有Bucket则创建,并设置为公共可读
     */
    private void createBucketIfNotExists(String bucketName) throws Exception {
        boolean found = bucketExists(bucketName);
        if (!found) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());

            // 设置桶策略为公共可读
            String policyJson = "{"
                    + "  \"Version\":\"2012-10-17\","
                    + "  \"Statement\":["
                    + "    {"
                    + "      \"Effect\":\"Allow\","
                    + "      \"Principal\":\"*\","
                    + "      \"Action\":[\"s3:GetObject\",\"s3:ListBucket\"],"
                    + "      \"Resource\":["
                    + "        \"arn:aws:s3:::" + bucketName + "\","
                    + "        \"arn:aws:s3:::" + bucketName + "/*\""
                    + "      ]"
                    + "    }"
                    + "  ]"
                    + "}";

            minioClient.setBucketPolicy(
                    SetBucketPolicyArgs.builder()
                            .bucket(bucketName)
                            .config(policyJson)
                            .build()
            );

            log.info("Bucket {} 已创建并设置为公共可读", bucketName);
        } else {
            log.info("Bucket {} 已存在", bucketName);
        }
    }

    /**
     *  判断Bucket是否存在，true：存在，false：不存在
     * @return
     * @throws Exception
     */
    public static boolean bucketExists(String bucketName) throws Exception {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }


    /**
     * 获得Bucket的策略
     * @param bucketName
     * @return
     * @throws Exception
     */
    public static String getBucketPolicy(String bucketName) throws Exception {
        String bucketPolicy = minioClient
                                .getBucketPolicy(
                                        GetBucketPolicyArgs
                                                .builder()
                                                .bucket(bucketName)
                                                .build()
                                );
        return bucketPolicy;
    }


    /**
     * 获得所有Bucket列表
     * @return
     * @throws Exception
     */
    public static List<Bucket> getAllBuckets() throws Exception {
        return minioClient.listBuckets();
    }

    /**
     * 根据bucketName获取其相关信息
     * @param bucketName
     * @return
     * @throws Exception
     */
    public static Optional<Bucket> getBucket(String bucketName) throws Exception {
        return getAllBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除Bucket，true：删除成功； false：删除失败，文件或已不存在
     * @param bucketName
     * @throws Exception
     */
    public static void removeBucket(String bucketName) throws Exception {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /******************************  Operate Bucket End  ******************************/


    /******************************  Operate Files Start  ******************************/

    /**
     * 判断文件是否存在
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return
     */
    public static boolean isObjectExist(String bucketName, String objectName) {
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    /**
     * 判断文件夹是否存在
     * @param bucketName 存储桶
     * @param objectName 文件夹名称
     * @return
     */
    public static boolean isFolderExist(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() && objectName.equals(item.objectName())) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    /**
     * 根据文件前缀查询文件
     * @param bucketName 存储桶
     * @param prefix 前缀
     * @param recursive 是否使用递归查询
     * @return MinioItem 列表
     * @throws Exception
     */
    public static List<Item> getAllObjectsByPrefix(String bucketName,
                                                   String prefix,
                                                   boolean recursive) throws Exception {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
            for (Result<Item> o : objectsIterator) {
                Item item = o.get();
                list.add(item);
            }
        }
        return list;
    }

    /**
     * 获取文件流
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return 二进制流
     */
    public static InputStream getObject(String bucketName, String objectName) throws Exception {
        return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 断点下载
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param offset 起始字节的位置
     * @param length 要读取的长度
     * @return 二进制流
     */
    public InputStream getObject(String bucketName, String objectName, long offset, long length)throws Exception {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .offset(offset)
                        .length(length)
                        .build());
    }

    /**
     * 获取路径下文件列表
     * @param bucketName 存储桶
     * @param prefix 文件名称
     * @param recursive 是否递归查找，false：模拟文件夹结构查找
     * @return 二进制流
     */
    public static Iterable<Result<Item>> listObjects(String bucketName, String prefix,
                                                     boolean recursive) {
        return minioClient.listObjects(
                ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .prefix(prefix)
                        .recursive(recursive)
                        .build());
    }

    /**
     * 使用MultipartFile进行文件上传
     * @param bucketName 存储桶
     * @param file 文件名
     * @param objectName 对象名
     * @param contentType 类型
     * @return
     * @throws Exception
     */
    public static ObjectWriteResponse uploadFile(String bucketName, MultipartFile file,
                                                String objectName, String contentType) throws Exception {
        InputStream inputStream = file.getInputStream();
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .contentType(contentType)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 上传本地文件
     * @param bucketName 存储桶
     * @param objectName 对象名称
     * @param fileName 本地文件路径
     */
    public static ObjectWriteResponse uploadFile(String bucketName, String objectName,
                                                String fileName) throws Exception {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(fileName)
                        .build());
    }

    /**
     * 通过流上传文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件对象
     * @param inputStream 文件流
     */
    public static ObjectWriteResponse uploadFile(String bucketName, String objectName, InputStream inputStream) throws Exception {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 创建文件夹或目录
     * @param bucketName 存储桶
     * @param objectName 目录路径
     */
    public static ObjectWriteResponse createDir(String bucketName, String objectName) throws Exception {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    public static String getFileStatusInfo(String bucketName, String objectName) throws Exception {
        return minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()).toString();
    }

    /**
     * 拷贝文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param srcBucketName 目标存储桶
     * @param srcObjectName 目标文件名
     */
    public static ObjectWriteResponse copyFile(String bucketName, String objectName,
                                                 String srcBucketName, String srcObjectName) throws Exception {
        return minioClient.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                        .bucket(srcBucketName)
                        .object(srcObjectName)
                        .build());
    }

    /**
     * 删除文件
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    public static void removeFile(String bucketName, String objectName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 批量删除文件
     * @param bucketName 存储桶
     * @param keys 需要删除的文件列表
     * @return
     */
    public static void removeFiles(String bucketName, List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeFile(bucketName, s);
            } catch (Exception e) {
                log.error("批量删除失败！error:{}",e);
            }
        });
    }

    /**
     * 获取文件外链
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param expires 过期时间 <=7 秒 （外链有效时间（单位：秒））
     * @return url
     * @throws Exception
     */
    public static String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws Exception {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder().expiry(expires).bucket(bucketName).object(objectName).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 获得文件外链
     * @param bucketName
     * @param objectName
     * @return url
     * @throws Exception
     */
    public static String getPresignedObjectUrl(String bucketName, String objectName) throws Exception {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                                                                    .bucket(bucketName)
                                                                    .object(objectName)
                                                                    .method(Method.GET).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 将URLDecoder编码转成UTF8
     * @param str
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
    }

    /******************************  Operate Files End  ******************************/


}

该工具类设计实用，涵盖常见使用场景，可直接集成使用。项目启动时会自动连接并初始化 MinIO 服务，若存储桶不存在则自动创建，并设置为公开访问模式，避免了手动建桶和配置权限的操作，提升开发效率。 

六、创建用于去重功能的表结构

CREATE TABLE `uploaded_files`  (
  `id` bigint(0) NOT NULL AUTO_INCREMENT,
  `hash` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bg_0900_ai_ci NOT NULL,
  `filename` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bg_0900_ai_ci NOT NULL,
  `url` varchar(512) CHARACTER SET utf8mb4 COLLATE utf8mb4_bg_0900_ai_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `hash`(`hash`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bg_0900_ai_ci ROW_FORMAT = Dynamic;

 6.1 创建uploaded_files对应的实体，服务类

6.1.1 service

package yjh.service;

import yjh.entity.UploadedFiles;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author author
 * @since 2025-07-14
 */
public interface IUploadedFilesService extends IService<UploadedFiles> {

}

6.1.2 serviceImpl

package yjh.service.impl;

import yjh.entity.UploadedFiles;
import yjh.mapper.UploadedFilesMapper;
import yjh.service.IUploadedFilesService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author author
 * @since 2025-07-14
 */
@Service
public class UploadedFilesServiceImpl extends ServiceImpl<UploadedFilesMapper, UploadedFiles> implements IUploadedFilesService {

}

6.1.3 entity

package yjh.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;

import java.io.Serial;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 
 * </p>
 *
 * @author author
 * @since 2025-07-14
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("uploaded_files")
public class UploadedFiles implements Serializable {
    @Serial
    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;


    private String hash;


    private String filename;

    private String url;


}

6.1.3Mapper

package yjh.mapper;

import yjh.entity.UploadedFiles;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author author
 * @since 2025-07-14
 */
public interface UploadedFilesMapper extends BaseMapper<UploadedFiles> {

}

6.1.4 Mapper XML

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="yjh.mapper.UploadedFilesMapper">

</mapper>

七、文件上传接口实现

7.1 计算MD5工具类 FileHashUtils

package yjh.utils;

import java.io.InputStream;
import java.security.MessageDigest;

public class FileHashUtils {

    public static String calculateMD5(InputStream inputStream) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] buffer = new byte[8192];
        int bytesRead;

        while ((bytesRead = inputStream.read(buffer)) != -1) {
            md.update(buffer, 0, bytesRead);
        }

        byte[] digest = md.digest();
        StringBuilder sb = new StringBuilder();
        for (byte b : digest) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

 7.2 文件上传Controller编写

package yjh.controller;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import yjh.config.MinIoConfig;
import yjh.entity.UploadedFiles;
import yjh.service.IUploadedFilesService;
import yjh.utils.FileHashUtils;
import yjh.utils.MinIOUtils;
import yjh.vo.ActionResult;

@RestController
@RequestMapping("/common")
@RequiredArgsConstructor
@Tag(name = "文件上传服务", description = "文件上传服务")
public class CommonController {

    private final MinIoConfig minIoConfig;

    private final IUploadedFilesService uploadedFilesService;

    @PostMapping("/uploadFile")
    @Operation(summary = "上传文件", description = "上传文件")
    public ActionResult<String> uploadFile(@RequestParam("file") MultipartFile file) throws Exception {
        try {
            String hash = FileHashUtils.calculateMD5(file.getInputStream());
            UploadedFiles one = uploadedFilesService.getOne(Wrappers.lambdaQuery(UploadedFiles.class).eq(UploadedFiles::getHash, hash), false);
            if (one != null) {
                return ActionResult.success("上传成功", one.getUrl());
            }
            String filename = file.getOriginalFilename();
            MinIOUtils.uploadFile(minIoConfig.getBucketName(), filename, file.getInputStream());
            String path = MinIOUtils.getBasisUrl() + filename;
            one = new UploadedFiles();
            one.setHash(hash);
            one.setFilename(filename);
            one.setUrl(path);
            uploadedFilesService.save(one);
            return ActionResult.success("上传成功", path);
        } catch (Exception e) {
            return ActionResult.fail("文件上传失败：" + e.getMessage());
        }
    }
}

这个接口是用来上传文件的。在上传之前，我会先计算一下文件的 MD5 值。如果数据库里已经有相同 MD5 的文件，就说明这个文件已经传过了，直接返回之前的链接就行，不用再传一遍。

如果没找到相同的文件，才会真正把文件上传到 MinIO，并把文件名、MD5 和访问链接保存到数据库里，方便下次重复使用。

这样做的好处是：节省空间、加快上传速度，还能避免重复上传同一个文件 。

八、通过ApiFox测试是否成功搭建文件上传流程

可以看到，已经成功上传到服务器了

 查看控制台信息

第一次上传时，文件会被正常上传至服务器。第二次上传时，系统会通过计算文件的 MD5 值判断其是否已存在，若存在则直接返回已有链接，实现“秒传”效果。

九、查看minio控制台

可以看到文件已经上传成功了。

十、结语

以上就是我关于文件上传优化的一些实践和总结。通过简单的 MD5 校验，就能实现一个高效又实用的小功能。技术不在于多复杂，而在于能不能解决问题。希望这篇内容对正在学习文件上传的你有所帮助！

余江淮
关注
Minio实现大文件切片上传，断点续传，秒传功能
SR003的博客
08-06 2847
切片上传通过将大文件分成多个小块，逐块上传，有效解决了网络不稳定的问题. 续传允许在上传中断后从中断点继续上传，避免了重新上传整个文件，提高了上传的可靠性。 重复文件秒传通过文件哈希值的校验，实现了文件的快速上传，避免了重复上传相同的文件，节省了时间和带宽。
MinIO上传
xwh041213的博客
01-17 618
MinIO是一个开源的对象存储服务器，兼容Amazon S3 API。它提供了可扩展、高性能和高可用性的存储解决方案，适用于大规模数据存储和分发。MinIO的设计目标是简单易用、轻量级和高度可定制。它可以在企业内部部署，也可以在公有云上使用。MinIO使用分布式架构，可以将数据在多个服务器上进行分片存储，实现高度可扩展性和容错性。通过MinIO，用户可以使用标准的S3 API进行对象存储的操作，例如创建、读取、更新和删除对象。
使用Minio进行文件上传
lzh_de_boke的博客
06-05 518
使用Minio进行文件上传
Minio实现本地文件的上传
m0_64823170的博客
03-01 6858
application.yml中关于Minio的配置代码如下minio:endpoint: http://192.168.160.1:9000 #Minio服务所在地址bucketName: xfs999 #存储桶名称accessKey: YtVsDJy5ZXKsFaNshoXk #访问的keysecretKey: 7yFu7bhTIgyFmFa6YLVysR60QMVIdhnxenN5o4Lh #访问的秘钥。
MinIO文件上传
qq_51179608的博客
08-12 1465
Data配置和创建一个Minio客户端的Spring配置类。配置类声明: 这个注解表示类是一个配置类，Spring容器在启动时会读取这个类中的配置信息。启用配置属性: 这个注解启用了对类的支持，这样就可以将配置文件（如application.properties或application.yml）中的属性自动绑定到对象上。属性注入@Autowired: 通过这个注解，类的实例被自动注入到类中。类应该包含与Minio服务相关的配置属性，如端点URL、访问密钥和秘密密钥。
在springboot中使用MinIO实现文件上传功能
m0_74920346的博客
10-22 2612
如果出现Non-XML response from server的错误，那就很有可能是在yml文件中端口号配置错误了（浏览器访问端口9001，java API端口是9000），我就是端口之前写错过，找了半天qwq。将okhttp升级到4.8.1版本后，还是不行，这时候就要思考是不是okhttp的版本冲突导致，可以通过下载Maven help插件看依赖树，我们可以注意到了报错信息中的。：设置要上传的对象（文件）的名称，表示文件在存储桶中的路径和名称。：设置要上传到的MinIO存储桶（bucket）的名称。
Minio 上传文件夹
m0_63963749的博客
04-08 1023
【代码】Minio 上传文件夹。
java，使用minio实现分片上传、秒传、断点续传，附docker安装文档
01-25
java，minio实现分片上传、秒传、断点续传，附docker安装文档
IT+minio+大文件的分片上传、断点续传、秒传的功能
09-01
minio springboot 实现大文件的分片上传、断点续传、秒传的功能
基于Java写minio客户端实现上传下载文件
08-19
总结起来，通过上述步骤，我们已经成功地构建了一个基于Java的MinIO客户端，实现了文件的上传和下载功能。这个客户端可以方便地集成到任何Java应用程序中，为存储和检索非结构化数据提供了一种高效、安全的方式。在...
Java实现MinIO客户端文件上传下载功能
最新发布
07-05
在本文中，我们将详细探讨如何使用Java实现MinIO客户端，以完成文件的上传和下载操作。MinIO是一种高性能的对象存储服务，适用于存储大量非结构化数据，如图片、文档和视频等。它提供了简洁易用的API，便于开发者...
Java实现MinIO文件服务器
07-04
通过上述步骤，开发者可以轻松地在Java应用中集成MinIO，实现文件的上传、下载、管理等功能，同时享受到MinIO提供的高性能和安全性。在实际项目中，你可以根据具体需求对这些基础操作进行扩展和定制，构建出符合业务...
Minio文件服务器（上传文件）
usa_washington的博客
12-18 1875
Minio文件服务器
Springboot功能模块之文件上传（minio）
qq_62377885的博客
08-03 1385
MinIO存储基于对象存储（Object Storage）是一种数据存储架构，它以对象为单位来处理、存储和检索数据，每个对象都包含了数据本身以及元数据；MinIO存储的元数据主要包括对象的描述信息，如用户（account）、存储桶（bucket）以及存储桶索引（bucket index）等；Bucket 是存储Object的逻辑空间，每个Bucket之间的数据是相互隔离的，对用户而言，相当于存放文件的顶层文件夹；非结构化数据：没有明确结构的数据，比如社交评论、日志文件......
Minio的文件上传
2201_75497315的博客
11-19 803
这个接口是Spring MVC部分的一部分，它提供了一种方便的方式来处理HTTP请求中的文件上传。MinIO 是一种高性能对象存储解决方案，它提供了与 Amazon Web Services S3 兼容的 API，并支持所有核心 S3 功能。MinIO 旨在部署在任何地。
Minio上传数据之上传文件夹（保留文件夹结构）
tiaoteek的博客
05-18 2027
通过 minioClient.fput_object(bucket_name, object_name, file_path)image.jpg，则上传后image为文件夹，文件名为image.jpg；image.jpg，则上传后的名字就是image\image.jpg；bucket_name：存储桶 ，放数据的地方。object_name：在存储桶中的名字。如果object_name为image。如果object_name为image。file_path：本地数据位置。
minio文件上传hash去重校验的详细代码
06-01
以下是使用MinIO进行文件上传hash去重校验的详细代码示例，其中假设已经安装并启动了MinIO服务，并创建了一个名为“test-bucket”的存储桶。 ```python import hashlib from minio import Minio from minio.error import ResponseError # 创建MinIO客户端对象 client = Minio('localhost:9000', access_key='ACCESS_KEY', secret_key='SECRET_KEY', secure=False) # 上传文件并进行hash去重校验 def upload_file(file_path, bucket_name, object_name): try: # 打开文件并计算MD5哈希值 with open(file_path, 'rb') as file: file_data = file.read() md5_hash = hashlib.md5(file_data).hexdigest() # 判断文件是否已经存在于存储桶中 object_exists = client.stat_object(bucket_name, md5_hash) # 文件已经存在，停止上传并返回文件URL if object_exists: object_url = client.presigned_url('GET', bucket_name, md5_hash) print(f'File already exists: {object_url}') return object_url # 文件不存在，进行上传操作 else: # 上传文件并指定对象名称 client.put_object(bucket_name, object_name, file_data, len(file_data)) # 在对象上设置元数据，将MD5哈希值作为对象名称 client.set_object_metadata(bucket_name, object_name, {'md5': md5_hash}) # 返回文件URL object_url = client.presigned_url('GET', bucket_name, object_name) print(f'File uploaded successfully: {object_url}') return object_url except ResponseError as err: print(f'MinIO error occurred: {err}') ``` 在上述示例代码中，首先创建了一个MinIO客户端对象，并定义了一个名为“upload_file”的函数来实现文件上传和hash去重校验的逻辑。具体而言，该函数接受三个参数：文件路径、存储桶名称和对象名称。在函数内部，首先使用Python内置的hashlib库计算文件的MD5哈希值，然后通过调用MinIO客户端对象的“stat_object”方法判断文件是否已经存在于存储桶中。如果文件已经存在，函数会返回该文件的URL并停止上传操作；否则，函数会调用MinIO客户端对象的“put_object”方法将文件上传到存储桶中，并使用“set_object_metadata”方法在对象上设置元数据，将MD5哈希值作为对象名称。最后，函数会返回上传文件的URL。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值