RustFS接口實戰：Java+Docker實現實時上傳下載，代碼拿來即用！詳情 - eureka,雲原生,RustFS,企業存儲,開發語言,Html,CSS,前端開發 u_17499862 博客

在日常開發中，對象存儲的集成總讓人頭疼？本文通過完整可運行的Java代碼，手把手教你實現RustFS的實時上傳下載功能，帶你徹底告別集成難題！

一、環境準備：5分鐘快速搭建RustFS服務

1.1 Docker一鍵啓動RustFS

1.2 驗證服務可用性

二、Java項目配置：依賴引入與客户端初始化

2.1 Maven依賴配置

2.2 RustFS配置類

2.3 應用配置文件

三、核心服務層：上傳下載功能實現

3.1 存儲服務接口設計

3.2 RustFS服務實現類

四、RESTful API控制器：提供HTTP接口

4.1 文件上傳下載控制器

五、高級功能：大文件分片上傳

5.1 分片上傳服務類

六、功能測試與驗證

6.1 使用curl測試API接口

6.2 使用Postman測試

七、生產環境優化建議

7.1 連接池配置優化

7.2 異常處理增強

八、完整項目結構

總結

一、環境準備：5分鐘快速搭建RustFS服務

1.1 Docker一鍵啓動RustFS

首先使用Docker快速搭建RustFS服務環境：

# 創建項目目錄
mkdir rustfs-java-demo && cd rustfs-java-demo

# 創建docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'
services:
  rustfs:
    image: rustfs/rustfs:latest
    container_name: rustfs-server
    ports:
      - "9000:9000"  # S3 API端口
      - "9001:9001"  # 控制枱端口
    environment:
      RUSTFS_ACCESS_KEY: "admin"
      RUSTFS_SECRET_KEY: "password123"
    volumes:
      - ./data:/data
    restart: unless-stopped
EOF

# 啓動服務
docker-compose up -d

# 驗證服務狀態
docker ps | grep rustfs

1.2 驗證服務可用性

# 檢查服務健康狀態
curl http://localhost:9000/minio/health/live

# 訪問Web控制枱
echo "控制枱地址: http://localhost:9001"
echo "用户名: admin"
echo "密碼: password123"

二、Java項目配置：依賴引入與客户端初始化

2.1 Maven依賴配置

創建Spring Boot項目，在pom.xml中添加必要依賴：

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- AWS S3 SDK -->
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3</artifactId>
        <version>2.20.0</version>
    </dependency>
    
    <!-- 文件操作工具 -->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.13.0</version>
    </dependency>
</dependencies>

2.2 RustFS配置類

創建配置類RustFSConfig.java：

package com.rustfs.demo.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;

import java.net.URI;

@Configuration
public class RustFSConfig {
    
    @Value("${rustfs.endpoint:http://localhost:9000}")
    private String endpoint;
    
    @Value("${rustfs.access-key:admin}")
    private String accessKey;
    
    @Value("${rustfs.secret-key:password123}")
    private String secretKey;
    
    @Value("${rustfs.region:us-east-1}")
    private String region;
    
    @Bean
    public S3Client s3Client() {
        return S3Client.builder()
                .endpointOverride(URI.create(endpoint))
                .credentialsProvider(StaticCredentialsProvider.create(
                        AwsBasicCredentials.create(accessKey, secretKey)))
                .region(Region.of(region))
                .forcePathStyle(true)  // 必須設置為true用於兼容RustFS
                .build();
    }
}

2.3 應用配置文件

application.yml配置：

rustfs:
  endpoint: "http://localhost:9000"
  access-key: "admin"
  secret-key: "password123"
  region: "us-east-1"
  bucket-name: "my-bucket"

server:
  port: 8080

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

三、核心服務層：上傳下載功能實現

3.1 存儲服務接口設計

創建StorageService.java接口：

package com.rustfs.demo.service;

import org.springframework.web.multipart.MultipartFile;
import java.io.InputStream;

public interface StorageService {
    
    /**
     * 上傳文件到RustFS
     */
    String uploadFile(MultipartFile file, String objectName);
    
