# 优雅实现Java手机号脱敏：基于Jackson自定义注解方案
在日常的后端开发中，用户手机号等敏感信息的脱敏处理是数据安全合规的基本要求。直接在业务代码中硬编码脱敏逻辑会导致代码冗余、维护成本高，本文将分享一种基于Jackson自定义注解的优雅实现方案，只需一个注解即可完成手机号字段的自动脱敏。

## 一、需求背景
在接口返回用户数据时，手机号这类敏感信息不能明文展示，通常需要按照`138****5678`的格式进行脱敏。我们希望：
1. 脱敏逻辑与业务代码解耦，不侵入业务层
2. 使用简单，只需在字段上添加注解即可生效
3. 具备容错性，非手机号格式的字符串原样返回
4. 空值不做处理，避免空指针异常



## 二、技术选型
- **Jackson**：Java生态中主流的JSON序列化/反序列化框架，支持自定义序列化逻辑
- **Hutool**：国产优秀的Java工具类库，提供了完善的手机号校验和脱敏工具，避免重复造轮子
- **自定义注解**：通过注解标记需要脱敏的字段，实现配置化使用

## 三、实现步骤

### 3.1 引入依赖
首先确保项目中引入了必要的依赖（以Maven为例）：
```xml

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>


<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.20</version>
</dependency>
```

### 3.2 自定义手机号脱敏注解
创建自定义注解`PhoneDesensitization`，用于标记需要脱敏的手机号字段：
```java
package com.nsw.server.common.annotation;

import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.nsw.server.common.config.PhoneDesensitizationSerializer;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 手机号脱敏注解
 * 标注在需要脱敏的phone字段上
 *
 * @author weizhenwang
 */
// 注解作用目标：字段
@Target({ElementType.FIELD})
// 注解保留策略：运行时生效（反射可获取）
@Retention(RetentionPolicy.RUNTIME)
// 生成文档时包含该注解
@Documented
// 嵌套Jackson注解的标记，避免注解冲突
@JacksonAnnotationsInside
// 指定序列化器：使用自定义的PhoneDesensitizationSerializer处理字段
@JsonSerialize(using = PhoneDesensitizationSerializer.class)
public @interface PhoneDesensitization {
}
```

**注解关键属性说明**：
- `@Target(ElementType.FIELD)`：限定注解只能用在类的字段上
- `@Retention(RetentionPolicy.RUNTIME)`：注解在运行时保留，Jackson序列化时能通过反射识别
- `@JacksonAnnotationsInside`：Jackson的注解，用于嵌套自定义注解，防止注解失效
- `@JsonSerialize`：指定该字段序列化时使用的自定义序列化器

### 3.3 实现手机号脱敏序列化器
创建`PhoneDesensitizationSerializer`类，继承Jackson的`JsonSerializer`，实现具体的脱敏逻辑：
```java
package com.nsw.server.common.config;

import cn.hutool.core.lang.Validator;
import cn.hutool.core.util.DesensitizedUtil;
import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

import java.io.IOException;

/**
 * 手机号脱敏序列化器
 */
public class PhoneDesensitizationSerializer extends JsonSerializer<String> {

    @Override
    public void serialize(String phone, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        // 1. 空值处理：空字符串/Null直接返回，避免空指针
        if (StrUtil.isBlank(phone)) {
            gen.writeString(phone);
            return;
        }

        // 2. 手机号格式校验：使用Hutool的Validator工具类
        if (Validator.isMobile(phone)) {
            // 3. 格式正确则脱敏：Hutool的DesensitizedUtil实现138****5678格式
            String desensitizedPhone = DesensitizedUtil.mobilePhone(phone);
            gen.writeString(desensitizedPhone);
        } else {
            // 4. 格式错误则原样返回，保证数据兼容性
            gen.writeString(phone);
        }
    }
}
```

**核心逻辑说明**：
1. **空值防护**：通过`StrUtil.isBlank()`判断空值，避免后续逻辑出现NPE
2. **格式校验**：`Validator.isMobile()`支持中国大陆11位手机号格式校验
3. **脱敏处理**：`DesensitizedUtil.mobilePhone()`内置了成熟的手机号脱敏逻辑（保留前3位和后4位，中间4位替换为*）
4. **容错处理**：非手机号格式的字符串原样返回，避免数据异常

