# 1. 拉取 MinIO 鏡像（最新穩(wěn)定版）
docker pull minio/minio:latest

# 2. 啟動 MinIO 容器（配置密鑰、掛載數(shù)據(jù)卷、設置控制臺端口）
docker run -d --name minio -p 9000:9000 -p 9001:9001 \
  -v minio-data:/data \ # 掛載數(shù)據(jù)卷，持久化存儲文件
  -e MINIO_ROOT_USER=minioadmin \ # Access Key（管理員賬號）
  -e MINIO_ROOT_PASSWORD=minioadmin123 \ # Secret Key（管理員密碼，需8位以上）
  minio/minio server /data --console-address ":9001"

<!-- MinIO Java SDK 依賴 -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.2</version>
</dependency>
<!-- Web 依賴 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<!-- 工具類依賴（處理文件名稱、格式） -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.20</version>
</dependency>

# MinIO 配置
minio:
  endpoint: http://localhost:9000 # API 訪問地址
  access-key: minioadmin # Access Key
  secret-key: minioadmin123 # Secret Key
  bucket-name: user-avatar # 默認存儲桶名稱
  preview-expire: 3600 # 預覽鏈接過期時間（秒，默認1小時）

# 服務端口
server:
  port: 8083

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MinIOConfig {
    @Value("${minio.endpoint}")
    private String endpoint;

    @Value("${minio.access-key}")
    private String accessKey;

    @Value("${minio.secret-key}")
    private String secretKey;

    // 注入 MinIO 客戶端
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }
}

import cn.hutool.core.io.FastByteArrayOutputStream;
import cn.hutool.core.util.RandomUtil;
import io.minio.*;
import io.minio.http.Method;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class MinIOUtils {
    @Resource
    private MinioClient minioClient;

    @Value("${minio.bucket-name}")
    private String defaultBucketName;

    @Value("${minio.preview-expire}")
    private Integer previewExpire;

    /**
     * 上傳文件（默認存儲桶，自動生成文件名避免重復）
     * @param file 上傳文件
     * @return 文件訪問路徑（預覽鏈接）
     */
    public String uploadFile(MultipartFile file) throws Exception {
        return uploadFile(file, defaultBucketName);
    }

    /**
     * 上傳文件（指定存儲桶）
     * @param file 上傳文件
     * @param bucketName 存儲桶名稱
     * @return 文件訪問路徑
     */
    public String uploadFile(MultipartFile file, String bucketName) throws Exception {
        // 1. 校驗存儲桶是否存在，不存在則創(chuàng)建
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            log.info("存儲桶 {} 不存在，已自動創(chuàng)建", bucketName);
        }

        // 2. 處理文件名（原文件名+隨機字符串，避免重復）
        String originalFilename = file.getOriginalFilename();
        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
        String fileName = RandomUtil.randomString(16) + suffix; // 16位隨機字符串+后綴

        // 3. 上傳文件到 MinIO
        minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(fileName) // 存儲到 MinIO 的文件名
                        .stream(file.getInputStream(), file.getSize(), -1) // 文件流
                        .contentType(file.getContentType()) // 文件類型（如 image/jpeg）
                        .build()
        );

        // 4. 返回文件預覽鏈接
        return getPreviewUrl(bucketName, fileName);
    }

    /**
     * 獲取文件預覽鏈接（帶簽名，過期自動失效）
     * @param bucketName 存儲桶名稱
     * @param fileName 文件名
     * @return 預覽鏈接
     */
    public String getPreviewUrl(String bucketName, String fileName) throws Exception {
        // 生成簽名 URL，支持 GET 方法（預覽/下載）
        return minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .bucket(bucketName)
                        .object(fileName)
                        .method(Method.GET)
                        .expiry(previewExpire, TimeUnit.SECONDS)
                        .build()
        );
    }

    /**
     * 下載文件
     * @param bucketName 存儲桶名稱
     * @param fileName 文件名
     * @param response 響應對象（用于返回文件流）
     */
    public void downloadFile(String bucketName, String fileName, HttpServletResponse response) throws Exception {
        // 1. 獲取文件信息
        StatObjectResponse stat = minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(fileName)
                        .build()
        );

        // 2. 設置響應頭（支持瀏覽器下載）
        response.setContentType(stat.contentType());
        response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, StandardCharsets.UTF_8));

        // 3. 讀取文件流并寫入響應
        try (InputStream in = minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(fileName)
                        .build()
        ); OutputStream out = response.getOutputStream()) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
        }
    }

    /**
     * 刪除文件
     * @param bucketName 存儲桶名稱
     * @param fileName 文件名
     */
    public void deleteFile(String bucketName, String fileName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(fileName)
                        .build()
        );
        log.info("文件 {} 已從存儲桶 {} 中刪除", fileName, bucketName);
    }
}