    /**
     * 下載文件從RustFS
     */
    InputStream downloadFile(String objectName);
    
    /**
     * 獲取文件訪問URL
     */
    String getFileUrl(String objectName);
    
    /**
     * 刪除文件
     */
    boolean deleteFile(String objectName);
}

3.2 RustFS服務實現類

實現類RustFSService.java：

package com.rustfs.demo.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;

import java.io.IOException;
import java.io.InputStream;
import java.time.Duration;

@Service
@Slf4j
public class RustFSService implements StorageService {
    
    private final S3Client s3Client;
    
    @Value("${rustfs.bucket-name:my-bucket}")
    private String bucketName;
    
    public RustFSService(S3Client s3Client) {
        this.s3Client = s3Client;
        createBucketIfNotExists();
    }
    
    /**
     * 檢查並創建存儲桶
     */
    private void createBucketIfNotExists() {
        try {
            s3Client.headBucket(HeadBucketRequest.builder()
                    .bucket(bucketName)
                    .build());
            log.info("存儲桶 {} 已存在", bucketName);
        } catch (NoSuchBucketException e) {
            // 存儲桶不存在，創建新桶
            s3Client.createBucket(CreateBucketRequest.builder()
                    .bucket(bucketName)
                    .build());
            log.info("創建存儲桶: {}", bucketName);
        }
    }
    
    @Override
    public String uploadFile(MultipartFile file, String objectName) {
        try {
            // 如果未指定對象名稱，使用原始文件名
            if (objectName == null || objectName.trim().isEmpty()) {
                objectName = file.getOriginalFilename();
            }
            
            // 執行文件上傳
            PutObjectRequest putObjectRequest = PutObjectRequest.builder()
                    .bucket(bucketName)
                    .key(objectName)
                    .contentType(file.getContentType())
                    .build();
            
            s3Client.putObject(putObjectRequest, 
                    RequestBody.fromBytes(file.getBytes()));
            
            log.info("文件上傳成功: {}", objectName);
            return objectName;
            
        } catch (IOException e) {
            log.error("文件上傳失敗: {}", e.getMessage());
            throw new RuntimeException("文件上傳失敗", e);
        }
    }
    
    @Override
    public InputStream downloadFile(String objectName) {
        try {
            GetObjectRequest getObjectRequest = GetObjectRequest.builder()
                    .bucket(bucketName)
                    .key(objectName)
                    .build();
            
            return s3Client.getObject(getObjectRequest);
            
        } catch (NoSuchKeyException e) {
            log.error("文件不存在: {}", objectName);
            throw new RuntimeException("文件不存在: " + objectName);
        }
    }
    
    @Override
    public String getFileUrl(String objectName) {
        try {
            GetUrlRequest getUrlRequest = GetUrlRequest.builder()
                    .bucket(bucketName)
                    .key(objectName)
                    .build();
            
            return s3Client.utilities().getUrl(getUrlRequest).toString();
            
        } catch (Exception e) {
            log.error("獲取文件URL失敗: {}", e.getMessage());
            return null;
        }
    }
    
    @Override
    public boolean deleteFile(String objectName) {
        try {
            DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder()
                    .bucket(bucketName)
                    .key(objectName)
                    .build();
            
            s3Client.deleteObject(deleteObjectRequest);
            log.info("文件刪除成功: {}", objectName);
            return true;
            
        } catch (Exception e) {
            log.error("文件刪除失敗: {}", e.getMessage());
            return false;
        }
    }
}

四、RESTful API控制器：提供HTTP接口

4.1 文件上傳下載控制器

創建FileController.java：

package com.rustfs.demo.controller;

import com.rustfs.demo.service.StorageService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/files")
@Slf4j
public class FileController {
    
    private final StorageService storageService;
    
    public FileController(StorageService storageService) {
        this.storageService = storageService;
    }
    