## 四、使用示例

### 4.1 实体类中使用注解
在需要脱敏的手机号字段上添加`@PhoneDesensitization`注解：
```java
package com.nsw.server.entity;

import com.nsw.server.common.annotation.PhoneDesensitization;
import lombok.Data;

@Data
public class User {
    /**
     * 用户ID
     */
    private Long id;
    
    /**
     * 用户名
     */
    private String username;
    
    /**
     * 手机号（脱敏展示）
     */
    @PhoneDesensitization
    private String phone;
    
    /**
     * 邮箱
     */
    private String email;
}
```

### 4.2 接口返回效果
编写测试接口：
```java
package com.nsw.server.controller;

import com.nsw.server.entity.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/info")
    public User getUserInfo() {
        User user = new User();
        user.setId(1L);
        user.setUsername("张三");
        user.setPhone("13812345678"); // 真实手机号
        user.setEmail("zhangsan@example.com");
        return user;
    }
}
```

访问接口后，返回的JSON数据如下：
```json
{
  "id": 1,
  "username": "张三",
  "phone": "138****5678", // 已脱敏
  "email": "zhangsan@example.com"
}
```

### 4.3 边界场景测试
| 输入手机号 | 输出结果 | 说明 |
|------------|----------|------|
| null       | null     | 空值原样返回 |
| ""         | ""       | 空字符串原样返回 |
| "13812345678" | "138****5678" | 合法手机号脱敏 |
| "123456"   | "123456" | 非手机号格式原样返回 |
| "138123456789" | "138123456789" | 长度不符原样返回 |

## 五、扩展与优化

### 5.1 支持更多脱敏规则
如果需要自定义脱敏规则（比如保留前2位、后3位），可以修改序列化器：
```java
// 自定义脱敏逻辑示例：保留前2位，后3位，中间用*填充
String prefix = phone.substring(0, 2);
String suffix = phone.substring(phone.length() - 3);
String desensitizedPhone = prefix + "*****" + suffix;
```

### 5.2 批量脱敏场景
如果需要对整个项目的手机号字段统一脱敏，可结合Spring Boot的配置，实现全局序列化规则，无需逐个字段加注解。

### 5.3 脱敏注解复用
可基于该思路扩展更多脱敏注解，如`@IdCardDesensitization`（身份证脱敏）、`@BankCardDesensitization`（银行卡脱敏）等，只需替换对应的序列化器即可。

## 六、核心优势
1. **侵入性低**：只需添加注解，无需修改业务代码，符合开闭原则
2. **通用性强**：基于Jackson实现，适配所有使用Jackson序列化的场景（Spring Boot默认JSON处理器）
3. **容错性好**：空值、非法格式均做了兼容处理，避免线上异常
4. **易于维护**：脱敏逻辑集中管理，修改时只需调整序列化器，无需逐个修改业务代码

## 总结
本文通过自定义Jackson注解+序列化器的方式，结合Hutool工具类，实现了优雅、通用的手机号脱敏方案。核心要点如下：
1. 利用`@JsonSerialize`注解指定自定义序列化器，实现字段级别的序列化控制
2. 通过Hutool工具类简化手机号校验和脱敏逻辑，提升开发效率
3. 做好空值和异常格式的容错处理，保证代码健壮性
4. 注解化使用方式降低代码侵入性，便于维护和扩展

该方案不仅适用于手机号脱敏，也可扩展到身份证、银行卡等其他敏感信息的脱敏场景，是后端开发中处理敏感数据的最佳实践之一。

优雅实现 Java 手机号脱敏：基于 Jackson 自定义注解方案

# JavaCV视频压缩实战：从原理到实现

## 一、依赖配置优化

在实际项目中，依赖管理是首要考虑的问题。JavaCV提供了两种依赖引入方式：

