# 第一部分 概述

`Liquibase`是一个开源的数据库版本控制工具，旨在简化和自动化数据库变更的管理和部署。它允许开发人员和数据库管理员以声明式的方式定义数据库架构和数据变更，然后自动将这些变更应用到各种数据库中。`Liquibase`支持多种数据库类型，提供了良好的可移植性和可扩展性。



**使用场景**
- **持续集成和持续部署（CI/CD）**：在`CI/CD`管道中，`Liquibase`可以自动应用数据库变更脚本，确保数据库在各个环境中的一致性。
- **数据库版本控制**：通过将数据库变更脚本与应用程序代码一起管理，可以实现数据库版本的追踪和回滚。
- **团队协作**：多人团队可以通过`Liquibase`共享和协作管理数据库变更，避免冲突和重复工作。
- **自动化数据库迁移**：自动化数据库结构和数据迁移，减少手动操作的错误和工作量。


# 第二部分 支持的数据类型及其对应关系

`Liquibase`在不同数据库系统中支持多种数据类型。以下是一些常见的数据类型及其在不同数据库中的对应关系。

## 2.1 布尔类型

### 2.1.1 boolean
- **MySQLDatabase**: `BIT(1)`
- **SQLiteDatabase**: `BOOLEAN`
- **H2Database**: `BOOLEAN`
- **PostgresDatabase**: `BOOLEAN`
- **UnsupportedDatabase**: `BOOLEAN`
- **DB2Database**: `SMALLINT`
- **MSSQLDatabase**: `[bit]`
- **OracleDatabase**: `NUMBER(1)`
- **HsqlDatabase**: `BOOLEAN`
- **FirebirdDatabase**: `SMALLINT`
- **DerbyDatabase**: `SMALLINT`
- **InformixDatabase**: `BOOLEAN`
- **SybaseDatabase**: `BIT`
- **SybaseASADatabase**: `BIT`

## 2.2 整数类型

### 2.2.1 tinyint
- **MySQLDatabase**: `TINYINT`
- **SQLiteDatabase**: `TINYINT`
- **H2Database**: `TINYINT`
- **PostgresDatabase**: `SMALLINT`
- **UnsupportedDatabase**: `TINYINT`
- **DB2Database**: `SMALLINT`
- **MSSQLDatabase**: `[tinyint]`
- **OracleDatabase**: `NUMBER(3)`
- **HsqlDatabase**: `TINYINT`
- **FirebirdDatabase**: `SMALLINT`
- **DerbyDatabase**: `SMALLINT`
- **InformixDatabase**: `TINYINT`
- **SybaseDatabase**: `TINYINT`
- **SybaseASADatabase**: `TINYINT`

### 2.2.2 int
- **MySQLDatabase**: `INT`
- **SQLiteDatabase**: `INTEGER`
- **H2Database**: `INT`
- **PostgresDatabase**: `INT`
- **UnsupportedDatabase**: `INT`
- **DB2Database**: `INTEGER`
- **MSSQLDatabase**: `[int]`
- **OracleDatabase**: `INTEGER`
- **HsqlDatabase**: `INT`
- **FirebirdDatabase**: `INT`
- **DerbyDatabase**: `INTEGER`
- **InformixDatabase**: `INT`
- **SybaseDatabase**: `INT`
- **SybaseASADatabase**: `INT`

### 2.2.3 mediumint
- **MySQLDatabase**: `MEDIUMINT`
- **SQLiteDatabase**: `MEDIUMINT`
- **H2Database**: `MEDIUMINT`
- **PostgresDatabase**: `MEDIUMINT`
- **UnsupportedDatabase**: `MEDIUMINT`
- **DB2Database**: `MEDIUMINT`
- **MSSQLDatabase**: `[int]`
- **OracleDatabase**: `MEDIUMINT`
- **HsqlDatabase**: `MEDIUMINT`
- **FirebirdDatabase**: `MEDIUMINT`
- **DerbyDatabase**: `MEDIUMINT`
- **InformixDatabase**: `MEDIUMINT`
- **SybaseDatabase**: `MEDIUMINT`
- **SybaseASADatabase**: `MEDIUMINT`

### 2.2.4 bigint
- **MySQLDatabase**: `BIGINT`
- **SQLiteDatabase**: `BIGINT`
- **H2Database**: `BIGINT`
- **PostgresDatabase**: `BIGINT`
- **UnsupportedDatabase**: `BIGINT`
- **DB2Database**: `BIGINT`
- **MSSQLDatabase**: `[bigint]`
- **OracleDatabase**: `NUMBER(38, 0)`
- **HsqlDatabase**: `BIGINT`
- **FirebirdDatabase**: `BIGINT`
- **DerbyDatabase**: `BIGINT`
- **InformixDatabase**: `INT8`
- **SybaseDatabase**: `BIGINT`
- **SybaseASADatabase**: `BIGINT`

