# 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
```

### 永久生效设置

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

```bash
sudo nano /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 的基本部署和使用方法。如需了解更多高级功能，请参考官方文档。

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

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

# Spring Boot整合Jasypt实现配置文件加密：保护敏感信息的最佳实践

## 引言

在现代应用开发中，安全性是至关重要的考量因素。Spring Boot应用的配置文件中常常包含数据库密码、API密钥等敏感信息，如果直接以明文形式存储，会带来严重的安全隐患。本文将介绍如何使用Jasypt（Java Simplified Encryption）库来实现Spring Boot配置文件的加密，保护这些敏感信息。

## 一、Jasypt简介

Jasypt（Java Simplified Encryption）是一个Java加密库，它简化了Java应用程序中的加密操作。`jasypt-spring-boot-starter`是专为Spring Boot设计的starter，可以无缝集成到Spring Boot应用中，实现配置属性的自动加解密。



主要特点：
- 支持多种加密算法
- 与Spring Boot完美集成
- 配置简单，使用方便
- 支持属性文件、YAML文件中的加密值

## 二、项目集成

### 1. 添加依赖

首先，在项目的`pom.xml`中添加Jasypt依赖：

```xml
<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>
```

### 2. 创建加密工具类

创建一个工具类用于加密和解密敏感数据：

```java
import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;
import org.jasypt.iv.RandomIvGenerator;

public class JasyptEncryptorUtils {
    
    private static final String ALGORITHM = "PBEWITHHMACSHA512ANDAES_256";
    private static final String PASSWORD = "your-secret-password"; // 测试用，生产环境不要硬编码

    public static String encrypt(String input) {
        StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
        encryptor.setPassword(PASSWORD);
        encryptor.setAlgorithm(ALGORITHM);
        encryptor.setIvGenerator(new RandomIvGenerator());
        return encryptor.encrypt(input);
    }

    public static String decrypt(String encryptedInput) {
        StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
        encryptor.setPassword(PASSWORD);
        encryptor.setAlgorithm(ALGORITHM);
        encryptor.setIvGenerator(new RandomIvGenerator());
        return encryptor.decrypt(encryptedInput);
    }

    public static void main(String[] args) {
        // 测试加密
        String originalValue = "my-sensitive-data";
        String encryptedValue = encrypt(originalValue);
        System.out.println("原始值: " + originalValue);
        System.out.println("加密值: ENC(" + encryptedValue + ")");
        
        // 测试解密
        String decryptedValue = decrypt(encryptedValue);
        System.out.println("解密值: " + decryptedValue);
    }
}
```

## 三、配置加密属性

### 1. 加密敏感数据

使用上面的工具类加密你的敏感数据。例如，加密数据库密码：

```java
String encryptedDbPassword = JasyptEncryptorUtils.encrypt("db@1234");
System.out.println("加密后的数据库密码: ENC(" + encryptedDbPassword + ")");
```

### 2. 在配置文件中使用加密值

在`application.yml`或`application.properties`中使用加密值：

```yaml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: dbuser
    password: ENC(4Bw9Jj3Z6X7yA8vB1cD2eF3gH4iJ5kL6mN7oP8qR9sT0uV1wX2yZ3) # 加密后的密码
```

### 3. 配置Jasypt

有多种方式配置Jasypt的加密密码：

#### 方式1：环境变量（推荐）

```bash
export JASYPT_ENCRYPTOR_PASSWORD=your-secret-password
```

#### 方式2：命令行参数

```bash
java -jar your-app.jar --jasypt.encryptor.password=your-secret-password
```

#### 方式3：配置文件（仅限开发）

```yaml
jasypt:
  encryptor:
    password: your-secret-password
    algorithm: PBEWITHHMACSHA512ANDAES_256
    iv-generator-classname: org.jasypt.iv.RandomIvGenerator
```

## 四、高级配置

### 1. 自定义加密器

```java
import com.ulisesbocchio.jasyptspringboot.annotation.EnableEncryptableProperties;
import org.jasypt.encryption.StringEncryptor;
import org.jasypt.encryption.pbe.PooledPBEStringEncryptor;
import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableEncryptableProperties
public class JasyptConfig {
    
    @Bean("jasyptStringEncryptor")
    public StringEncryptor stringEncryptor() {
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();
        config.setPassword(System.getProperty("jasypt.encryptor.password"));
        config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
        config.setKeyObtentionIterations("1000");
        config.setPoolSize("1");
        config.setProviderName("SunJCE");
        config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        config.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
        config.setStringOutputType("base64");
        encryptor.setConfig(config);
        return encryptor;
    }
}
```

### 2. 多环境配置

为不同环境配置不同的加密密码：

```yaml
# application-dev.yml
jasypt:
  encryptor:
    password: dev-password

# application-prod.yml
jasypt:
  encryptor:
    password: ${JASYPT_ENCRYPTOR_PASSWORD:} # 从环境变量获取
```

## 五、最佳实践

1. **不要硬编码加密密码**：加密密码不应出现在代码或配置文件中
2. **使用强加密算法**：如`PBEWITHHMACSHA512ANDAES_256`
3. **定期轮换密钥**：定期更换加密密码
4. **分环境管理**：开发、测试、生产环境使用不同的加密密码
5. **结合密钥管理服务**：对于生产环境，考虑使用Vault或KMS

## 六、常见问题解决

### 1. 启动时报错：加密密码未配置

```
Failed to bind properties under 'spring.datasource.password' to java.lang.String:
Reason: java.lang.IllegalStateException: either 'jasypt.encryptor.password' must be provided
```

**解决方案**：确保已通过环境变量或命令行参数提供加密密码。

### 2. 解密失败

**可能原因**：
- 加密密码不正确
- 加密算法不匹配
- JCE无限强度策略文件未安装

**解决方案**：
1. 验证加密密码是否正确
2. 确保加密和解密使用相同的算法
3. 安装JCE无限强度策略文件

## 七、总结

通过Jasypt实现Spring Boot配置文件加密，我们可以有效保护敏感信息，提高应用安全性。关键点包括：

1. 正确集成`jasypt-spring-boot-starter`
2. 安全地管理加密密码（通过环境变量或密钥管理服务）
3. 使用强加密算法
4. 遵循安全最佳实践

希望本文能帮助你安全地保护Spring Boot应用中的敏感配置信息。如有任何问题，欢迎在评论区讨论。