通过注解对敏感字段进行加密解密

🌏应用场景

当系统中涉及一些个人信息，如身份证号码、手机号码等，不方便明文显示，要进行加密保存的数据，如果使用的地方很多，在每个插入数据和查询数据处进行加解密这个过程十分繁琐。整个系统的冗余代码会特别的多。

🤸解决方案

使用拦截器，在每次对数据库进行操作时，对查询条件和查询结果中涉及加密的字段进行加密解密，减少系统中的冗余代码。

对于敏感字段的确定，通过对请求实体或者返回实体对象的指定字段加注解的方式。

目前该方案的优缺点：

🥳优点：显著减少冗余代码；

🤡缺点：查询的mapper里面涉及加密字段的请求参数和返回参数都需要使用实体类接收；

这个方案涉及的一些知识点

• mybatis的工作原理及核心流程
• mybatis拦截器相关
• Java注解的相关知识

mybatis的工作原理及核心流程

mybatis 的底层是封装了JDBC的接口的，mybatis 的核心对象也和JDBC类型。

整个mybatis 的核心流程就是围绕它的这四个核心对象的：

1.读取配置文件MyBatisConfig.java ，获取数据库的配置信息，即读取 mybatis-config.xml 文件、，进行相关配置。

❗ 此文件可以配置的信息包括：

• properties 属性

• settings 设置

• typeAliases 类型别名

• typeHandlers 类型处理器

• objectFactory 对象工厂

• plugins 插件

• environments 环境配置

  • environment 环境变量
  • transactionManager 事务管理器
  • dataSource 数据源

• databaseIdProvider 数据库厂商标识

• mappers 映射器

• 通过configuration - setting 进行一些全局参数配置，配置一些功能及权限，例如以下代码：

  <configuration>
      <!-- 设置 -->
      <settings>
          <!-- 使全局的映射器启用或禁用缓存 -->
          <setting name="cacheEnabled" value="true"/>
          <!-- 允许JDBC 支持自动生成主键 -->
          <setting name="useGeneratedKeys" value="true"/>
          <!-- 配置默认的执行器.SIMPLE就是普通执行器;
  			REUSE执行器会重用预处理语句(prepared statements);
  			BATCH执行器将重用语句并执行批量更新 -->   
          <setting name="defaultExecutorType" value="SIMPLE"/>
          <!-- 指定 MyBatis 所用日志的具体实现 -->
          <setting name="logImpl" value="SLF4J"/>
      </settings>
  </configuration>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

• 通过configuration - plugins 进行一些拦截器配置，例如以下代码：

    <plugins>
        <plugin interceptor="com.doordiey.test.interceptor.EncryptInterceptor"/>
        <plugin interceptor="com.doordiey.test.interceptor.DecryptInterceptor"/>
    </plugins>
1
2
3
4

2.加载映射文件，每个文件对应一张表。

即每个表对应一个xml文件，类似于 ABCMapper.xml 该表内为@Mapper 注解的ABCMapper.java 文件内对应的每一个方法。

3.构建会话工厂，会话工厂SqlSessionFactory。

4.构建会话对象，即生成SqlSession。

5.Executor 执行器根据会话对象以及传入的参数动态生成要执行的SQL语句，并进行查询缓存的维护。

6.MappedStatement 对象，在执行器的执行方法中用该对象对映射的信息进行封装。

7.输入参数映射，将查询传入的参数类为Map、List等集合类型进行映射。类似于JDBC对preparedStatement对象设置参数的过程。

8.输出结果映射。类似于JDBC对结果集的解析过程

总结为：加载配置、建立会话、执行语句、结果处理。

mybatis拦截器相关

mybatis 的拦截器实现是通过在其配置文件中通过插件进行配置。这里的插件值的是对默认功能的一种自定义修改。

拦截器拦截的对象

MyBatis 中使用拦截器可以拦截的对象主要有四种：

• ParamterHandler 处理SQL的参数对象 —参数的处理
• ResultSetHandler 处理SQL的返回结果集 ----结果集的处理
• StatementHandler 数据库的处理对象，用于执行SQL语句 ----SQL语句的构建
• Executor MyBatis的执行器，用于执行增删改查操作 ----执行

拦截器拦截的过程

拦截的时候通过代理的方式，将要拦截的对象包装一下，生成一个代理对象

在进行拦截的时候要对2个步骤：

1.对拦截器和拦截对象进行处理，利用反射技术，创建拦截器interceptor，创建要拦截的对象；

2.将拦截器和对象包装在一起，并对拦截的对象进行一个重新赋值

通过代码还原一下具体过程

将拦截器和对象包装在一起

package org.apache.ibatis.plugin;

import java.util.Properties;

//Mybatis 的 拦截器接口
public interface Interceptor {
    Object intercept(Invocation var1) throws Throwable;

    default Object plugin(Object target) {
	// 其中这里就是将拦截器和对象包装在一起：详细见下面
        return Plugin.wrap(target, this);
    }