### 2.2.5 number
- **MySQLDatabase**: `numeric`
- **SQLiteDatabase**: `NUMBER`
- **H2Database**: `NUMBER`
- **PostgresDatabase**: `numeric`
- **UnsupportedDatabase**: `NUMBER`
- **DB2Database**: `numeric`
- **MSSQLDatabase**: `[numeric](18, 0)`
- **OracleDatabase**: `NUMBER`
- **HsqlDatabase**: `numeric`
- **FirebirdDatabase**: `numeric`
- **DerbyDatabase**: `numeric`
- **InformixDatabase**: `numeric`
- **SybaseDatabase**: `numeric`
- **SybaseASADatabase**: `numeric`

## 2.3 小数类型

### 2.3.1 float
- **MySQLDatabase**: `FLOAT`
- **SQLiteDatabase**: `FLOAT`
- **H2Database**: `FLOAT`
- **PostgresDatabase**: `FLOAT`
- **UnsupportedDatabase**: `FLOAT`
- **DB2Database**: `FLOAT`
- **MSSQLDatabase**: `[float](53)`
- **OracleDatabase**: `FLOAT`
- **HsqlDatabase**: `FLOAT`
- **FirebirdDatabase**: `FLOAT`
- **DerbyDatabase**: `FLOAT`
- **InformixDatabase**: `FLOAT`
- **SybaseDatabase**: `FLOAT`
- **SybaseASADatabase**: `FLOAT`

### 2.3.2 double
- **MySQLDatabase**: `DOUBLE`
- **SQLiteDatabase**: `DOUBLE`
- **H2Database**: `DOUBLE`
- **PostgresDatabase**: `DOUBLE PRECISION`
- **UnsupportedDatabase**: `DOUBLE`
- **DB2Database**: `DOUBLE`
- **MSSQLDatabase**: `[float](53)`
- **OracleDatabase**: `FLOAT(24)`
- **HsqlDatabase**: `DOUBLE`
- **FirebirdDatabase**: `DOUBLE PRECISION`
- **DerbyDatabase**: `DOUBLE`
- **InformixDatabase**: `DOUBLE PRECISION`
- **SybaseDatabase**: `DOUBLE`
- **SybaseASADatabase**: `DOUBLE`

### 2.3.3 decimal
- **MySQLDatabase**: `DECIMAL`
- **SQLiteDatabase**: `DECIMAL`
- **H2Database**: `DECIMAL`
- **PostgresDatabase**: `DECIMAL`
- **UnsupportedDatabase**: `DECIMAL`
- **DB2Database**: `DECIMAL`
- **MSSQLDatabase**: `[decimal](18, 0)`
- **OracleDatabase**: `DECIMAL`
- **HsqlDatabase**: `DECIMAL`
- **FirebirdDatabase**: `DECIMAL`
- **DerbyDatabase**: `DECIMAL`
- **InformixDatabase**: `DECIMAL`
- **SybaseDatabase**: `DECIMAL`
- **SybaseASADatabase**: `DECIMAL`

### 2.3.4 currency
- **MySQLDatabase**: `DECIMAL`
- **SQLiteDatabase**: `REAL`
- **H2Database**: `DECIMAL`
- **PostgresDatabase**: `DECIMAL`
- **UnsupportedDatabase**: `DECIMAL`
- **DB2Database**: `DECIMAL(19, 4)`
- **MSSQLDatabase**: `[money]`
- **OracleDatabase**: `NUMBER(15, 2)`
- **HsqlDatabase**: `DECIMAL`
- **FirebirdDatabase**: `DECIMAL(18, 4)`
- **DerbyDatabase**: `DECIMAL`
- **InformixDatabase**: `MONEY`
- **SybaseDatabase**: `MONEY`
- **SybaseASADatabase**: `MONEY`

## 2.4 字符串类型

### 2.4.1 char
- **MySQLDatabase**: `CHAR`
- **SQLiteDatabase**: `CHAR`
- **H2Database**: `CHAR`
- **PostgresDatabase**: `CHAR`
- **UnsupportedDatabase**: `CHAR`
- **DB2Database**: `CHAR`
- **MSSQLDatabase**: `[char](1)`
- **OracleDatabase**: `CHAR`
- **HsqlDatabase**: `CHAR`
- **FirebirdDatabase**: `CHAR`
- **DerbyDatabase**: `CHAR`
- **InformixDatabase**: `CHAR`
- **SybaseDatabase**: `CHAR`
- **SybaseASADatabase**: `CHAR`

