在 Spring Boot 中集成 MinIO 对象存储

docker pull minio/minio

mkdir -p /data/minio/data /data/minio/config

docker run -p 9090:9090 -p 9000:9000 --name minio \
  -v ~/data/minio/data:/data \
  -v ~/data/minio/config:/root/.minio \
  -e "MINIO_ACCESS_KEY=minio" \
  -e "MINIO_SECRET_KEY=minio123" \
  minio/minio server /data --console-address ":9090"

version: '3.9'
services:
    minio:
        command: 'server /data --console-address ":9090"'
        image: minio/minio
        environment:
            - MINIO_SECRET_KEY=minio123
            - MINIO_ACCESS_KEY=minio
        volumes:
            - '~/data/minio/config:/root/.minio'
            - '~/data/minio/data:/data'
        container_name: minio
        ports:
            - '9000:9000'
            - '9090:9090'

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.5</version>
</dependency>

# MinIO配置
minio.endpoint=http://localhost:9000  # MinIO服务器的地址
minio.access-key=minio     # 您的访问密钥
minio.secret-key=minio123     # 您的秘密密钥

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;
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }
}

import io.minio.GetObjectArgs;
import io.minio.GetObjectResponse;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import okhttp3.Headers;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
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 java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
@RestController
@RequestMapping("/minio")
public class MinioController {
    @Autowired
    private MinioClient minioClient;
    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) {
        try {
            /**
             * 使用 UUID 作为对象名称:
             * 1. 唯一性，避免对象名称冲突。
             * 2. 隐藏实际文件信息，提高一定的隐私。
             * 3. 对象名称不受原始文件名长度或特殊字符的限制。
             * 在实际场景中，如果你更注重文件的可识别性和管理，可以考虑使用文件名称。如果你更注重唯一性和隐私性，可以考虑使用 UUID。
             * 同时，你也可以结合两者，例如将文件名作为对象属性存储，然后使用 UUID 作为对象名称。这样既可以保留文件信息，又能保证唯一性。
             */
            String objectName = UUID.randomUUID().toString();
            Map<String, String> metadata = new HashMap<>();
            metadata.put("originalFilename", file.getOriginalFilename());
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket("firsttest")
                            .object(objectName)
                            .userMetadata(metadata)
                            .stream(file.getInputStream(), file.getSize(), -1)
                            .contentType(file.getContentType())
                            .build()
            );
            return "File uploaded successfully!  fileId: " + objectName;
        } catch (Exception e) {
            return "Error uploading file: " + e.getMessage();
        }
    }
    @GetMapping("/download/{filename}")
    public ResponseEntity<InputStreamResource> downloadFile(@PathVariable("filename") String filename) {
        try {
            Optional<GetObjectResponse> inputStream = Optional.ofNullable(minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket("firsttest")
                            .object(filename)
                            .build()
            ));
            if (inputStream.isPresent()) {
                InputStreamResource resource = new InputStreamResource(inputStream.get());
                Headers headers = inputStream.get().headers();
                ResponseEntity.BodyBuilder bodyBuilder = ResponseEntity.ok();
                String mediaType = headers.get("Content-Type");
                if (StringUtils.isNotEmpty(mediaType)) {
                    bodyBuilder.contentType(MediaType.parseMediaType(mediaType));
                }
                return bodyBuilder.header("Content-Disposition", "attachment; filename=" + URLEncoder.encode(headers.get("X-Amz-Meta-originalfilename"), StandardCharsets.UTF_8))
                        .body(resource);
            } else {
                return ResponseEntity.notFound().build();
            }
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(null);
        }
    }
}