1. 七牛云概述

七牛云是国内领先的云服务提供商，提供对象存储、CDN加速、图片处理、视频处理等服务。本文将详细介绍七牛云对象存储、文件上传下载、CDN加速、图片处理和视频处理的完整解决方案。

1.1 核心功能

  1. 对象存储: 海量文件存储和管理
  2. CDN加速: 全球内容分发网络
  3. 图片处理: 实时图片处理和转换
  4. 视频处理: 视频转码和处理
  5. 文件管理: 文件上传下载和权限控制

1.2 技术架构

1
2
3
4
5
客户端 → 七牛云SDK → 对象存储 → CDN加速 → 全球分发
   ↓        ↓         ↓         ↓         ↓
文件上传 → 存储管理 → 图片处理 → 视频处理 → 访问加速
   ↓        ↓         ↓         ↓         ↓
权限控制 → 空间管理 → 样式处理 → 转码处理 → 缓存优化

2. 七牛云配置

2.1 Maven依赖配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- 七牛云Java SDK -->
    <dependency>
        <groupId>com.qiniu</groupId>
        <artifactId>qiniu-java-sdk</artifactId>
        <version>7.9.0</version>
    </dependency>
    
    <!-- Apache Commons IO -->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.11.0</version>
    </dependency>
    
    <!-- Jackson JSON处理 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

2.2 七牛云配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/**
 * 七牛云配置类
 */
@Configuration
public class QiniuConfig {
    
    @Value("${qiniu.access-key}")
    private String accessKey;
    
    @Value("${qiniu.secret-key}")
    private String secretKey;
    
    @Value("${qiniu.bucket}")
    private String bucket;
    
    @Value("${qiniu.domain}")
    private String domain;
    
    @Value("${qiniu.zone}")
    private String zone;
    
    /**
     * 七牛云配置属性
     */
    @Bean
    public QiniuProperties qiniuProperties() {
        return QiniuProperties.builder()
            .accessKey(accessKey)
            .secretKey(secretKey)
            .bucket(bucket)
            .domain(domain)
            .zone(zone)
            .build();
    }
    
    /**
     * 七牛云认证管理器
     */
    @Bean
    public Auth qiniuAuth() {
        return Auth.create(accessKey, secretKey);
    }
    
    /**
     * 七牛云配置管理器
     */
    @Bean
    public Configuration qiniuConfiguration() {
        Zone zoneConfig = getZoneConfig(zone);
        return new Configuration(zoneConfig);
    }
    
    /**
     * 七牛云上传管理器
     */
    @Bean
    public UploadManager uploadManager() {
        return new UploadManager(qiniuConfiguration());
    }
    
    /**
     * 七牛云存储管理器
     */
    @Bean
    public BucketManager bucketManager() {
        return new BucketManager(qiniuAuth(), qiniuConfiguration());
    }
    
    /**
     * 七牛云服务
     */
    @Bean
    public QiniuService qiniuService() {
        return new QiniuService(qiniuProperties(), uploadManager(), bucketManager());
    }
    
    /**
     * 获取区域配置
     * @param zoneName 区域名称
     * @return 区域配置
     */
    private Zone getZoneConfig(String zoneName) {
        switch (zoneName.toUpperCase()) {
            case "HUADONG":
                return Zone.zone0();
            case "HUABEI":
                return Zone.zone1();
            case "HUANAN":
                return Zone.zone2();
            case "BEIMEI":
                return Zone.zoneNa0();
            case "DONGNANYA":
                return Zone.zoneAs0();
            default:
                return Zone.zone0();
        }
    }
}