### 1.1 完整平台包（不推荐）
```xml
<dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>javacv-platform</artifactId>
    <version>1.5.12</version>
    <scope>provided</scope>
</dependency>
```
**问题**：会导致JAR包增大650MB+，包含所有支持的库，多数情况下不必要。



### 1.2 精简依赖方案（推荐），如果是其他操作系统引入对应系统环境的ffmpeg即可
```xml

<dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>javacv</artifactId>
    <version>1.5.12</version>
</dependency>

<dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>ffmpeg</artifactId>
    <version>7.1.1-1.5.12</version>
    <classifier>linux-x86_64</classifier>
</dependency>

<dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>ffmpeg</artifactId>
    <version>7.1.1-1.5.12</version>
    <classifier>windows-x86_64</classifier>
</dependency>
```

### 1.3 Docker部署注意事项
必须使用`eclipse-temurin:17`基础镜像
```dockerfile
FROM eclipse-temurin:17
```

:::warning{title="注意"}
OpenJDK会导致运行时错误：`Could not initialize class org.bytedeco.ffmpeg.global.avutil`
:::

## 二、视频压缩核心实现

以下是完整的视频压缩工具类实现，包含详细注释：

```java
package com.truth.engine.common.util;

import cn.hutool.core.io.FileUtil;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@Slf4j
public class VideoCompressionUtil {

    /**
     * 压缩视频文件
     *
     * @param videoFile     上传的视频文件
     * @param targetWidth   目标宽度(设置为0保持原始比例)
     * @param targetBitrate 目标比特率(设置为0自动计算)
     * @param quality       压缩质量(1-51, 越低质量越好)
     * @return 压缩后的视频字节数组
     * @throws IOException 文件处理异常
     */
    public static byte[] compressVideo(MultipartFile videoFile,
                                       int targetWidth,
                                       int targetBitrate,
                                       int quality) throws IOException {
        // === 参数校验部分 ===
        // 检查视频文件是否为空
        if (videoFile == null || videoFile.isEmpty()) {
            throw new IllegalArgumentException("视频文件不能为空");
        }
        // 检查质量参数是否在有效范围内(1-51)
        if (quality < 1 || quality > 51) {
            throw new IllegalArgumentException("质量参数必须在1-51之间");
        }

        // === 临时文件创建 ===
        // 创建临时输入文件（用于存储上传的原始视频）
        File tempInputFile = FileUtil.createTempFile("input_", ".mp4", true);
        // 创建临时输出文件（用于存储压缩后的视频）
        File tempOutFile = FileUtil.createTempFile("input_", ".mp4", true);

        try {
            // 将上传的视频文件转存到临时输入文件
            videoFile.transferTo(tempInputFile);

            // === 视频抓取器初始化 ===
            // 创建FFmpeg帧抓取器，用于读取视频信息
            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(tempInputFile);
            grabber.start();  // 启动视频抓取器

            // === 计算目标视频参数 ===
            // 获取原始视频宽度
            int originalWidth = grabber.getImageWidth();
            // 获取原始视频高度
            int originalHeight = grabber.getImageHeight();
            // 计算输出宽度（如果targetWidth为0则保持原始宽度）
            int outputWidth = targetWidth > 0 ? targetWidth : originalWidth;
            // 计算输出高度（保持原始宽高比）
            int outputHeight = targetWidth > 0 ?
                    (int) (originalHeight * ((double) targetWidth / originalWidth)) : originalHeight;

            // === 计算比特率 ===
            // 获取原始视频比特率
            int originalBitrate = grabber.getVideoBitrate();
            // 计算输出比特率（如果targetBitrate为0则使用原始比特率的70%）
            int outputBitrate = targetBitrate > 0 ? targetBitrate : (int) (originalBitrate * 0.7);

            // === 视频录制器初始化 ===
            // 创建FFmpeg帧录制器，指定输出文件和分辨率
            FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(tempOutFile, outputWidth, outputHeight);

            // === 设置视频编码参数 ===
            recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);  // 使用H.264编码
            recorder.setFormat("mp4");  // 输出格式为MP4
            recorder.setVideoBitrate(outputBitrate);  // 设置视频比特率
            recorder.setVideoQuality(quality);  // 设置视频质量（1-51）
            // 设置FFmpeg高级选项：
            recorder.setVideoOption("preset", "fast");  // 编码速度预设（fast平衡速度和质量）
            recorder.setVideoOption("tune", "film");  // 优化场景（film针对电影/动画优化）
            recorder.setVideoOption("crf", String.valueOf(quality));  // 恒定质量因子
            recorder.setFrameRate(grabber.getFrameRate());  // 保持原始帧率

            // === 音频处理配置 ===
            // 如果原始视频包含音频轨道
            if (grabber.getAudioChannels() > 0) {
                recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);  // 使用AAC音频编码
                recorder.setAudioChannels(grabber.getAudioChannels());  // 保持原始声道数
                recorder.setAudioBitrate(grabber.getAudioBitrate());  // 保持原始音频比特率
                recorder.setSampleRate(grabber.getSampleRate());  // 保持原始采样率
            }

            // === 开始视频处理 ===
            recorder.start();  // 启动视频录制器

            // === 逐帧处理视频 ===
            Frame frame;
            while (true) {
                // 抓取下一 {
                // 抓取下一帧（包含视频和音频帧）
                frame = grabber.grabFrame();
                // 当没有更多帧时退出循环
                if (frame == null) {
                    break;
                }
                // 将当前帧写入输出视频
                recorder.record(frame);
            }

            // === 资源释放 ===
            // 停止并释放录制器资源（注意顺序：先停止录制器）
            recorder.stop();      // 停止录制
            grabber.stop();       // 停止抓取
            recorder.release();   // 释放录制器资源
            grabber.release();    // 释放抓取器资源
            recorder.close();     // 关闭录制器
            grabber.close();      // 关闭抓取器

            // 读取压缩后的视频文件到字节数组
            return FileUtil.readBytes(tempOutFile);
        } finally {
            // === 清理临时文件 ===
            // 记录临时文件路径（用于调试）
            log.info("tempInputFile:{}", tempInputFile.getAbsolutePath());
            log.info("tempOutFile:{}", tempOutFile.getAbsolutePath());
            // 删除临时输入文件
            FileUtil.del(tempInputFile);
            // 删除临时输出文件
            FileUtil.del(tempOutFile);
        }
    }

    /**
     * 默认参数的视频压缩
     *
     * @param videoFile 上传的视频文件
     * @return 压缩后的视频字节数组
     * @throws Exception 处理异常
     */
    public static byte[] compressVideo(MultipartFile videoFile) throws Exception {
        // 使用默认参数调用压缩方法：
        // 目标宽度640px, 比特率自动计算(原始比特率的70%), 质量参数28(一般质量)
        return compressVideo(videoFile, 640, 0, 28);
    }
}

```

