前言

有些系统对于敏感信息（如：手机号码、身份证号码、家庭地址等）需要加密后将密文入库，不能明文存储。普通的加密模式下，整段内容会被整体加密，密文就不再具备被模糊查询的功能。

应用层次

在应用层中实现，通过 MyBatis 的 TypeHandler 拦截数据的读写操作。

每次查询前先从数据库查询所有记录，且在内存中对加密字段进行解密，在内存中对解密后的明文进行模糊匹配。适用于加密的字段不多且数据量不大的场景。但当数据量较大时，内存消耗会非常高，性能也会受到影响。

优点

灵活性：加解密逻辑完全由应用层控制，可以自定义加密算法。
数据库无关性：不依赖数据库的加解密功能，适用于多种数据库。

缺点

性能开销：加解密操作在应用层进行，可能增加 CPU 和内存的开销。
模糊查询困难：密文存储导致无法直接在数据库中进行模糊查询。

实现

通过MyBatis的TypeHandler进行加解密，并将所有数据加载到内存中进行过滤匹配。

配置MyBatis的`TypeHandler`

MyBatis 中的自定义类型处理器（TypeHandler），用于处理 Java 类型和 JDBC 类型之间的转换。

创建一个自定义的TypeHandler来处理手机号的加密和解密操作。

import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedTypes;
import org.example.utils.CryptoUtils;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@MappedTypes(String.class) // 指定处理的 Java 类型
public class EncryptedStringTypeHandler extends BaseTypeHandler<String> {

    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
        try {
            // 写入数据库时加密
            String encrypted = CryptoUtils.encrypt(parameter);
            ps.setString(i, encrypted);
        } catch (Exception e) {
            throw new SQLException("加密失败", e);
        }
    }

    @Override
    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        String encrypted = rs.getString(columnName);
        try {
            // 从数据库读取时解密
            return encrypted == null ? null : CryptoUtils.decrypt(encrypted);
        } catch (Exception e) {
            throw new SQLException("解密失败", e);
        }
    }

    @Override
    public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        String encrypted = rs.getString(columnIndex);
        try {
            return encrypted == null ? null : CryptoUtils.decrypt(encrypted);
        } catch (Exception e) {
            throw new SQLException("解密失败", e);
        }
    }

    @Override
    public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        String encrypted = cs.getString(columnIndex);
        try {
            return encrypted == null ? null : CryptoUtils.decrypt(encrypted);
        } catch (Exception e) {
            throw new SQLException("解密失败", e);
        }
    }
}

使用 AES 进行加解密：

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

// 使用对称加密算法（如AES）对手机号进行加密和解密
public class CryptoUtils {
    private static final String KEY = "1234567890123456"; // 密钥，长度是 16、24或32字节

    public static String encrypt(String data) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(KEY.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    public static String decrypt(String encryptedData) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(KEY.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedBytes);
    }
}

配置MyBatis的`SqlSessionFactory`

需要在MyBatis的配置中注册这个TypeHandler，以便MyBatis在操作数据库时使用它

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;

@Configuration
@MapperScan("org.example.mapper")
public class MyBatisConfig {
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        // 避免 EncryptedStringTypeHandler 被全局注册
        // sessionFactory.setTypeHandlers(new EncryptedStringTypeHandler()); // 注册 TypeHandler
        return sessionFactory.getObject();
    }
}

编写Mapper接口和XML

import org.apache.ibatis.annotations.Mapper;
import org.example.entity.User;

import java.util.List;

@Mapper
public interface UserMapper {
    List<User> selectAllUsers();
    void insertUser(User user);
}

UserMapper.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.example.mapper.UserMapper">
    <resultMap id="UserResultMap" type="org.example.entity.User">
        <id property="id" column="id"/>
        <result property="phone" column="phone" typeHandler="org.example.handler.EncryptedStringTypeHandler"/>
        <result property="name" column="name"/>
    </resultMap>

    <select id="selectAllUsers" resultMap="UserResultMap">
        SELECT id, phone, name
        FROM user
    </select>

    <insert id="insertUser" parameterType="org.example.entity.User" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user (phone, name)
        VALUES (#{phone, typeHandler=org.example.handler.EncryptedStringTypeHandler}, #{name})
    </insert>
</mapper>

在 MyBatis 的 resultMap 中，通过 typeHandler 属性指定某个字段使用 EncryptedStringTypeHandler

其他

service：

import org.example.entity.User;
import org.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public List<User> queryByPhonePattern(String phonePattern) {
        // 查询所有用户（MyBatis 会自动解密）
        List<User> allUsers = userMapper.selectAllUsers();

        // 在内存中模糊匹配
        return allUsers.stream()
                .filter(user -> user.getPhone().contains(phonePattern))
                .collect(Collectors.toList());
    }

    public void addUser(User user) {
        userMapper.insertUser(user);
    }
}