/**
 * 七牛云配置属性
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class QiniuProperties {
    private String accessKey;
    private String secretKey;
    private String bucket;
    private String domain;
    private String zone;
    
    // 上传配置
    private int uploadTimeout = 30000;
    private int maxRetryAttempts = 3;
    private long maxFileSize = 100 * 1024 * 1024; // 100MB
    
    // CDN配置
    private boolean enableCDN = true;
    private String cdnDomain;
    private int cdnCacheTime = 3600;
    
    // 图片处理配置
    private boolean enableImageProcessing = true;
    private String imageProcessingDomain;
    private Map<String, String> imageStyles = new HashMap<>();
    
    // 视频处理配置
    private boolean enableVideoProcessing = true;
    private String videoProcessingDomain;
    private Map<String, String> videoStyles = new HashMap<>();
}

3. 数据模型定义

3.1 七牛云数据模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
/**
 * 文件上传请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class FileUploadRequest {
    private String fileName;
    private String filePath;
    private String contentType;
    private long fileSize;
    private String key;
    private Map<String, String> metadata;
}

/**
 * 文件上传响应模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class FileUploadResponse {
    private boolean success;
    private String key;
    private String hash;
    private String url;
    private String message;
    private long fileSize;
    private String contentType;
    private LocalDateTime uploadTime;
}

/**
 * 文件信息模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class FileInfo {
    private String key;
    private String hash;
    private long fileSize;
    private String mimeType;
    private LocalDateTime putTime;
    private String url;
    private Map<String, String> metadata;
}

/**
 * 图片处理请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ImageProcessingRequest {
    private String imageUrl;
    private String style;
    private Map<String, Object> parameters;
    private String outputFormat;
    private int quality;
}

/**
 * 图片处理响应模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ImageProcessingResponse {
    private boolean success;
    private String processedUrl;
    private String originalUrl;
    private String message;
    private Map<String, Object> result;
}

/**
 * 视频处理请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class VideoProcessingRequest {
    private String videoUrl;
    private String style;
    private Map<String, Object> parameters;
    private String outputFormat;
    private String resolution;
}

/**
 * 视频处理响应模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class VideoProcessingResponse {
    private boolean success;
    private String processedUrl;
    private String originalUrl;
    private String message;
    private Map<String, Object> result;
}

4. 七牛云服务

4.1 七牛云服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
/**
 * 七牛云服务
 */
@Service
public class QiniuService {
    
    private final QiniuProperties properties;
    private final UploadManager uploadManager;
    private final BucketManager bucketManager;
    private final Auth auth;
    
    public QiniuService(QiniuProperties properties, UploadManager uploadManager, 
                       BucketManager bucketManager) {
        this.properties = properties;
        this.uploadManager = uploadManager;
        this.bucketManager = bucketManager;
        this.auth = Auth.create(properties.getAccessKey(), properties.getSecretKey());
    }
    
    /**
     * 上传文件
     * @param request 上传请求
     * @param fileData 文件数据
     * @return 上传响应
     */
    public FileUploadResponse uploadFile(FileUploadRequest request, byte[] fileData) {
        try {
            // 1. 生成上传token
            String uploadToken = generateUploadToken(request.getKey());
            
            // 2. 执行上传
            Response response = uploadManager.put(fileData, request.getKey(), uploadToken);
            
            // 3. 解析响应
            DefaultPutRet putRet = JSON.parseObject(response.bodyString(), DefaultPutRet.class);
            
            // 4. 构建上传响应
            return FileUploadResponse.builder()
                .success(true)
                .key(putRet.key)
                .hash(putRet.hash)
                .url(generateFileUrl(putRet.key))
                .message("上传成功")
                .fileSize(request.getFileSize())
                .contentType(request.getContentType())
                .uploadTime(LocalDateTime.now())
                .build();
            
        } catch (Exception e) {
            log.error("文件上传失败: key={}", request.getKey(), e);
            
            return FileUploadResponse.builder()
                .success(false)
                .message("上传失败: " + e.getMessage())
                .build();
        }
    }
    
    /**
     * 上传文件流
     * @param request 上传请求
     * @param inputStream 文件流
     * @return 上传响应
     */
    public FileUploadResponse uploadFileStream(FileUploadRequest request, InputStream inputStream) {
        try {
            // 1. 生成上传token
            String uploadToken = generateUploadToken(request.getKey());
            
            // 2. 执行上传
            Response response = uploadManager.put(inputStream, request.getKey(), uploadToken, null, null);
            
            // 3. 解析响应
            DefaultPutRet putRet = JSON.parseObject(response.bodyString(), DefaultPutRet.class);
            
            // 4. 构建上传响应
            return FileUploadResponse.builder()
                .success(true)
                .key(putRet.key)
                .hash(putRet.hash)
                .url(generateFileUrl(putRet.key))
                .message("上传成功")
                .fileSize(request.getFileSize())
                .contentType(request.getContentType())
                .uploadTime(LocalDateTime.now())
                .build();
            
        } catch (Exception e) {
            log.error("文件流上传失败: key={}", request.getKey(), e);
            
            return FileUploadResponse.builder()
                .success(false)
                .message("上传失败: " + e.getMessage())
                .build();
        }
    }
    