### 2.4.2 varchar
- **MySQLDatabase**: `VARCHAR`
- **SQLiteDatabase**: `VARCHAR`
- **H2Database**: `VARCHAR`
- **PostgresDatabase**: `VARCHAR`
- **UnsupportedDatabase**: `VARCHAR`
- **DB2Database**: `VARCHAR`
- **MSSQLDatabase**: `[varchar](1)`
- **OracleDatabase**: `VARCHAR2`
- **HsqlDatabase**: `VARCHAR`
- **FirebirdDatabase**: `VARCHAR`
- **DerbyDatabase**: `VARCHAR`
- **InformixDatabase**: `VARCHAR`
- **SybaseDatabase**: `VARCHAR`
- **SybaseASADatabase**: `VARCHAR`

### 2.4.3 nchar
- **MySQLDatabase**: `NCHAR`
- **SQLiteDatabase**: `NCHAR`
- **H2Database**: `NCHAR`
- **PostgresDatabase**: `NCHAR`
- **UnsupportedDatabase**: `NCHAR`
- **DB2Database**: `NCHAR`
- **MSSQLDatabase**: `[nchar](1)`
- **OracleDatabase**: `NCHAR`
- **HsqlDatabase**: `CHAR`
- **FirebirdDatabase**: `NCHAR`
- **DerbyDatabase**: `NCHAR`
- **InformixDatabase**: `NCHAR`
- **SybaseDatabase**: `NCHAR`
- **SybaseASADatabase**: `NCHAR`

### 2.4.4 nvarchar
- **MySQLDatabase**: `NVARCHAR`
- **SQLiteDatabase**: `NVARCHAR`
- **H2Database**: `NVARCHAR`
- **PostgresDatabase**: `VARCHAR`
- **UnsupportedDatabase**: `NVARCHAR`
- **DB2Database**: `NVARCHAR`
- **MSSQLDatabase**: `[nvarchar](1)`
- **OracleDatabase**: `NVARCHAR2`
- **HsqlDatabase**: `VARCHAR`
- **FirebirdDatabase**: `NVARCHAR`
- **DerbyDatabase**: `VARCHAR`
- **InformixDatabase**: `NVARCHAR`
- **SybaseDatabase**: `NVARCHAR`
- **SybaseASADatabase**: `NVARCHAR`

## 2.5 日期和时间类型

### 2.5.1 datetime
- **MySQLDatabase**: `datetime`
- **SQLiteDatabase**: `TEXT`
- **H2Database**: `TIMESTAMP`
- **PostgresDatabase**: `TIMESTAMP WITHOUT TIME ZONE`
- **UnsupportedDatabase**: `datetime`
- **DB2Database**: `TIMESTAMP`
- **MSSQLDatabase**: `[datetime]`
- **OracleDatabase**: `TIMESTAMP`
- **HsqlDatabase**: `TIMESTAMP`
- **FirebirdDatabase**: `TIMESTAMP`
- **DerbyDatabase**: `TIMESTAMP`
- **InformixDatabase**: `DATETIME YEAR TO FRACTION(5)`
- **SybaseDatabase**: `datetime`
- **SybaseASADatabase**: `datetime`

### 2.5.2 time
- **MySQLDatabase**: `time`
- **SQLiteDatabase**: `time`
- **H2Database**: `time`
- **PostgresDatabase**: `TIME WITHOUT TIME ZONE`
- **UnsupportedDatabase**: `time`
- **DB2Database**: `time`
- **MSSQLDatabase**: `[time](7)`
- **OracleDatabase**: `DATE`
- **HsqlDatabase**: `time`
- **FirebirdDatabase**: `time`
- **DerbyDatabase**: `time`
- **InformixDatabase**: `INTERVAL HOUR TO FRACTION(5)`
- **SybaseDatabase**: `time`
- **SybaseASADatabase**: `time`

### 2.5.3 timestamp
- **MySQLDatabase**: `timestamp`
- **SQLiteDatabase**: `TEXT`
- **H2Database**: `TIMESTAMP`
- **PostgresDatabase**: `TIMESTAMP WITHOUT TIME ZONE`
- **UnsupportedDatabase**: `timestamp`
- **DB2Database**: `timestamp`
- **MSSQLDatabase**: `[datetime]`
- **OracleDatabase**: `TIMESTAMP`
- **HsqlDatabase**: `TIMESTAMP`
- **FirebirdDatabase**: `TIMESTAMP`
- **DerbyDatabase**: `TIMESTAMP`
- **InformixDatabase**: `DATETIME YEAR TO FRACTION(5)`
- **SybaseDatabase**: `datetime`
- **SybaseASADatabase**: `timestamp`

### 2.5.4 date
- **MySQLDatabase**: `date`
- **SQLiteDatabase**: `date`
- **H2Database**: `date`
- **PostgresDatabase**: `date`
- **UnsupportedDatabase**: `date`
- **DB2Database**: `date`
- **MSSQLDatabase**: `[date]`
- **OracleDatabase**: `date`
- **HsqlDatabase**: `date`
- **FirebirdDatabase**: `date`
- **DerbyDatabase**: `date`
- **InformixDatabase**: `date`
- **SybaseDatabase**: `date`
- **SybaseASADatabase**: `date`