    /**
     * 文件上傳接口
     */
    @PostMapping("/upload")
    public ResponseEntity<Map<String, Object>> uploadFile(
            @RequestParam("file") MultipartFile file,
            @RequestParam(value = "objectName", required = false) String objectName) {
        
        try {
            String uploadedObjectName = storageService.uploadFile(file, objectName);
            String fileUrl = storageService.getFileUrl(uploadedObjectName);
            
            Map<String, Object> result = new HashMap<>();
            result.put("success", true);
            result.put("objectName", uploadedObjectName);
            result.put("fileUrl", fileUrl);
            result.put("fileSize", file.getSize());
            result.put("message", "文件上傳成功");
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("文件上傳失敗: {}", e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Map.of("success", false, "message", "文件上傳失敗: " + e.getMessage()));
        }
    }
    
    /**
     * 文件下載接口
     */
    @GetMapping("/download/{objectName}")
    public ResponseEntity<byte[]> downloadFile(@PathVariable String objectName) {
        try {
            InputStream inputStream = storageService.downloadFile(objectName);
            byte[] fileBytes = IOUtils.toByteArray(inputStream);
            
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
            headers.setContentDispositionFormData("attachment", 
                    new String(objectName.getBytes(StandardCharsets.UTF_8), StandardCharsets.ISO_8859_1));
            
            return new ResponseEntity<>(fileBytes, headers, HttpStatus.OK);
            
        } catch (Exception e) {
            log.error("文件下載失敗: {}", e.getMessage());
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }
    }
    
    /**
     * 獲取文件信息
     */
    @GetMapping("/info/{objectName}")
    public ResponseEntity<Map<String, Object>> getFileInfo(@PathVariable String objectName) {
        try {
            String fileUrl = storageService.getFileUrl(objectName);
            
            Map<String, Object> result = new HashMap<>();
            result.put("objectName", objectName);
            result.put("fileUrl", fileUrl);
            result.put("exists", true);
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            return ResponseEntity.ok(Map.of(
                    "objectName", objectName,
                    "exists", false,
                    "message", "文件不存在"
            ));
        }
    }
    
    /**
     * 刪除文件接口
     */
    @DeleteMapping("/{objectName}")
    public ResponseEntity<Map<String, Object>> deleteFile(@PathVariable String objectName) {
        try {
            boolean success = storageService.deleteFile(objectName);
            
            Map<String, Object> result = new HashMap<>();
            result.put("success", success);
            result.put("message", success ? "文件刪除成功" : "文件刪除失敗");
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("文件刪除失敗: {}", e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Map.of("success", false, "message", "文件刪除失敗"));
        }
    }
}

五、高級功能：大文件分片上傳

5.1 分片上傳服務類

對於大文件，實現分片上傳功能：

package com.rustfs.demo.service.impl;

import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

@Service
public class MultipartUploadService {
    
    private final S3Client s3Client;
    private static final int PART_SIZE = 5 * 1024 * 1024; // 5MB
    
    public MultipartUploadService(S3Client s3Client) {
        this.s3Client = s3Client;
    }
    
    /**
     * 大文件分片上傳
     */
    public String uploadLargeFile(MultipartFile file, String bucketName, String objectName) 
            throws Exception {
        
        // 初始化分片上傳
        CreateMultipartUploadRequest createRequest = CreateMultipartUploadRequest.builder()
                .bucket(bucketName)
                .key(objectName)
                .contentType(file.getContentType())
                .build();
        
        CreateMultipartUploadResponse createResponse = s3Client.createMultipartUpload(createRequest);
        String uploadId = createResponse.uploadId();
        
        List<CompletedPart> completedParts = new ArrayList<>();
        byte[] fileBytes = file.getBytes();
        int partCount = (int) Math.ceil((double) fileBytes.length / PART_SIZE);
        
        // 上傳各個分片
        for (int partNumber = 1; partNumber <= partCount; partNumber++) {
            int start = (partNumber - 1) * PART_SIZE;
            int end = Math.min(start + PART_SIZE, fileBytes.length);
            byte[] partBytes = new byte[end - start];
            System.arraycopy(fileBytes, start, partBytes, 0, partBytes.length);
            
            UploadPartRequest uploadRequest = UploadPartRequest.builder()
                    .bucket(bucketName)
                    .key(objectName)
                    .uploadId(uploadId)
                    .partNumber(partNumber)
                    .build();
            
            UploadPartResponse uploadResponse = s3Client.uploadPart(uploadRequest, 
                    RequestBody.fromBytes(partBytes));
            
            completedParts.add(CompletedPart.builder()
                    .partNumber(partNumber)
                    .eTag(uploadResponse.eTag())
                    .build());
        }
        
        // 完成分片上傳
        CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder()
                .parts(completedParts)
                .build();
        
        CompleteMultipartUploadRequest completeRequest = CompleteMultipartUploadRequest.builder()
                .bucket(bucketName)
                .key(objectName)
                .uploadId(uploadId)
                .multipartUpload(completedMultipartUpload)
                .build();
        
        s3Client.completeMultipartUpload(completeRequest);
        return objectName;
    }
}