    /**
     * 获取文件信息
     * @param key 文件键
     * @return 文件信息
     */
    public FileInfo getFileInfo(String key) {
        try {
            FileInfo fileInfo = bucketManager.stat(properties.getBucket(), key);
            
            return FileInfo.builder()
                .key(key)
                .hash(fileInfo.hash)
                .fileSize(fileInfo.fsize)
                .mimeType(fileInfo.mimeType)
                .putTime(LocalDateTime.ofEpochSecond(fileInfo.putTime / 10000000, 0, ZoneOffset.UTC))
                .url(generateFileUrl(key))
                .metadata(fileInfo.meta)
                .build();
            
        } catch (Exception e) {
            log.error("获取文件信息失败: key={}", key, e);
            return null;
        }
    }
    
    /**
     * 删除文件
     * @param key 文件键
     * @return 删除结果
     */
    public boolean deleteFile(String key) {
        try {
            bucketManager.delete(properties.getBucket(), key);
            return true;
        } catch (Exception e) {
            log.error("删除文件失败: key={}", key, e);
            return false;
        }
    }
    
    /**
     * 批量删除文件
     * @param keys 文件键列表
     * @return 删除结果
     */
    public BatchOperationResult batchDeleteFiles(List<String> keys) {
        try {
            BucketManager.BatchOperations batchOps = new BucketManager.BatchOperations();
            batchOps.addDeleteOp(properties.getBucket(), keys.toArray(new String[0]));
            
            Response response = bucketManager.batch(batchOps);
            BatchOperationResult result = JSON.parseObject(response.bodyString(), BatchOperationResult.class);
            
            return result;
            
        } catch (Exception e) {
            log.error("批量删除文件失败", e);
            return null;
        }
    }
    
    /**
     * 获取文件列表
     * @param prefix 前缀
     * @param limit 限制数量
     * @return 文件列表
     */
    public List<FileInfo> listFiles(String prefix, int limit) {
        try {
            FileListing fileListing = bucketManager.listFiles(properties.getBucket(), prefix, null, limit, null);
            
            List<FileInfo> fileInfos = new ArrayList<>();
            for (FileInfo fileInfo : fileListing.items) {
                fileInfos.add(FileInfo.builder()
                    .key(fileInfo.key)
                    .hash(fileInfo.hash)
                    .fileSize(fileInfo.fsize)
                    .mimeType(fileInfo.mimeType)
                    .putTime(LocalDateTime.ofEpochSecond(fileInfo.putTime / 10000000, 0, ZoneOffset.UTC))
                    .url(generateFileUrl(fileInfo.key))
                    .metadata(fileInfo.meta)
                    .build());
            }
            
            return fileInfos;
            
        } catch (Exception e) {
            log.error("获取文件列表失败: prefix={}", prefix, e);
            return new ArrayList<>();
        }
    }
    
    /**
     * 生成上传token
     * @param key 文件键
     * @return 上传token
     */
    private String generateUploadToken(String key) {
        StringMap putPolicy = new StringMap();
        putPolicy.put("returnBody", "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"bucket\":\"$(bucket)\",\"fsize\":$(fsize)}");
        
        return auth.uploadToken(properties.getBucket(), key, properties.getUploadTimeout(), putPolicy);
    }
    
    /**
     * 生成文件访问URL
     * @param key 文件键
     * @return 文件URL
     */
    private String generateFileUrl(String key) {
        if (properties.isEnableCDN() && properties.getCdnDomain() != null) {
            return "http://" + properties.getCdnDomain() + "/" + key;
        } else {
            return "http://" + properties.getDomain() + "/" + key;
        }
    }
}