## 2.6 其他数据类型

### 2.6.1 blob
- **MySQLDatabase**: `LONGBLOB`
- **SQLiteDatabase**: `BLOB`
- **H2Database**: `BLOB`
- **PostgresDatabase**: `BYTEA`
- **UnsupportedDatabase**: `BLOB`
- **DB2Database**: `BLOB`
- **MSSQLDatabase**: `[varbinary](MAX)`
- **OracleDatabase**: `BLOB`
- **HsqlDatabase**: `BLOB`
- **FirebirdDatabase**: `BLOB`
- **DerbyDatabase**: `BLOB`
- **InformixDatabase**: `BLOB`
- **SybaseDatabase**: `IMAGE`
- **SybaseASADatabase**: `LONG BINARY`

### 2.6.2 clob
- **MySQLDatabase**: `LONGTEXT`
- **SQLiteDatabase**: `TEXT`
- **H2Database**: `CLOB`
- **PostgresDatabase**: `TEXT`
- **UnsupportedDatabase**: `CLOB`
- **DB2Database**: `CLOB`
- **MSSQLDatabase**: `[varchar](MAX)`
- **OracleDatabase**: `CLOB`
- **HsqlDatabase**: `CLOB`
- **FirebirdDatabase**: `BLOB SUB_TYPE TEXT`
- **DerbyDatabase**: `CLOB`
- **InformixDatabase**: `CLOB`
- **SybaseDatabase**: `TEXT`
- **SybaseASADatabase**: `LONG VARCHAR`

### 2.6.3 function
- **MySQLDatabase**: `FUNCTION`
- **SQLiteDatabase**: `FUNCTION`
- **H2Database**: `FUNCTION`
- **PostgresDatabase**: `FUNCTION`
- **UnsupportedDatabase**: `FUNCTION`
- **DB2Database**: `FUNCTION`
- **MSSQLDatabase**: `[function]`
- **OracleDatabase**: `FUNCTION`
- **HsqlDatabase**: `FUNCTION`
- **FirebirdDatabase**: `FUNCTION`
- **DerbyDatabase**: `FUNCTION`
- **InformixDatabase**: `FUNCTION`
- **SybaseDatabase**: `FUNCTION`
- **SybaseASADatabase**: `FUNCTION`

### 2.6.4 UNKNOWN
- **MySQLDatabase**: `UNKNOWN`
- **SQLiteDatabase**: `UNKNOWN`
- **H2Database**: `UNKNOWN`
- **PostgresDatabase**: `UNKNOWN`
- **UnsupportedDatabase**: `UNKNOWN`
- **DB2Database**: `UNKNOWN`
- **MSSQLDatabase**: `[UNKNOWN]`
- **OracleDatabase**: `UNKNOWN`
- **HsqlDatabase**: `UNKNOWN`
- **FirebirdDatabase**: `UNKNOWN`
- **DerbyDatabase**: `UNKNOWN`
- **InformixDatabase**: `UNKNOWN`
- **SybaseDatabase**: `UNKNOWN`
- **SybaseASADatabase**: `UNKNOWN`

### 2.6.5 uuid
- **MySQLDatabase**: `char(36)`
- **SQLiteDatabase**: `TEXT`
- **H2Database**: `UUID`
- **PostgresDatabase**: `UUID`
- **UnsupportedDatabase**: `char(36)`
- **DB2Database**: `char(36)`
- **MSSQLDatabase**: `[uniqueidentifier]`
- **OracleDatabase**: `RAW(16)`
- **HsqlDatabase**: `char(36)`
- **FirebirdDatabase**: `char(36)`
- **DerbyDatabase**: `char(36)`
- **InformixDatabase**: `char(36)`
- **SybaseDatabase**: `UNIQUEIDENTIFIER`
- **SybaseASADatabase**: `UNIQUEIDENTIFIER`

liquibase支持的数据类型及其对应关系

常用数据加解密算法与应用

# 第一部分 概述

数据脱敏是一种重要的数据安全技术，它通过特定的算法对敏感数据进行变形或替换，以保护个人隐私和企业机密，同时允许数据在开发、测试、分析等环境中使用，而不会带来安全风险。数据脱敏，也称为数据去隐私化，是指在给定脱敏规则和策略的情况下，对敏感数据（如手机号、银行卡号等）进行转换或修改的技术手段，防止敏感数据直接在不可靠的环境下使用。



数据脱敏分为静态数据脱敏（`SDM`）和动态数据脱敏（`DDM`）：

- **静态数据脱敏**：适用于将数据从生产环境抽取出来后，在非生产环境中使用，如测试、开发、培训、数据分析等场景。
- **动态数据脱敏**：适用于生产环境，能够在访问敏感数据时实时进行脱敏处理，根据不同角色和权限执行不同的脱敏方案。