## 三、关键技术解析

### 3.1 核心参数说明

| 参数 | 说明 | 推荐值 |
|------|------|------|
| targetWidth | 目标宽度（像素） | 640/1280/1920 |
| targetBitrate | 目标比特率（bps） | 0（自动计算） |
| quality | 压缩质量（1-51） | 23-28（平衡质量） |

### 3.2 FFmpeg关键配置

1. **编码预设(preset)**：
- `ultrafast`：最快编码，最低压缩率
- `fast`：平衡速度和质量（推荐）
- `slow`：高质量，慢速编码

2. **场景优化(tune)**：
- `film`：电影/动画
- `stillimage`：静态图像
- `fastdecode`：快速解码

3. **恒定质量因子(crf)**：
- 18-23：高质量
- 24-28：标准质量
- 29+：低质量

## 四、性能优化建议

1. **批量处理**：
```java
// 使用线程池处理多个视频
ExecutorService executor = new ThreadPoolExecutor(
    Runtime.getRuntime().availableProcessors(),  // 核心线程数
    Runtime.getRuntime().availableProcessors(),  // 最大线程数
    0L,                                         // 空闲线程存活时间
    TimeUnit.MILLISECONDS,                      // 时间单位
    new LinkedBlockingQueue<Runnable>()         // 任务队列
);
```