import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import com.example.minio.utils.MinIOUtils;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;

@RestController
@RequestMapping("/file")
public class FileController {
    @Resource
    private MinIOUtils minIOUtils;

    // ? 上傳文件（默認存儲桶，示例：用戶頭像）
    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) {
        try {
            // 僅允許圖片上傳（業(yè)務限制，可選）
            String contentType = file.getContentType();
            if (contentType == null || !contentType.startsWith("image/")) {
                return "僅支持圖片文件上傳";
            }
            // 上傳并返回預覽鏈接
            String previewUrl = minIOUtils.uploadFile(file);
            return "文件上傳成功，預覽鏈接：" + previewUrl;
        } catch (Exception e) {
            log.error("文件上傳失敗", e);
            return "文件上傳失?。? + e.getMessage();
        }
    }

    // ? 預覽文件（指定存儲桶和文件名）
    @GetMapping("/preview")
    public String getPreviewUrl(
            @RequestParam String bucketName,
            @RequestParam String fileName
    ) {
        try {
            return minIOUtils.getPreviewUrl(bucketName, fileName);
        } catch (Exception e) {
            log.error("獲取預覽鏈接失敗", e);
            return "獲取預覽鏈接失?。? + e.getMessage();
        }
    }

    // ? 下載文件
    @GetMapping("/download")
    public void downloadFile(
            @RequestParam String bucketName,
            @RequestParam String fileName,
            HttpServletResponse response
    ) {
        try {
            minIOUtils.downloadFile(bucketName, fileName, response);
        } catch (Exception e) {
            log.error("文件下載失敗", e);
            response.setStatus(500);
            try {
                response.getWriter().write("文件下載失敗：" + e.getMessage());
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    // ? 刪除文件
    @DeleteMapping
    public String deleteFile(
            @RequestParam String bucketName,
            @RequestParam String fileName
    ) {
        try {
            minIOUtils.deleteFile(bucketName, fileName);
            return "文件刪除成功";
        } catch (Exception e) {
            log.error("文件刪除失敗", e);
            return "文件刪除失?。? + e.getMessage();
        }
    }
}

// 示例：設置存儲桶策略（允許上傳，禁止刪除）
String policyJson = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:PutObject\"],\"Resource\":[\"arn:aws:s3:::user-avatar/*\"]}]}";
minioClient.setBucketPolicy(
        SetBucketPolicyArgs.builder()
                .bucket("user-avatar")
                .config(policyJson)
                .build()
);

# 分布式部署命令（4節(jié)點示例，需提前準備多臺服務器）
docker run -d --name minio-cluster \
  -p 9000:9000 -p 9001:9001 \
  -e MINIO_ROOT_USER=minioadmin \
  -e MINIO_ROOT_PASSWORD=minioadmin123 \
  minio/minio server \
  http://192.168.0.101/data \
  http://192.168.0.102/data \
  http://192.168.0.103/data \
  http://192.168.0.104/data \
  --console-address ":9001"

// 分片上傳核心邏輯（簡化版）
public String uploadLargeFile(MultipartFile file, String bucketName, String fileName, int chunkIndex, int totalChunks) throws Exception {
    // 1. 上傳分片
    minioClient.putObject(
            PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object("chunks/" + fileName + "/" + chunkIndex)
                    .stream(file.getInputStream(), file.getSize(), -1)
                    .build()
    );
    // 2. 所有分片上傳完成后，合并分片
    if (chunkIndex == totalChunks - 1) {
        // 合并分片邏輯（調(diào)用 MinIO 合并接口）
        minioClient.completeMultipartUpload(/* 合并參數(shù) */);
        return getPreviewUrl(bucketName, fileName);
    }
    return "分片 " + chunkIndex + " 上傳成功";
}