六、功能測試與驗證

6.1 使用curl測試API接口

# 測試文件上傳
curl -X POST -F "file=@test.jpg" \
  http://localhost:8080/api/files/upload

# 測試文件下載
curl -X GET \
  http://localhost:8080/api/files/download/test.jpg \
  --output downloaded.jpg

# 測試文件信息查詢
curl -X GET \
  http://localhost:8080/api/files/info/test.jpg

# 測試文件刪除
curl -X DELETE \
  http://localhost:8080/api/files/test.jpg

6.2 使用Postman測試

創建測試集合，包含以下請求：

POST /api/files/upload- 文件上傳
GET /api/files/download/{name}- 文件下載
GET /api/files/info/{name}- 文件信息
DELETE /api/files/{name}- 文件刪除

七、生產環境優化建議

7.1 連接池配置優化

@Bean
public S3Client s3Client() {
    return S3Client.builder()
            .endpointOverride(URI.create(endpoint))
            .credentialsProvider(StaticCredentialsProvider.create(
                    AwsBasicCredentials.create(accessKey, secretKey)))
            .region(Region.of(region))
            .forcePathStyle(true)
            .httpClientBuilder(UrlConnectionHttpClient.builder()
                    .maxConnections(100)  // 最大連接數
                    .connectionTimeout(Duration.ofSeconds(10))  // 連接超時
                    .socketTimeout(Duration.ofSeconds(30)))  // 讀寫超時
            .build();
}

7.2 異常處理增強

創建全局異常處理器：

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(S3Exception.class)
    public ResponseEntity<Map<String, Object>> handleS3Exception(S3Exception e) {
        log.error("RustFS操作異常: {}", e.getMessage());
        
        Map<String, Object> error = new HashMap<>();
        error.put("success", false);
        error.put("errorCode", e.awsErrorDetails().errorCode());
        error.put("message", "存儲服務異常: " + e.getMessage());
        
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }
}

八、完整項目結構

src/main/java/
└── com/rustfs/demo/
    ├── config/
    │   └── RustFSConfig.java
    ├── controller/
    │   └── FileController.java
    ├── service/
    │   ├── StorageService.java
    │   ├── impl/
    │   │   ├── RustFSService.java
    │   │   └── MultipartUploadService.java
    │   └── exception/
    │       └── GlobalExceptionHandler.java
    └── DemoApplication.java

總結

通過本文的完整實現，我們成功構建了一個基於Java和Docker的RustFS文件存儲服務。關鍵亮點包括：

✅ 開箱即用：提供完整可運行的代碼示例

✅ 功能全面：覆蓋上傳、下載、刪除等核心操作

✅ 生產就緒：包含異常處理、性能優化等生產級特性

✅ 易於擴展：模塊化設計便於功能擴展

這種實現方式特別適合需要快速集成對象存儲功能的Java項目，無論是單體應用還是微服務架構都能良好適配。

以下是深入學習 RustFS 的推薦資源：RustFS

官方文檔： RustFS 官方文檔- 提供架構、安裝指南和 API 參考。

GitHub 倉庫： GitHub 倉庫 - 獲取源代碼、提交問題或貢獻代碼。

社區支持： GitHub Discussions- 與開發者交流經驗和解決方案。

u_17499862 博客

u_17499862 博客

博客 / 詳情