2. **内存优化**：
```java
// 限制帧处理速率
recorder.setFrameRate(25);
// 设置最大比特率
recorder.setVideoBitrate(1000000);
```

3. **硬件加速**（如果支持）：
```java
recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264_QSV);
```

## 五、异常处理增强

```java
try {
    grabber.start();
} catch (FFmpegFrameGrabber.Exception e) {
    log.error("视频处理失败 - 格式不支持或已损坏", e);
    throw new IllegalArgumentException("不支持的视频格式");
}

try {
    recorder.start();
} catch (FFmpegFrameRecorder.Exception e) {
    log.error("视频编码器初始化失败", e);
    throw new IllegalStateException("视频编码失败");
}
```

## 六、总结

本文完整呈现了基于JavaCV的视频压缩解决方案，重点包括：
1. 精简依赖配置方案
2. 完整的视频压缩实现代码
3. 关键参数说明和优化建议
4. 异常处理和性能优化技巧

该方案已在生产环境验证，可直接集成到项目中，根据实际需求调整参数即可实现高效的视频压缩功能。

JavaCV实战：高效视频压缩方案与最佳实践

# 如何在Linux系统中创建和删除交换内存（Swap）空间

交换空间（Swap）是Linux系统中的一项重要功能，它可以在物理内存（RAM）不足时，将部分内存数据暂时存储到硬盘上，从而防止系统因内存不足而崩溃。本文将详细介绍如何在Linux系统中创建和删除交换空间。

## 什么是交换空间？

交换空间是硬盘上的一块特殊区域，当系统物理内存不足时，Linux内核会将不活跃的内存页移动到交换空间中，从而释放物理内存供其他进程使用。虽然交换空间的访问速度比物理内存慢得多，但它能有效防止系统在内存耗尽时崩溃。



## 检查当前交换空间

在开始操作之前，我们应该先检查系统当前的交换空间配置：

```bash
free -h
sudo swapon --show
```

`free -h`命令会以人类可读的格式显示内存和交换空间的使用情况，而`sudo swapon --show`会显示当前激活的交换空间设备或文件。

## 创建交换文件

### 方法一：使用fallocate命令

1. **创建交换文件**：
```bash
sudo fallocate -l 8G /swapfile
```
这个命令会快速创建一个8GB大小的交换文件。

### 方法二：使用dd命令（适用于不支持fallocate的系统）

```bash
sudo dd if=/dev/zero of=/swapfile bs=1G count=8
```
这个命令会创建一个8GB大小的文件，内容全部为零。

### 设置文件权限

出于安全考虑，我们需要限制交换文件的访问权限：

```bash
sudo chmod 600 /swapfile
```

### 格式化交换文件

将文件格式化为交换空间：

```bash
sudo mkswap /swapfile
```

### 启用交换文件

```bash
sudo swapon /swapfile
```

### 调整交换倾向
```bash
sudo vim /etc/sysctl.conf
# 如果找到 vm.swappiness=0，改为：
# vm.swappiness=10
# 如果不存在，在文件末尾添加：
# vm.swappiness=10
# 修改配置后重新加载配置
sudo sysctl -p
```

### 永久生效设置

为了让交换文件在系统重启后自动启用，我们需要将其添加到`/etc/fstab`文件中：

```bash
sudo vim /etc/fstab
```

在文件末尾添加以下内容：

```
/swapfile none swap sw 0 0
```