**数据脱敏的实现方式**
- **使用脚本进行脱敏**：早期用户通过编写代码或脚本来实现数据的脱敏变形，例如将敏感信息替换为其他信息。
- **使用专业数据脱敏产品**：随着信息化管理的完善和数据使用场景的复杂化，专业的数据脱敏产品因其高效性和准确性而成为主流选择。
- **基于规则的脱敏**：数据脱敏可以根据业务需求自行定义和编写脱敏规则，支持对特定敏感字段进行不落地脱敏。
- **数据脱敏算法**：包括替换、无效化、随机值、数据替换、对称加密、平均值处理、偏移和取整等。

**数据脱敏的价值**
- 防止组织内部对隐私数据的滥用。
- 防止隐私数据在未经脱敏的情况下从组织流出。
- 满足企业保护隐私数据和保持监管合规的需要。
- 降低数据泄露风险，提高数据的安全性。
- 允许在保护隐私的前提下，对数据进行分析和使用，支持企业业务的连续性和创新。
- 数据脱敏是企业数据安全管理不可或缺的一部分，对于保护个人隐私和企业数据资产具有重要意义。

# 第二部分 Java中使用Jackson实现数据脱敏

## 2.1 常用数据脱敏规则

- **姓名**: 两个字名称保留姓，名部分使用`*`替换，三个字(含)保留首尾两个字，其余部分使用`*`替换
- **身份证号**: 保留前`6`位与后3位，中间部分使用`*`替换
- **手机号**: 保留前`3`位与后`4`位，中间部分使用`*`替换
- **邮箱**: 保留前`2`位与`@(含)`后内容，中间部分使用`*`替换
- **银行卡**: 保留前`4`位与后`4`位，中间部分使用`*`替换

基于上述规则，将脱敏规则定义为枚举，示例代码如下：

```java
/**
 * 敏感信息策略
 */
public enum SensitiveStrategy {

    /**
     * 姓名
     */
    CHINESE_NAME(s -> s.replaceAll("(\\S)\\S(\\S*)", "$1*$2")),
    /**
     * 身份证号
     */
    ID_CARD(s -> s.replaceAll("(\\d{6})\\d{9}(\\w{3})", "$1*********$2")),
    /**
     * 手机号
     */
    PHONE(s -> s.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2")),
    /**
     * 邮箱
     */
    EMAIL(s -> s.replaceAll("(\\w{2})\\w*(@[\\w|\\.]*)", "$1****$2")),
    /**
     * 银行卡
     */
    BANK_CARD_NO(s -> s.replaceAll("(\\w{4})\\w*(\\w{4})", "$1********$2")),

    /**
     * 自定义
     */
    CUSTOM(s -> s);

    private final Function<String, String> desensitizer;

    private SensitiveStrategy(Function<String, String> desensitizer) {
        this.desensitizer = desensitizer;
    }

    public String desensitized(String value) {
        return this.desensitizer.apply(value);
    }
}
```

在上述示例代码中，处理定义的几种脱敏规则，额外增加了`CUSTOM`用于标识当现有规则不满足时的自定义处理。


:::tip{title="提示"}
由于不同系统对数据脱敏的要求不同，上述脱敏规则仅为参考，实际应用中应根据实际情况进行调整。
:::

## 2.2 Jackson脱敏实现

在`Jackson`中支持用户自定义序列化，在脱敏实现中，针对不同的规则编写不同的序列化类显然是比较繁琐的，可以借助自定义注解的形式动态使用上一节中的脱敏规则枚举，在需要进行脱敏的字段上只需要添加脱敏注解即可。

接下来编写用于脱敏所需的注解，示例代码如下：

```java
@Retention(RUNTIME)
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
@JacksonAnnotationsInside
@JsonSerialize(using = SensitiveSerializer.class)
public @interface Sensitive {
    SensitiveStrategy value();

    String regex() default "";

    String replacement() default "";
}
```

在脱敏注解中包含三个字段：
- value: 表示使用的脱敏规则
- regex: 当脱敏规则为`CUSTOM`时必填，用于定义自定义脱敏规则的正则表达式
- replacement: 当脱敏规则为`CUSTOM`时必填，用于定义自定义脱敏规则的替换表达式

最后需要实现脱敏注解中使用的`JsonSerialize`注解对应的`SensitiveSerializer`实现，具体的脱敏逻辑应该在此类中处理，示例代码如下：