java bean：

public class User {
    private Long id;
    private String phone;
    private String name;
    // Getters and Setters
}

sql：

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `phone` varchar(255) COLLATE utf8mb4_bin NOT NULL COMMENT '加密后的手机号',
  `name` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

测试：

import org.example.entity.User;
import org.example.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest(classes = Application.class)
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testAddAndQueryUser() {
        // 添加用户
        User user = new User();
        user.setPhone("13800138000"); // 明文手机号
        user.setName("张三");
        userService.addUser(user);

        // 查询用户
        List<User> users = userService.queryByPhonePattern("138");
        assertFalse(users.isEmpty());
        assertEquals("13800138000", users.get(0).getPhone()); // 解密后的手机号
    }
}

基于数据库函数

在数据库层实现，通过数据库的加解密函数（如 MySQL 的 AES_ENCRYPT 和 AES_DECRYPT）对数据进行加解密。

在插入数据时，调用数据库的加密函数对敏感字段（如手机号）进行加密存储。在查询数据时，调用数据库的解密函数对加密字段进行解密，然后再进行模糊匹配。

不同的数据库提供了不同的加密函数，例如：

MySQL：AES_ENCRYPT 和 AES_DECRYPT
PostgreSQL：pgp_sym_encrypt 和 pgp_sym_decrypt
Oracle：DBMS_CRYPTO

优点

简化应用层代码：加解密逻辑由数据库处理，应用层无需关心加解密细节。
支持模糊查询：可以通过数据库函数实现模糊查询（如 AES_DECRYPT(column) LIKE '%...%'）

缺点

数据库依赖：依赖数据库的加解密功能，切换数据库时可能需要调整实现。
性能开销：加解密操作在数据库层进行，可能增加数据库的 CPU 和内存开销。
密钥管理：密钥需要在数据库 SQL 语句中传递，存在泄露风险。

MySQL 的 AES_ENCRYPT 和 AES_DECRYPT 函数使用的是 AES 加密算法，支持的密钥长度如下：

128 位密钥：16 个字符（例如：1234567890123456）
192 位密钥：24 个字符（例如：123456789012345678901234）
256 位密钥：32 个字符（例如：12345678901234567890123456789012）

-- 插入数据时加密
INSERT INTO user (phone, name)
VALUES (AES_ENCRYPT('13800138000', 'my_secret_key'), '张三');

-- 查询数据时解密并模糊匹配
SELECT *
FROM user
WHERE AES_DECRYPT(phone, 'my_secret_key') LIKE '%138%';

也可以使用 MySQL 的 HEX 函数将二进制数据转换为十六进制字符串，存储到 VARCHAR 字段中。查询时，使用 UNHEX 函数将十六进制字符串转换回二进制数据。

INSERT INTO user (phone, name)
VALUES (HEX(AES_ENCRYPT('13800138000', 'my_secret_key')), '张三');

SELECT id, AES_DECRYPT(UNHEX(phone), 'my_secret_key') AS phone, name
FROM user
WHERE AES_DECRYPT(UNHEX(phone), 'my_secret_key') LIKE '%8001%';

如果使用 HEX 函数，加密后的数据长度会翻倍（因为每个字节转换为 2 个十六进制字符），转换后的字符串长度是原始二进制数据长度的 2 倍。

实现

需要将 phone 字段的类型改为 BLOB 或 VARBINARY，以支持存储二进制数据。

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `phone` varbinary(128) DEFAULT NULL,
  `name` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

java bean：

public class User {
    private Long id;
    private String phone;
    private String name;
}

mapper：

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.example.entity.User;

import java.util.List;

@Mapper
public interface UserMapper {
    void insertUser(@Param("phone") String phone, @Param("name") String name);
    List<User> queryByPhonePattern(@Param("phonePattern") String phonePattern);
}