    default void setProperties(Properties properties) {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Plugin.wrap方法代码见下面所示：

public static Object wrap(Object target, Interceptor interceptor) {
	// 获取拦截器的Intercepts注解的所有Signature参数，即该拦截器要拦截的类和对象的方法、参数; 
        Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
	//获取拦截对象的类
        Class<?> type = target.getClass();
	//获取所有接口
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
	// 根据返回的接口数量，判断是否要拦截的，要拦截的对象生成将拦截器和拦截对象封装在一起的代理对象
        return interfaces.length > 0 ? Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)) : target;
    }
1
2
3
4
5
6
7
8
9
10

获取拦截器对象的Intercepts注解的所有Signature参数

private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
	// 获取注解Intercepts的信息
        Intercepts interceptsAnnotation = (Intercepts)interceptor.getClass().getAnnotation(Intercepts.class);
        if (interceptsAnnotation == null) {
            throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
        } else {
            Signature[] sigs = interceptsAnnotation.value();
            Map<Class<?>, Set<Method>> signatureMap = new HashMap();
            Signature[] var4 = sigs;
            int var5 = sigs.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                Signature sig = var4[var6];
                Set methods = (Set)signatureMap.computeIfAbsent(sig.type(), (k) -> {
                    return new HashSet();
                });

                try {
                    Method method = sig.type().getMethod(sig.method(), sig.args());
                    methods.add(method);
                } catch (NoSuchMethodException var10) {
                    throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + var10, var10);
                }
            }

            return signatureMap;
        }
    }
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

获取所有接口： 遍历多层 检查是否是要拦截的

private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
        HashSet interfaces;
        for(interfaces = new HashSet(); type != null; type = type.getSuperclass()) {
            Class[] var3 = type.getInterfaces();
            int var4 = var3.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                Class<?> c = var3[var5];
		//检查是否是要拦截的
                if (signatureMap.containsKey(c)) {
                    interfaces.add(c);
                }
            }
        }

        return (Class[])interfaces.toArray(new Class[interfaces.size()]);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Java注解的相关知识

Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。

注解可以分为三类：

1、java自带的标准注解，如@Override

2、元注解：用来定义注解的注解，定义注解的一些基本属性，如是否可继承、是否在文档中出现等。

3、自定义注解

注解的定义

注解通过**@interface** 对注解进行定义

注解是接口类，都继承自Annotation接口类

通俗的说

注解就是给一个东西记了一个标记，也许是为了让人便于理解，也许是有些地方要标注出来划重点

至此，要实现我们通过注解对敏感字段加密的功能所需要的知识就说完了。

具体操作

现在就相当于做菜，已经把材料都准备好了，动手就完事了。下面罗列一下目的、准备、实际操作。

要达到的目的：通过注解对敏感字段加密

已经做了的准备：一些可能用上的知识储备

❗对整理出来的知识再进行一个筛选：

• 使用注解可以用来划重点，这样可以知道哪些是敏感字段。 通俗的说
• mybatis 拦截器我要拦截它的ParamterHandler 和 ResultSetHandler 对 参数设置 和 返回结果涉及的敏感字段进行相应的加密解密操作 拦截器拦截的对象

代码

配置方面

要在mybatis-config.xml 中配置上两个插件，即两个拦截器，一个用来拦截组装参数、一个用来拦截返回结果处理;

    <plugins>
        <plugin interceptor="com.doordiey.interceptor.EncryptInterceptor"/>
        <plugin interceptor="com.doordiey.interceptor.DecryptInterceptor"/>
    </plugins>
1
2
3
4

拦截器- 拦截参数设置 —加密入库

@Component
@Slf4j
@Intercepts({ @Signature(method = "setParameters", type = ParameterHandler.class, args = PreparedStatement.class) })
public class EncryptInterceptor implements Interceptor
{
	@Override
	public Object intercept(Invocation invocation) throws Throwable
	{
		//确认是我要拦截的多做以下处理
		if (invocation.getTarget() instanceof ParameterHandler)
		{
			//获取拦截对象
			ParameterHandler parameterHandler = (ParameterHandler) invocation.getTarget();
			// 反射获取 参数对像
			Field parameterField = parameterHandler.getClass().getDeclaredField("parameterObject");
			parameterField.setAccessible(true);
			Object parameterObject = parameterField.get(parameterHandler);
			if (Objects.nonNull(parameterObject) && parameterObject instanceof BaseEntity)
			{
				encryptField((BaseEntity) parameterObject);
			}
		}
		//执行
		return invocation.proceed();
	}

	//遍历参数，有带有@Sensitive 的对象就进行加密
	private void encryptField(BaseEntity object) throws IllegalAccessException
	{
		Class<?> clazz = object.getClass();
		Field[] fields = clazz.getDeclaredFields();
		for (Field field : fields)
		{
			field.setAccessible(true);
			Sensitive encrypt = field.getAnnotation(Sensitive.class);
			if (encrypt != null)
			{
				Object toEncryptObj = field.get(object);
				if (null != toEncryptObj)
				{
					log.debug("加密敏感字段 {}", field.getName());
				}
			}
		}
	}

	@Override
	public Object plugin(Object target)
	{
		return Plugin.wrap(target, this);
	}

	@Override
	public void setProperties(Properties properties)
	{

	}
}
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