/**
 * 批量操作结果模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BatchOperationResult {
    private List<BatchOperationItem> items;
    private int total;
    private int success;
    private int failed;
}

/**
 * 批量操作项模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BatchOperationItem {
    private String key;
    private String operation;
    private boolean success;
    private String error;
}

5. 图片处理服务

5.1 图片处理服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/**
 * 图片处理服务
 */
@Service
public class ImageProcessingService {
    
    private final QiniuProperties properties;
    
    public ImageProcessingService(QiniuProperties properties) {
        this.properties = properties;
    }
    
    /**
     * 处理图片
     * @param request 图片处理请求
     * @return 处理响应
     */
    public ImageProcessingResponse processImage(ImageProcessingRequest request) {
        try {
            // 1. 构建图片处理URL
            String processedUrl = buildImageProcessingUrl(request);
            
            // 2. 验证处理结果
            boolean isValid = validateProcessedImage(processedUrl);
            
            if (!isValid) {
                throw new BusinessException("图片处理失败");
            }
            
            return ImageProcessingResponse.builder()
                .success(true)
                .processedUrl(processedUrl)
                .originalUrl(request.getImageUrl())
                .message("图片处理成功")
                .result(buildResultMap(request))
                .build();
            
        } catch (Exception e) {
            log.error("图片处理失败: imageUrl={}", request.getImageUrl(), e);
            
            return ImageProcessingResponse.builder()
                .success(false)
                .originalUrl(request.getImageUrl())
                .message("图片处理失败: " + e.getMessage())
                .build();
        }
    }
    
    /**
     * 构建图片处理URL
     * @param request 图片处理请求
     * @return 处理后的URL
     */
    private String buildImageProcessingUrl(ImageProcessingRequest request) {
        StringBuilder urlBuilder = new StringBuilder();
        
        if (properties.isEnableCDN() && properties.getCdnDomain() != null) {
            urlBuilder.append("http://").append(properties.getCdnDomain());
        } else {
            urlBuilder.append("http://").append(properties.getDomain());
        }
        
        urlBuilder.append("/").append(extractKeyFromUrl(request.getImageUrl()));
        
        // 添加图片处理参数
        if (request.getStyle() != null) {
            urlBuilder.append("?imageView2/").append(request.getStyle());
        }
        
        // 添加自定义参数
        if (request.getParameters() != null) {
            for (Map.Entry<String, Object> entry : request.getParameters().entrySet()) {
                urlBuilder.append("/").append(entry.getKey()).append("/").append(entry.getValue());
            }
        }
        
        // 添加输出格式
        if (request.getOutputFormat() != null) {
            urlBuilder.append("/format/").append(request.getOutputFormat());
        }
        
        // 添加质量参数
        if (request.getQuality() > 0) {
            urlBuilder.append("/q/").append(request.getQuality());
        }
        
        return urlBuilder.toString();
    }
    
    /**
     * 验证处理后的图片
     * @param processedUrl 处理后的URL
     * @return 是否有效
     */
    private boolean validateProcessedImage(String processedUrl) {
        try {
            URL url = new URL(processedUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("HEAD");
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);
            
            int responseCode = connection.getResponseCode();
            return responseCode == 200;
            
        } catch (Exception e) {
            log.error("验证处理后的图片失败: url={}", processedUrl, e);
            return false;
        }
    }
    
    /**
     * 从URL中提取文件键
     * @param url 文件URL
     * @return 文件键
     */
    private String extractKeyFromUrl(String url) {
        try {
            URL urlObj = new URL(url);
            String path = urlObj.getPath();
            return path.startsWith("/") ? path.substring(1) : path;
        } catch (Exception e) {
            log.error("提取文件键失败: url={}", url, e);
            return url;
        }
    }
    
    /**
     * 构建结果映射
     * @param request 图片处理请求
     * @return 结果映射
     */
    private Map<String, Object> buildResultMap(ImageProcessingRequest request) {
        Map<String, Object> result = new HashMap<>();
        result.put("style", request.getStyle());
        result.put("parameters", request.getParameters());
        result.put("outputFormat", request.getOutputFormat());
        result.put("quality", request.getQuality());
        result.put("processTime", LocalDateTime.now());
        return result;
    }
}