```java
public class SensitiveSerializer extends StdScalarSerializer<String>
        implements ContextualSerializer {
    private Sensitive sensitive;

    public SensitiveSerializer(Sensitive sensitive) {
        super(String.class);
        this.sensitive = sensitive;
    }

    public SensitiveSerializer() {
        super(String.class);
    }

    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider provider) 
            throws IOException {
        if (sensitive == null) {
            gen.writeString(value);
            return;
        }
        SensitiveStrategy strategy = sensitive.value();
        if (SensitiveStrategy.CUSTOM == strategy) {
            gen.writeString(value.replaceAll(sensitive.regex(), sensitive.replacement()));
            return;
        }
        gen.writeString(strategy.desensitized(value));
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializers, BeanProperty property)
            throws JsonMappingException {
        if (property == null) {
            return serializers.findNullValueSerializer(property);
        }
        // 非 String 类直接跳过
        if (Objects.equals(property.getType().getRawClass(), String.class)) {
            Sensitive sensitive = property.getAnnotation(Sensitive.class);
            if (sensitive == null) {
                sensitive = property.getContextAnnotation(Sensitive.class);
            }
            if (sensitive != null) {
                return new SensitiveSerializer(sensitive);
            }
        }
        return serializers.findValueSerializer(property.getType(), property);
    }
}
```

观察`SensitiveSerializer`的实现，与传统的自定义序列化不同，`SensitiveSerializer`实现了`ContextualSerializer`接口，该接口中定义了`createContextual`方法用于在序列化的时候，根据属性的脱敏注解动态创建实际的脱敏序列化实现。

最后，编写测试实体类对上述逻辑进行测试验证：

```java
@Data
@Accessors(chain = true)
public static class User {
    @Sensitive(SensitiveStrategy.CHINESE_NAME)
    private String name;
    @Sensitive(SensitiveStrategy.ID_CARD)
    private String idCardNo;
    @Sensitive(SensitiveStrategy.PHONE)
    private String phone;
    @Sensitive(SensitiveStrategy.EMAIL)
    private String email;
    @Sensitive(SensitiveStrategy.BANK_CARD_NO)
    private String bankCardNo;
}

@Test
public void testSensitive() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
    User user = new User()
        .setName("蒋固金")
        .setIdCardNo("320324123456781452")
        .setPhone("15111111111")
        .setEmail("1013195469@qq.com")
        .setBankCardNo("6225881304837593");
    System.out.println(mapper.writeValueAsString(user));
}
```

运行示例代码观察控制台输出

```
{
  "name" : "蒋*金",
  "idCardNo" : "320324*********452",
  "phone" : "151****1111",
  "email" : "10****@qq.com",
  "bankCardNo" : "6225********7593"
}
```


:::info{title="相关信息"}
在`Jackson`库中，`ContextualSerializer`接口是一个用于自定义序列化器以支持更细粒度控制的接口。当需要基于对象的具体类型或者属性值来选择不同的序列化器时，这个接口就非常有用。
`ContextualSerializer`接口继承自`JsonSerializer<T>`接口，它要求实现一个`createContextual()`方法，该方法返回一个`JsonSerializer<?>`类型的实例，这个实例将用于实际的序列化过程。

**主要作用和用途**

- **上下文感知序列化**：允许开发者根据对象的上下文信息（比如对象的属性值、注解、甚至是运行时的类型）来决定使用哪个序列化器。
- **多态序列化**：在处理多态类层次结构时，可以根据子类的特定类型来选择不同的序列化器，从而实现更精细的序列化控制。
- **动态配置**：可以在序列化过程中动态地配置序列化器的行为，例如，根据属性的值来决定是否序列化该属性，或者如何序列化。
- **注解驱动的序列化**：结合Jackson的注解，可以利用`ContextualSerializer`来实现基于注解的序列化逻辑。
- **性能优化**：在某些情况下，可以实现一个高效的序列化器，它仅在需要时才进行额外的类型检查或上下文评估。

实现`ContextualSerializer`接口的类通常会与`Jackson`的注解处理器结合使用，以提供更灵活的序列化策略。例如，会定义一个带有`@JsonSerialize(using = MyContextualSerializer.class)`注解的类，其中`MyContextualSerializer`是一个实现了`ContextualSerializer`接口的类。

使用`ContextualSerializer`时，通常会重载`createContextual()`方法，以便于在该方法中进行必要的检查和配置，然后返回适当的`JsonSerializer`实例。这样`Jackson`在序列化对象时会调用这个`createContextual()`方法来获取正确的序列化器实例。
:::

Java结合Jackson实现数据脱敏

# 第一部分 概述
将长链接转换为短链接是一种常见的需求，通常用于在限制长度的场景下分享链接，或者简化链接以提高用户体验。本篇文章讨论几种相对通用的实现方式（第三方服务不在讨论范围）。




# 第二部分 常用方案


:::tip{title="提示"}
生成短链接时，确保其唯一性和尽可能短是非常关键的。
:::

## 2.1 基于时间戳+随机数/计数器

**方案说明**：
- **时间戳**: 使用当前时间的时间戳作为基础部分，确保了每个短链接的生成时间不同，自然具有一定的唯一性。
- **随机数/计数器**: 在时间戳基础上附加一个较短的随机数或递增计数器，以应对同一毫秒内生成多个短链接的情况，确保唯一性。