**Nano编辑器快捷键备忘**：
- `Ctrl + O`：保存文件
- `Ctrl + X`：退出编辑器
- `Ctrl + K`：删除当前行
- `Ctrl + \`：查找并替换文本
- `Ctrl + W`：查找文本
- `Ctrl + G`：打开帮助菜单

## 删除交换空间

### 删除交换文件

1. **禁用交换文件**：
```bash
sudo swapoff /swapfile
```

2. **删除文件**：
```bash
sudo rm /swapfile
```

3. **从fstab中移除自动挂载项**：
```bash
sudo nano /etc/fstab
```
删除或注释掉与交换文件相关的行。

### 验证删除结果

```bash
free -h
sudo swapon --show
```

`free -h`应显示交换空间已归零，`sudo swapon --show`应无输出。

## 重要注意事项

1. **内存充足性**：删除交换空间前，确保系统有足够的物理内存，否则可能导致进程崩溃。

2. **休眠功能**：如果交换空间曾被用于休眠（hibernate），需先禁用休眠功能。

3. **数据备份**：删除交换分区会永久擦除数据，操作前请备份重要数据。

4. **性能考虑**：交换空间的大小通常建议为物理内存的1-2倍，但具体取决于系统用途和工作负载。

5. **SSD寿命**：在SSD上使用交换空间可能会影响其寿命，需权衡利弊。

## 总结

合理配置交换空间可以显著提高Linux系统的稳定性和可靠性，特别是在内存资源有限的情况下。通过本文介绍的方法，您可以轻松地创建、管理和删除交换空间，以满足不同场景下的系统需求。

记住，虽然交换空间很有用，但它不能替代物理内存。最佳实践是确保系统有足够的物理内存，并将交换空间作为最后的安全网。

如何在Linux系统中创建和删除交换内存（Swap）空间

滚轮上的时光

# RustFS 安装与使用教程：兼容 S3 的高性能存储解决方案

## 前言

RustFS 是一款基于 Rust 语言开发的高性能存储服务，完全兼容 S3 协议，适用于 AI/ML、大数据、互联网、工业存储等多种场景。本文将详细介绍如何部署 RustFS 服务，并演示如何在 Spring Boot 应用中集成 RustFS。

## 一、RustFS 简介



RustFS 的主要特点：
- 使用安全高效的 Rust 语言开发
- 完全兼容 Amazon S3 协议
- 支持海量数据存储
- 近乎免费使用
- 遵循 Apache 2 开源协议
- 支持国产保密设备和系统

[RustFS官方网站](https://rustfs.com/zh/)

[x-file-storage官方网站](https://x-file-storage.xuyanwu.cn/)

## 二、RustFS 服务部署

### 1. 准备工作

确保你的系统已安装 Docker 环境。

### 2. 创建部署脚本

创建一个名为 `rustfs.sh` 的部署脚本：

```bash
#!/bin/bash

curr_dir=$(pwd)

mkdir -p "$curr_dir"/data

chmod -R 755 "$curr_dir"

# 停止旧容器运行
docker stop rustfs

# 删除旧容器
docker rm rustfs

#docker rmi rustfs/rustfs

docker run -itd \
--name rustfs \
-e RUSTFS_SERVER_DOMAINS=tcuwzw.com \
-e RUSTFS_ACCESS_KEY=your_access_key \
-e RUSTFS_SECRET_KEY=your_secret_key \
-e RUSTFS_CONSOLE_ENABLE=true \
-e RUSTFS_TLS_PATH=/certs \
-p 9000:9000 \
-v "$curr_dir"/data:/data \
-v /data/nginx/ssl:/certs \
rustfs/rustfs:latest

exit 0
```

:::tip{title="提示"}
物理主机需要开放防火墙9000端口
:::

访问ip:9000即可看到如下页面，账号：your_access_key，密钥：your_secret_key

![image.png](/static/img/256a64699f1cf234805a675433d04c4e.image.webp)

### 3. 配置说明

- `RUSTFS_ACCESS_KEY` 和 `RUSTFS_SECRET_KEY`: 设置访问凭证
- `RUSTFS_CONSOLE_ENABLE`: 启用控制台
- `RUSTFS_TLS_PATH`: TLS 证书路径
- `-p 9000:9000`: 将容器 9000 端口映射到主机
- `-v "$curr_dir"/data:/data`: 挂载数据目录

### 4. 运行脚本

```bash
chmod +x rustfs.sh
./rustfs.sh
```

## 三、Spring Boot 集成 RustFS

### 1. 添加依赖

在 `pom.xml` 中添加以下依赖：

```xml
<dependency>
    <groupId>org.dromara.x-file-storage</groupId>
    <artifactId>x-file-storage-spring</artifactId>
    <version>2.3.0</version>
