mybatis拦截器 + 注解对敏感字段进行加密解密

2年前 (2022) 程序员胖胖胖虎阿

443 0 0

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

🌏应用场景

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

🤸解决方案

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

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

目前该方案的优缺点：

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

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

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

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

mybatis的工作原理及核心流程

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

JDBC	MyBatis
DriverManager：注册连接	Executor：根据SqlSession动态生成需要执行的SQL
Connection：数据库连接对象	SqlSession：包含所有执行SQL的方法，类似Connection
Statement/PrepareStatement：操作数据库SQL语句的对象	MappedStatement：映射SQL的封装，存储SQL的id、参数信息
ResultSe：结果集	ResultHandler：对返回结果进行处理

整个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>

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

    <plugins>
        <plugin interceptor="com.doordiey.test.interceptor.EncryptInterceptor"/>
        <plugin interceptor="com.doordiey.test.interceptor.DecryptInterceptor"/>
    </plugins>

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

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

获取拦截器对象的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;
        }
    }

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

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()]);
    }

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>

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

@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)
	{

	}
}