**优点**：
- 利用时间戳的天然顺序，易于排序和管理。
- 随机数或计数器的加入，提高了并发情况下的唯一性保障。

**缺点**：
- 时间戳部分较长，可能影响短链接的简洁度。

## 2.2 Base62编码

**方案说明**：
- 将长整型`ID`（如`基于时间戳+计数器`生成的`ID`）转换为`Base62`编码。`Base62`包含小写字母、大写字母和数字（共`62`个字符），比传统的`Base16`（十六进制）或`Base32`能更高效地利用字符空间，使得同样的数字可以表示更短的字符串。

**优点**：
- 极大地缩短了编码长度，提升了短链接的简洁性。
- 可以通过逆向解码恢复原始`ID`，便于查询和管理。

**缺点**：
- 需要处理潜在的冲突问题，尤其是在高并发场景下。


:::info{title="相关信息"}
`Base62`是一种将数字和字母混合起来的编码方式，使用了`62`个字符，包括小写字母、大写字母和数字`0-9`。`Base62`编码常用于将较长的数字或数据转换为更短、更易于处理和传输的字符串表示形式。

**使用场景**
- **短链接生成**：`Base62`编码常用于生成短链接，将长网址转换为短字符串，方便分享和传播。短链接不仅更美观，而且更易于记忆和传输，因此在分享网址时非常流行。
- **密钥生成**：`Base62`编码可用于生成密钥或令牌，用于安全验证或身份验证。例如，生成访问令牌、`API`密钥或会话标识符等。
- **文件名生成**：`Base62`编码可用于生成独一无二的文件名，避免文件名冲突和重复，同时保持文件名的简洁和易读性。
- **数据转换**：在数据传输过程中，`Base62`编码可用于将二进制数据或大整数转换为字符串形式，方便存储、传输和解析。
- **短字符串存储**：在数据库中存储较短的标识符或键值对时，`Base62`编码可节省存储空间，并提高查询和索引的效率。
- 
总的来说，`Base62`编码适用于需要将较长的数字或数据转换为短、易于处理和传输的字符串形式的场景。它具有良好的可读性、节省存储空间的优势，并广泛应用于短链接生成、密钥生成、文件名生成等领域。
:::

## 2.3 自增ID+连续哈希映射

**方案说明**：
- 维护一个全局自增ID作为长链接的标识。
- 使用连续哈希映射（如一致性哈希）将这个`ID`映射到一个较短的字符串空间中，确保映射的一致性和高效查询。

**优点**：
- 通过连续哈希映射，可以在保持唯一性的前提下，有效控制短链接的长度。
- 易于扩展和维护。

**缺点**：
- 实现相对复杂，需要考虑哈希环的平衡性和扩展性。

:::info{title="相关信息"}
连续哈希映射是一种多次应用哈希函数的方法，其中每次哈希函数的输出作为下一次哈希函数的输入。通过多次哈希映射，可以进一步增加哈希函数的分散性和唯一性，从而提高哈希算法的安全性和性能。

**示例**
假设有一个长字符串需要哈希，我们可以将该字符串首先应用第一个哈希函数，然后将结果再次应用到第二个哈希函数，以此类推，直到达到预定的哈希次数或达到某个条件为止。最终的哈希值即为连续哈希映射的结果。

**使用场景**
- **密码学中的加密算法**：连续哈希映射可以用于密码学中的加密算法，如密码哈希函数。例如，在密码存储过程中，可以多次应用哈希函数对密码进行哈希，增加密码的安全性。
- **数据完整性校验**：在数据传输过程中，可以使用连续哈希映射来对数据进行完整性校验。发送方可以将数据连续哈希映射后的结果附加到数据中，接收方可以再次对接收到的数据应用相同的连续哈希映射，以验证数据的完整性。
- **分布式系统中的数据分片**：在分布式系统中，可以使用连续哈希映射来将数据分配到不同的节点或分片中。通过多次哈希映射，可以使数据更均匀地分布在不同的节点中，提高系统的负载均衡性和性能。

总的来说，连续哈希映射适用于需要增加哈希函数分散性和唯一性的场景，如密码学、数据完整性校验和分布式系统中的数据分片等领域。通过多次应用哈希函数，可以提高数据的安全性、完整性和性能。
:::

## 2.4 哈希算法+自定义规则

**方案说明**：
- 使用`MD5`或`SHA-256`等安全哈希算法处理长链接或其`ID`，然后取哈希值的前几位作为短链接的基础。
- 可以根据需要，对哈希值进行自定义规则处理，如替换、移位等，进一步增加唯一性并缩短长度。

> 在`Hash`算法选择中，通常会使用`MurmurHash`算法生成长链接的`hash`值。 

**优点**：
- 哈希算法保证了良好的唯一性。
- 自定义规则可以灵活调整以适应不同的长度要求。