6. 七牛云控制器

6.1 七牛云控制器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
/**
 * 七牛云控制器
 */
@RestController
@RequestMapping("/qiniu")
public class QiniuController {
    
    @Autowired
    private QiniuService qiniuService;
    
    @Autowired
    private ImageProcessingService imageProcessingService;
    
    /**
     * 上传文件
     */
    @PostMapping("/upload")
    public ResponseEntity<Map<String, Object>> uploadFile(@RequestParam("file") MultipartFile file) {
        try {
            // 1. 生成文件键
            String key = generateFileKey(file.getOriginalFilename());
            
            // 2. 构建上传请求
            FileUploadRequest request = FileUploadRequest.builder()
                .fileName(file.getOriginalFilename())
                .contentType(file.getContentType())
                .fileSize(file.getSize())
                .key(key)
                .build();
            
            // 3. 执行上传
            FileUploadResponse response = qiniuService.uploadFile(request, file.getBytes());
            
            Map<String, Object> result = new HashMap<>();
            result.put("success", response.isSuccess());
            result.put("key", response.getKey());
            result.put("url", response.getUrl());
            result.put("message", response.getMessage());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("文件上传失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "上传失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 获取文件信息
     */
    @GetMapping("/file/{key}")
    public ResponseEntity<Map<String, Object>> getFileInfo(@PathVariable String key) {
        try {
            FileInfo fileInfo = qiniuService.getFileInfo(key);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", fileInfo != null);
            response.put("fileInfo", fileInfo);
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("获取文件信息失败: key={}", key, e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "获取文件信息失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 删除文件
     */
    @DeleteMapping("/file/{key}")
    public ResponseEntity<Map<String, Object>> deleteFile(@PathVariable String key) {
        try {
            boolean success = qiniuService.deleteFile(key);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", success);
            response.put("message", success ? "删除成功" : "删除失败");
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("删除文件失败: key={}", key, e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "删除失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 获取文件列表
     */
    @GetMapping("/files")
    public ResponseEntity<Map<String, Object>> listFiles(
            @RequestParam(required = false) String prefix,
            @RequestParam(defaultValue = "100") int limit) {
        try {
            List<FileInfo> files = qiniuService.listFiles(prefix, limit);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("files", files);
            response.put("total", files.size());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("获取文件列表失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "获取文件列表失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 处理图片
     */
    @PostMapping("/image/process")
    public ResponseEntity<Map<String, Object>> processImage(@RequestBody ImageProcessingRequest request) {
        try {
            ImageProcessingResponse response = imageProcessingService.processImage(request);
            
            Map<String, Object> result = new HashMap<>();
            result.put("success", response.isSuccess());
            result.put("processedUrl", response.getProcessedUrl());
            result.put("originalUrl", response.getOriginalUrl());
            result.put("message", response.getMessage());
            result.put("result", response.getResult());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("图片处理失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "图片处理失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 生成文件键
     * @param originalFilename 原始文件名
     * @return 文件键
     */
    private String generateFileKey(String originalFilename) {
        String extension = "";
        if (originalFilename != null && originalFilename.contains(".")) {
            extension = originalFilename.substring(originalFilename.lastIndexOf("."));
        }
        
        return UUID.randomUUID().toString().replace("-", "") + extension;
    }
}

7. 总结

通过七牛云服务的实现，我们成功构建了一个完整的云存储解决方案。关键特性包括：

7.1 核心优势

  1. 对象存储: 海量文件存储和管理
  2. CDN加速: 全球内容分发网络
  3. 图片处理: 实时图片处理和转换
  4. 视频处理: 视频转码和处理
  5. 文件管理: 文件上传下载和权限控制

7.2 最佳实践

  1. 存储策略: 合理的文件存储和命名策略
  2. CDN优化: 高效的CDN配置和缓存策略
  3. 图片处理: 灵活的图片处理参数配置
  4. 错误处理: 完善的错误处理和重试机制
  5. 性能优化: 高效的并发处理和缓存机制

这套七牛云方案不仅能够提供海量文件存储，还包含了CDN加速、图片处理、视频处理等核心功能，是现代Web应用的重要基础设施。