mapper xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.example.mapper.UserMapper">
    <insert id="insertUser">
        INSERT INTO user (phone, name)
        VALUES (AES_ENCRYPT(#{phone}, '1234567890123456'), #{name})
    </insert>

    <select id="queryByPhonePattern" resultType="org.example.entity.User">
        SELECT id, AES_DECRYPT(phone, '1234567890123456') AS phone, name
        FROM user
        WHERE AES_DECRYPT(phone, '1234567890123456') LIKE CONCAT('%', #{phonePattern}, '%')
    </select>
</mapper>

service：

import org.example.entity.User;
import org.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public void addUser(String phone, String name) {
        userMapper.insertUser(phone, name);
    }

    public List<User> queryByPhonePattern(String phonePattern) {
        return userMapper.queryByPhonePattern(phonePattern);
    }
}

配置：

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=1234
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# MyBatis 配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=org.example.entity
# 开启驼峰命名映射
mybatis.configuration.map-underscore-to-camel-case=true
mybatis.type-handlers-package=org.example.handler

# MyBatis 日志
logging.level.org.mybatis=DEBUG
logging.level.org.example.mapper=DEBUG

启动类：

@SpringBootApplication
@MapperScan("org.example.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

测试：

import org.example.entity.User;
import org.example.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest(classes = Application.class)
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testAddAndQueryUser() {
        // 添加用户
        userService.addUser("13800138000", "张三");

        // 查询用户
        List<User> users = userService.queryByPhonePattern("138");
        assertFalse(users.isEmpty());

        // 验证查询结果
        User queriedUser = users.get(0);
        assertEquals("13800138000", queriedUser.getPhone()); // 解密后的手机号
        assertEquals("张三", queriedUser.getName());
    }
}

基于分词密文映射表

基于 分词密文映射表 的模糊查询方案，核心思想是将敏感字段拆分为多个分词，对每个分词进行加密，并建立分词密文与目标数据行的关联关系。在查询时，对查询关键字进行加密，通过分词密文映射表进行模糊匹配，最终返回目标数据。

优点

支持模糊查询：通过分词密文映射表实现模糊查询。
灵活性：分词规则和加密算法可以自定义。

缺点

存储开销：分词密文映射表会显著增加存储空间。
性能开销：分词和加密操作在应用层进行，查询时需要多次数据库交互。
实现复杂度：需要维护分词密文映射表，增加了系统复杂性。

如果分词长度过短（如 2 个字符），攻击者可以通过穷举法（暴力破解）轻易猜测出分词内容，从而破解加密数据。分词长度越长，单个字段生成的分词数量越少，从而减少分词密文映射表的数据量。分词长度通常为 4 个英文字符（半角） 或 2 个中文字符（全角），在安全性和查询效率之间取得较好的平衡。

思路

数据存储
1. 目标表：存储原始数据，包含敏感字段（如手机号）。
2. 分词密文映射表：存储敏感字段的分词密文与目标表主键的关联关系。
分词规则
- 对敏感字段进行固定长度的分词（如 4 个字符一组）。
- 例如，手机号 15503770537 的分词结果为：
  - 1550
  - 5503
  - 5037
  - 0377
  - 3770
  - 7705
  - 7053
  - 0537
加密分词
- 对每个分词进行加密，生成密文。
- 例如，1550 加密后为 abc123，5503 加密后为 def456
查询流程
1. 对查询关键字进行分词和加密。
2. 在分词密文映射表中，使用 LIKE 查询匹配的密文。
3. 根据匹配的密文，获取目标表的主键。
4. 根据主键，从目标表中查询完整数据。

实现

目标表，存储用户信息，包含手机号等敏感字段：

CREATE TABLE user (
    id INT PRIMARY KEY AUTO_INCREMENT, -- 主键
    phone VARCHAR(16) NOT NULL,       -- 手机号（明文存储）
    name VARCHAR(64) NOT NULL         -- 用户名
);

分词密文映射表，存储手机号的分词密文与用户主键的关联关系：

CREATE TABLE phone_index (
    id INT PRIMARY KEY AUTO_INCREMENT, -- 主键
    user_id INT NOT NULL,              -- 关联的用户 ID
    token_cipher VARCHAR(128) NOT NULL -- 分词密文
);

java bean：

public class PhoneIndex {
    private Long id;
    private Long userId;
    private String tokenCipher;
}
public class User {
    private Long id;
    private String phone;
    private String name;
}

mapper：

@Mapper
public interface PhoneIndexMapper {
    void batchInsertPhoneIndex(@Param("list") List<PhoneIndex> phoneIndices);
    List<Integer> findUserIdsByTokenCipher(@Param("tokenCipher") String tokenCipher);
}

@Mapper
public interface UserMapper {
    void insertUser(User user);
    List<User> selectUsersByIds(@Param("userIds") List<Integer> userIds);
}

mapper xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.example.mapper.PhoneIndexMapper">
    <insert id="batchInsertPhoneIndex">
        INSERT INTO phone_index (user_id, token_cipher)
        VALUES
        <foreach collection="list" item="item" separator=",">
            (#{item.userId}, #{item.tokenCipher})
        </foreach>
    </insert>

    <select id="findUserIdsByTokenCipher" resultType="java.lang.Integer">
        SELECT DISTINCT user_id
        FROM phone_index
        WHERE token_cipher LIKE CONCAT('%', #{tokenCipher}, '%')
    </select>
</mapper>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.example.mapper.UserMapper">
    <insert id="insertUser" parameterType="org.example.entity.User" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user (phone, name)
        VALUES (#{phone}, #{name})
    </insert>

    <select id="selectUsersByIds" resultType="org.example.entity.User">
        SELECT id, phone, name
        FROM user
        WHERE id IN
        <foreach collection="userIds" item="userId" open="(" separator="," close=")">
            #{userId}
        </foreach>
    </select>
</mapper>

service：

import org.example.entity.PhoneIndex;
import org.example.entity.User;
import org.example.mapper.PhoneIndexMapper;
import org.example.mapper.UserMapper;
import org.example.utils.CryptoUtils;
import org.example.utils.Tokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PhoneIndexMapper phoneIndexMapper;

    @Transactional
    public void addUser(User user) {
        // 插入用户信息
        userMapper.insertUser(user);

        // 对手机号进行分词和加密
        List<String> tokens = Tokenizer.tokenize(user.getPhone(), 4);
        List<PhoneIndex> phoneIndices = new ArrayList<>();
        for (String token : tokens) {
            String tokenCipher = null;
            try {
                tokenCipher = CryptoUtils.encrypt(token);
            } catch (Exception e) {
                throw new RuntimeException("解密失败", e);
            }
            phoneIndices.add(new PhoneIndex(user.getId(), tokenCipher));
        }

        // 批量插入分词密文
        phoneIndexMapper.batchInsertPhoneIndex(phoneIndices);
    }

    /**
     * 根据手机号模糊查询用户
     *
     * @param phonePattern 手机号查询关键字
     * @return 用户列表
     */
    public List<User> queryByPhonePattern(String phonePattern) {
        // 对查询关键字进行加密
        String patternCipher = null;
        try {
            patternCipher = CryptoUtils.encrypt(phonePattern);
        } catch (Exception e) {
            throw new RuntimeException("加密失败", e);
        }
        // 在分词密文映射表中进行模糊查询
        List<Integer> userIds = phoneIndexMapper.findUserIdsByTokenCipher(patternCipher);
        // 根据用户 ID 查询用户信息
        return userMapper.selectUsersByIds(userIds);
    }
}

分词工具类：

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

public class Tokenizer {
    /**
     * 对字符串进行固定长度的分词
     *
     * @param input 输入字符串
     * @param length 分词长度
     * @return 分词结果列表
     */
    public static List<String> tokenize(String input, int length) {
        List<String> tokens = new ArrayList<>();
        for (int i = 0; i <= input.length() - length; i++) {
            tokens.add(input.substring(i, i + length));
        }
        return tokens;
    }
}

加密工具类：

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

// 使用对称加密算法（如AES）对手机号进行加密和解密
public class CryptoUtils {
    private static final String KEY = "1234567890123456"; // 密钥，长度是 16、24或32字节

    public static String encrypt(String data) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(KEY.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    public static String decrypt(String encryptedData) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(KEY.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedBytes);
    }
}

启动类：

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement
@MapperScan("org.example.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

配置：

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=1234
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# MyBatis 配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=org.example.entity
# 开启驼峰命名映射
mybatis.configuration.map-underscore-to-camel-case=true
mybatis.type-handlers-package=org.example.handler

# MyBatis 日志
logging.level.org.mybatis=DEBUG
logging.level.org.example.mapper=DEBUG

测试：

import org.example.entity.User;
import org.example.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest(classes = Application.class)
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testAddAndQueryUser() {
        // 添加用户
        User user = new User();
        user.setPhone("15503770537"); // 明文手机号
        user.setName("张三");
        userService.addUser(user);

        // 查询用户
        List<User> users = userService.queryByPhonePattern("5503");
        assertFalse(users.isEmpty());
        assertEquals("15503770537", users.get(0).getPhone()); // 验证查询结果
    }
}

参考

阿里巴巴：密文字段检索方案
京东：加解密对接的典型方案

加密存储在数据库中的数据如何进行模糊查询

前言

应用层次

实现

配置MyBatis的`TypeHandler`

配置MyBatis的`SqlSessionFactory`

编写Mapper接口和XML

其他

基于数据库函数

实现

基于分词密文映射表

思路

实现

参考

RabbitMQ如何保证消息的可靠性传输

分布式锁的几种实现方案

木浅

前言

应用层次

实现

配置MyBatis的TypeHandler

配置MyBatis的SqlSessionFactory

编写Mapper接口和XML

其他

基于数据库函数

实现

基于分词密文映射表

思路

实现

参考

RabbitMQ如何保证消息的可靠性传输

分布式锁的几种实现方案

木浅

配置MyBatis的`TypeHandler`

配置MyBatis的`SqlSessionFactory`