**缺点**：
- 存在极小概率的哈希碰撞问题，需要额外机制处理。


:::info{title="相关信息"}

`MurmurHash`是一种快速非加密型哈希函数，由`Austin Appleby`在2008年创建。它被设计用于高速哈希算法中，具有良好的散列性能和低碰撞率。`MurmurHash`在计算哈希值时非常快速，并且在处理非常大的数据集时具有良好的性能。

**简介**

`MurmurHash`算法的核心思想是通过混合、变换和组合输入数据的各个部分来计算哈希值。它采用了一系列位操作、移位操作、异或运算和乘法等简单的数学运算，以及一个具有良好随机性的特定常数作为种子来实现哈希计算。`MurmurHash`算法的设计目标是高速、可靠和具有良好的分布特性。

**适应场景**

`MurmurHash`算法适用于许多场景，包括但不限于：
- **哈希表**：用于实现哈希表数据结构，用于快速查找和存储键值对。
- **数据分布**：用于分布式系统中的数据分区和负载均衡，确保数据分布均匀。
- **哈希检验**：用于数据完整性检验，如校验和计算、文件校验等。
- **哈希索引**：用于构建索引数据结构，提高检索效率。

**优点**

- **速度快**：`MurmurHash`算法在计算哈希值时非常快速，适用于需要高效处理大量数据的场景。
- **低碰撞率**：`MurmurHash`算法具有良好的散列性能，碰撞率较低，适用于要求较高的哈希算法场景。
- **分布均匀**：`MurmurHash`算法生成的哈希值分布均匀，有利于提高数据的均匀分布性，降低哈希冲突的概率。

**总结**

`MurmurHash`算法是一种快速、可靠且具有良好散列性能的哈希算法，适用于各种需要哈希计算的场景。它的速度快、碰撞率低以及分布均匀等特点使得它成为了许多哈希算法的首选之一。无论是在哈希表、数据分布、哈希检验还是哈希索引等领域，`MurmurHash`都展现出了出色的性能和应用价值。
:::

# 第三部分 综合方案

在实际应用中，通常会结合上述多种方法，例如先使用时间戳加计数器生成`ID`，然后将`ID`进行`Base62`编码，同时设计一套冲突检测和解决机制（如在数据库中检查`ID`是否已存在），确保生成的短链接既唯一又尽量短。此外，还可以引入布隆过滤器等数据结构来快速判断`ID`是否存在，减少数据库查询压力。

## 3.1 MurmurHash+Base62编码

使用`MurmurHash`和`Base62`结合的方法生成短链接是一种常见的做法，这样可以保证生成的短链接具有较高的唯一性和易读性。下面是使用`MurmurHash`和`Base62`结合的方法生成短链接的示例代码：

```java
long hash = MurmurHash.hash32("https://blog.jianggujin.com/post/5");
System.out.println("长链接hash:" + hash);
byte[] bytes = ByteBuffer.allocate(Long.BYTES).putLong(hash).array();
String encoded = Base62.encode(bytes);
System.out.println("转换后编码:" + encoded);

hash = MurmurHash.hash64("https://blog.jianggujin.com/post/5");
System.out.println("长链接hash:" + hash);
bytes = ByteBuffer.allocate(Long.BYTES).putLong(hash).array();
encoded = Base62.encode(bytes);
System.out.println("转换后编码:" + encoded);
```

运行示例代码观察控制台输出

```
长链接hash:640577084
转换后编码:0000hLnMS
长链接hash:-4731572046405325430
转换后编码:GL9dGlAe8Yk
```

> 示例代码中的`MurmurHash`和`Base62`使用`hutool`工具实现，在进行`hash`处理时，可根据实际情况选择`hash32`或`hash64`。

:::warning{title="注意"}
虽然`MurmurHash`和`Base62`结合的方式生成短链接具有较高的唯一性，依然存在冲突的可能，在实际使用过程中需要考虑发生冲突后的处理，比如增加自增整数等。
:::

## 3.2 自增ID+Base62编码

使用自增`ID`和`Base62`结合的方法生成短链接是另一种常见的做法，相较于使用`MurmurHash`和`Base62`结合的方法，采用自增`ID`的方式可确保生成的短链的唯一性。自增`ID`的生成可以利用数据库、`Redis`、雪花算法等方式生成。下面是使用雪花算法和`Base62`结合的方法生成短链接的示例代码：

```java
long hash = IdWorker.getId();
System.out.println("长链接hash:" + hash);
byte[] bytes = ByteBuffer.allocate(Long.BYTES).putLong(hash).array();
String encoded = Base62.encode(bytes);
System.out.println("转换后编码:" + encoded);
```

运行示例代码观察控制台输出

```
长链接hash:1787313950076686338
转换后编码:281uqNpdic6
```

> 使用自增`ID`和`Base62`结合的方式，短链接的`hash`值的生成与链接本身无关

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述