</dependency>
<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>s3</artifactId>
    <version>2.29.29</version>
</dependency>
```

### 2. 配置 application.yml

```yaml
dromara:
  x-file-storage: #文件存储配置
    default-platform: amazon-s3-v2-1 #默认使用的存储平台
    thumbnail-suffix: ".min.jpg" #缩略图后缀，例如【.min.jpg】【.png】
    access-key: your_access_key
    secret-key: your_secret_key
    end-point: http://your_server_ip:9000/ # RustFS 服务地址
    #对应平台的配置写在这里，注意缩进要对齐
    amazon-s3-v2:
      - platform: amazon-s3-v2-1 # 存储平台标识
        enable-storage: true  # 启用存储
        access-key: ${dromara.x-file-storage.access-key}
        secret-key: ${dromara.x-file-storage.secret-key}
        region: ap-east-1 # 必填
        end-point: ${dromara.x-file-storage.end-point}
        bucket-name: ${spring.application.name}
        domain: http://your_server_ip:9000/file/download # 资源访问地址
        base-path: / # 文件服务器的存储路径路径
```

### 3. 配置 S3Client Bean

```java
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 org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.net.URI;

@Configuration
public class S3Config {
    
    @Value("${dromara.x-file-storage.end-point}")
    private String endPoint;

    @Value("${dromara.x-file-storage.access-key}")
    private String accessKey;

    @Value("${dromara.x-file-storage.secret-key}")
    private String secretKey;

    @Bean
    public S3Client s3Client() {
        return S3Client.builder()
                .endpointOverride(URI.create(endPoint)) // RustFS 地址
                .region(Region.US_EAST_1) // 可写死，RustFS 不校验 region
                .credentialsProvider(
                        StaticCredentialsProvider.create(
                                AwsBasicCredentials.create(accessKey, secretKey)
                        )
                )
                .forcePathStyle(true) // 关键配置！RustFS 需启用 Path-Style
                .build();
    }
}
```

### 4. 创建文件上传下载控制器

```java
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.IoUtil;
import org.dromara.x.file.storage.core.FileInfo;
import org.dromara.x.file.storage.core.FileStorageService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@RestController
@RequestMapping("/file")
public class FileController {

    @Value("${spring.application.name}")
    private String bucketName;

    private final S3Client s3Client;
    private final FileStorageService fileStorageService;
    private final HttpServletResponse response;

    /**
     * 上传文件
     */
    @PostMapping("/upload")
    public Object upload(@RequestPart("file") MultipartFile file) {
        FileInfo fileInfo = fileStorageService.of(file).upload();
        // 返回文件信息
        return fileInfo;
    }

    /**
     * 下载文件
     */
    @GetMapping("/download/{fileName}")
    public void download(@PathVariable String fileName) throws IOException {
        ResponseInputStream<GetObjectResponse> objectStream = s3Client.getObject(
                GetObjectRequest
                        .builder()
                        .bucket(bucketName)
                        .key(fileName)
                        .build());
        IoUtil.write(response.getOutputStream(), true, objectStream.readAllBytes());
    }
}
```

## 四、使用示例

### 1. 文件上传

使用 Postman 或 curl 测试文件上传：

```bash
curl -X POST -F "file=@/path/to/your/file.jpg" http://localhost:8080/file/upload
```

### 2. 文件下载

通过浏览器或 curl 访问下载接口：

```bash
curl -o downloaded_file.jpg http://localhost:8080/file/download/your_file_name.jpg
```

## 五、注意事项

1. 确保 RustFS 服务已正常运行，端口未被占用
2. 在生产环境中，建议配置 HTTPS 访问
3. 根据实际需求调整存储路径和权限设置
4. 定期备份重要数据

## 六、总结

RustFS 提供了一种高性能、兼容 S3 协议的存储解决方案，特别适合需要处理海量数据的应用场景。通过本文的介绍，你应该已经掌握了 RustFS 的基本部署和使用方法。如需了解更多高级功能，请参考官方文档。

如果在使用过程中遇到任何问题，欢迎在评论区留言讨论。