• mybatis拦截器实现数据脱敏&拦截器使用

    目录

    1.主要代码如下：

    1.注解

    2.定义枚举脱敏规则

    3.增加mybatis拦截器

    4.Javabean中增加注解，如果是查询返回的map，会根据desensitionMap的规则进行脱敏

    2.原理简单介绍

    3.拦截器实现数据库查询完加密，编辑关联查询解密

    今天遇到个需求需要对现有的数据进行脱敏处理。于是简单研究了下。

    　　其实拦截器对脱敏处理主要处理两种数据，一种是bean类型，一种是map类型。

    　　普通的javabean利用注解+反射来处理，map的数据自己维护需要脱敏的key以及规则。bean类型是用mybatis以及mybatis-plus自动生成的SQL映射的；map类型是手写的返回map类型的SQL和mybatis-plus的返回map类型的数据。

    1.主要代码如下：

    1.注解

    1. package cn.xm.exam.mybatis;
    2.  
    3. import java.lang.annotation.ElementType;
    4. import java.lang.annotation.Retention;
    5. import java.lang.annotation.RetentionPolicy;
    6. import java.lang.annotation.Target;
    7.  
    8. @Target(ElementType.FIELD)
    9. @Retention(RetentionPolicy.RUNTIME)
    10. public @interface Desensitization {
    11.     
    12.     DesensitionType type();
    13.  
    14.     String[] attach() default "";
    15. }

    2.定义枚举脱敏规则

    1. package cn.xm.exam.mybatis;
    2.  
    3. public enum DesensitionType {
    4.     PHONE("phone", "11位手机号", "^(\\d{3})\\d{4}(\\d{4})$", "$1****$2"),
    5.   
    6.     ID_CARD("idCard", "16或者18身份证号", "^(\\d{4})\\d{11,13}(\\w{1})$", "$1****$2"), BANK_CARD("bankCardNo", "银行卡号",
    7.             "^(\\d{4})\\d*(\\d{4})$", "$1****$2"), ADDRESS("addrss", "地址", "(?<=.{3}).*(?=.{3})", "*"), REAL_NAME(
    8.                     "realName", "真实姓名", "(?<=.{1}).*(?=.{1})", "*"), EMAIL("email", "电子邮箱", "(\\w+)\\w{5}@(\\w+)",
    9.                             "$1***@$2"), CUSTOM("custom", "自定义正则处理", ""), TRUNCATE("truncate", "字符串截取处理", "");
    10.  
    11.     private String type;
    12.  
    13.     private String describe;
    14.  
    15.     private String[] regular;
    16.  
    17.     DesensitionType(String type, String describe, String... regular) {
    18.         this.type = type;
    19.         this.describe = describe;
    20.         this.regular = regular;
    21.     }
    22.  
    23.     public String getType() {
    24.         return type;
    25.     }
    26.  
    27.     public void setType(String type) {
    28.         this.type = type;
    29.     }
    30.  
    31.     public String getDescribe() {
    32.         return describe;
    33.     }
    34.  
    35.     public void setDescribe(String describe) {
    36.         this.describe = describe;
    37.     }
    38.  
    39.     public String[] getRegular() {
    40.         return regular;
    41.     }
    42.  
    43.     public void setRegular(String[] regular) {
    44.         this.regular = regular;
    45.     }
    46.  
    47. }

    3.增加mybatis拦截器

    1. package cn.xm.exam.mybatis;
    2.  
    3. import java.lang.reflect.Field;
    4. import java.util.ArrayList;
    5. import java.util.Arrays;
    6. import java.util.Collections;
    7. import java.util.LinkedHashMap;
    8. import java.util.List;
    9. import java.util.Map;
    10. import java.util.Properties;
    11. import java.util.Set;
    12.  
    13. import org.apache.commons.collections.CollectionUtils;
    14. import org.apache.commons.collections.MapUtils;
    15. import org.apache.commons.lang3.ArrayUtils;
    16. import org.apache.commons.lang3.StringUtils;
    17. import org.apache.ibatis.cache.CacheKey;
    18. import org.apache.ibatis.executor.Executor;
    19. import org.apache.ibatis.mapping.BoundSql;
    20. import org.apache.ibatis.mapping.MappedStatement;
    21. import org.apache.ibatis.plugin.Interceptor;
    22. import org.apache.ibatis.plugin.Intercepts;
    23. import org.apache.ibatis.plugin.Invocation;
    24. import org.apache.ibatis.plugin.Plugin;
    25. import org.apache.ibatis.plugin.Signature;
    26. import org.apache.ibatis.session.ResultHandler;
    27. import org.apache.ibatis.session.RowBounds;
    28. import org.slf4j.Logger;
    29. import org.slf4j.LoggerFactory;
    30. @Component
    31. @Intercepts({
    32.         @Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class,
    33.                 RowBounds.class, ResultHandler.class }),
    34.          })
    35. public class DesensitizationInterceptor implements Interceptor {
    36.  
    37.     private static final Logger logger = LoggerFactory.getLogger(DesensitizationInterceptor.class);
    38.     @Value("${desensitization}")
    39.     private boolean desensitization = false;// 脱敏
    40.  
    41.     private static final Map desensitionMap = new LinkedHashMap<>();
    42.     static {
    43.         initDensensitionMap();
    44.     }
    45.  
    46.     @Override
    47.     public Object intercept(Invocation invocation) throws Throwable {
    48.         Object result = invocation.proceed();
    49.  
    50.         // 如果需要对结果脱敏，则执行
    51.         if (desensitization) {
    52.             // 先对Map进行处理
    53.             if (result != null && result instanceof Map) {
    54.                 return this.desensitizationMap(result);
    55.             }
    56.  
    57.             // 处理集合
    58.             if (result instanceof ArrayList) {
    59.                 List list = (ArrayList) result;
    60.                 return this.desensitization(list);
    61.             }
    62.  
    63.             // 处理单个bean
    64.             return this.desensitization(result);
    65.         }
    66.  
    67.         return result;
    68.     }
    69.  
    70.     private static void initDensensitionMap() {
    71.         desensitionMap.put("idCode", DesensitionType.ID_CARD);
    72.         desensitionMap.put("idCard", DesensitionType.ID_CARD);
    73.         desensitionMap.put("userIDCard", DesensitionType.ID_CARD);
    74.         desensitionMap.put("userIdCard", DesensitionType.ID_CARD);
    75.  
    76.         desensitionMap.put("username", DesensitionType.REAL_NAME);
    77.         desensitionMap.put("address", DesensitionType.ADDRESS);
    78.     }
    79.  
    80.     /*
    81.      * 对map脱敏
    82.      */
    83.     private Object desensitizationMap(Object result) {
    84.         Map mapResult = (Map) result;
    85.         if (MapUtils.isEmpty(mapResult)) {
    86.             return mapResult;
    87.         }
    88.  
    89.         Set keySet = mapResult.keySet();
    90.         for (String key : keySet) {
    91.             if (desensitionMap.containsKey(key)) {
    92.                 DesensitionType desensitionType = desensitionMap.get(key);
    93.                 String replacedVal = getReplacedVal(desensitionType, MapUtils.getString(mapResult, key), null);
    94.                 mapResult.put(key, replacedVal);
    95.             }
    96.         }
    97.         return result;
    98.     }
    99.  
    100.     private List desensitization(List list) {
    101.         if (CollectionUtils.isEmpty(list)) {
    102.             return Collections.emptyList();
    103.         }
    104.  
    105.         Class cls = null;
    106.         for (Object o : list) {
    107.             // 脱敏map，改变引用地址(根据静态配置脱敏)
    108.             if (o != null && o instanceof Map) {
    109.                 o = desensitizationMap(o);
    110.                 continue;
    111.             }
    112.  
    113.             // 脱敏bean(根据注解脱敏)
    114.             if (cls == null) {
    115.                 cls = o.getClass();
    116.             }
    117.             o = desensitization(o);
    118.         }
    119.         return list;
    120.     }
    121.  
    122.     @Override
    123.     public Object plugin(Object target) {
    124.      
    125.         return Plugin.wrap(target, this);
    126.     }
    127.  
    128.    
    129.     @Override
    130.     public void setProperties(Properties properties) {
    131.     }
    132.  
    133.     private Object desensitization(Object obj) {
    134.         if (obj == null) {
    135.             return obj;
    136.         }
    137.         Class cls = obj.getClass();
    138.         Field[] objFields = cls.getDeclaredFields();
    139.         if (ArrayUtils.isEmpty(objFields)) {
    140.             return obj;
    141.         }
    142.  
    143.         for (Field field : objFields) {
    144.             if ("serialVersionUID".equals(field.getName())) {
    145.                 continue;
    146.             }
    147.  
    148.             Desensitization desensitization = null;
    149.             if (String.class != field.getType()
    150.                     || (desensitization = field.getAnnotation(Desensitization.class)) == null) {
    151.                 continue;
    152.             }
    153.  
    154.             try {
    155.                 field.setAccessible(true);
    156.                 String value = field.get(obj) != null ? field.get(obj).toString() : null;
    157.                 if (StringUtils.isBlank(value)) {
    158.                     continue;
    159.                 }
    160.  
    161.                 value = getReplacedVal(desensitization.type(), value, desensitization.attach());
    162.                 field.set(obj, value);
    163.             } catch (Exception ignore) {
    164.                 ignore.printStackTrace();
    165.             }
    166.         }
    167.  
    168.         return obj;
    169.     }
    170.  
    171.     private String getReplacedVal(DesensitionType type, String value, String[] attachs) {
    172.         List regular = null;
    173.         switch (type) {
    174.         case CUSTOM:
    175.             regular = Arrays.asList(attachs);
    176.             break;
    177.         case TRUNCATE:
    178.             regular = truncateRender(attachs);
    179.             break;
    180.         default:
    181.             regular = Arrays.asList(type.getRegular());
    182.         }
    183.  
    184.         if (regular != null && regular.size() > 1) {
    185.             String match = regular.get(0);
    186.             String result = regular.get(1);
    187.             if (null != match && result != null && match.length() > 0) {
    188.                 value = ((String) value).replaceAll(match, result);
    189.                 return value;
    190.             }
    191.         }
    192.  
    193.         return "";
    194.     }
    195.  
    196.     private List truncateRender(String[] attachs) {
    197.         List regular = new ArrayList<>();
    198.         if (null != attachs && attachs.length > 1) {
    199.             String rule = attachs[0];
    200.             String size = attachs[1];
    201.             String template, result;
    202.             if ("0".equals(rule)) {
    203.                 template = "^(\\S{%s})(\\S+)$";
    204.                 result = "$1";
    205.             } else if ("1".equals(rule)) {
    206.                 template = "^(\\S+)(\\S{%s})$";
    207.                 result = "$2";
    208.             } else {
    209.                 return regular;
    210.             }
    211.             try {
    212.                 if (Integer.parseInt(size) > 0) {
    213.                     regular.add(0, String.format(template, size));
    214.                     regular.add(1, result);
    215.                 }
    216.             } catch (Exception e) {
    217.                 logger.warn("ValueDesensitizeFilter truncateRender size {} exception", size);
    218.             }
    219.         }
    220.         return regular;
    221.     }
    222.  
    223.     public boolean isDesensitization() {
    224.         return desensitization;
    225.     }
    226.  
    227.     public void setDesensitization(boolean desensitization) {
    228.         this.desensitization = desensitization;
    229.     }
    230.  
    231. }

    解释： 

    (1)Interceptor接口有三个方法，如下：

    1. package org.apache.ibatis.plugin;
    2. import java.util.Properties;
    3.  
    4. public interface Interceptor {
    5.  
    6.   Object intercept(Invocation invocation) throws Throwable;
    7.  
    8.   Object plugin(Object target);
    9.  
    10.   void setProperties(Properties properties);
    11.  
    12. }

    intercept方法中编写我们自己的处理逻辑。类似于AOP。

    (2)@Intercepts注解：

    1. package org.apache.ibatis.plugin;
    2. import java.lang.annotation.ElementType;
    3. import java.lang.annotation.Retention;
    4. import java.lang.annotation.RetentionPolicy;
    5. import java.lang.annotation.Target;
    6.  
    7. /**
    8.  * @author Clinton Begin
    9.  */
    10. @Retention(RetentionPolicy.RUNTIME)
    11. @Target(ElementType.TYPE)
    12. public @interface Intercepts {
    13.   Signature[] value();
    14. }

     Intercepts注解需要一个Signature(拦截点)参数数组。通过Signature来指定拦截哪个对象里面的哪个方法。

    (3)Signature注解指定需要拦截那个类对象的哪个方法

    1. package org.apache.ibatis.plugin;
    2. import java.lang.annotation.ElementType;
    3. import java.lang.annotation.Retention;
    4. import java.lang.annotation.RetentionPolicy;
    5. import java.lang.annotation.Target;
    6.  
    7. @Retention(RetentionPolicy.RUNTIME)
    8. @Target(ElementType.TYPE)
    9. public @interface Signature {
    10.   Class type();
    11.  
    12.   String method();
    13.  
    14.   Class[] args();
    15. }

    class：指定定义拦截的类 Executor、ParameterHandler、StatementHandler、ResultSetHandler当中的一个。

    method：指定拦截的方法，方法名字即可

    args：指定拦截的方法对应的参数，JAVA里面方法可能重载，不指定参数，不能确定调用那个方法。

    4.Javabean中增加注解，如果是查询返回的map，会根据desensitionMap的规则进行脱敏

    1. public class EmployeeIn {
    2.     private String employeeid;
    3.  
    4.     /**
    5.      * 员工编号
    6.      */
    7.     private String employeenumber;
    8.  
    9.     private String name;
    10.  
    11.     /**
    12.      * 身份证号
    13.      */
    14.     @Desensitization(type = DesensitionType.ID_CARD)
    15.     private String idcode;
    16.  
    17.     ...
    18. }

    至此就可以实现一些基本的数据脱敏，前台查看返回的信息如下：

     

     

    2.原理简单介绍

    　　Mybatis拦截器设计的初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。通过Mybatis拦截器我们可以拦截某些方法的调用，我们可以选择在这些被拦截的方法执行前后加上某些逻辑，也可以在执行这些被拦截的方法时执行自己的逻辑而不再执行被拦截的方法。

    　　Mybatis里面的核心对象还是比较多的，如下：

     　　Mybatis拦截器并不是每个对象里面的方法都可以被拦截的。Mybatis拦截器只能拦截Executor、ParameterHandler、StatementHandler、ResultSetHandler四个对象里面的方法。

    1.Executor接口如下：

    1. package org.apache.ibatis.executor;
    2. import java.sql.SQLException;
    3. import java.util.List;
    4.  
    5. import org.apache.ibatis.cache.CacheKey;
    6. import org.apache.ibatis.mapping.BoundSql;
    7. import org.apache.ibatis.mapping.MappedStatement;
    8. import org.apache.ibatis.reflection.MetaObject;
    9. import org.apache.ibatis.session.ResultHandler;
    10. import org.apache.ibatis.session.RowBounds;
    11. import org.apache.ibatis.transaction.Transaction;
    12.  
    13. /**
    14.  * @author Clinton Begin
    15.  */
    16. public interface Executor {
    17.  
    18.   ResultHandler NO_RESULT_HANDLER = null;
    19.  
    20.   int update(MappedStatement ms, Object parameter) throws SQLException;
    21.  
    22.    List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
    23.  
    24.    List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
    25.  
    26.   List flushStatements() throws SQLException;
    27.  
    28.   void commit(boolean required) throws SQLException;
    29.  
    30.   void rollback(boolean required) throws SQLException;
    31.  
    32.   CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
    33.  
    34.   boolean isCached(MappedStatement ms, CacheKey key);
    35.  
    36.   void clearLocalCache();
    37.  
    38.   void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class targetType);
    39.  
    40.   Transaction getTransaction();
    41.  
    42.   void close(boolean forceRollback);
    43.  
    44.   boolean isClosed();
    45.   
    46.   void setExecutorWrapper(Executor executor);
    47.  
    48. }

    　　 Mybatis中所有的Mapper语句的执行都是通过Executor进行的。Executor是Mybatis的核心接口。从其定义的接口方法我们可以看出，对应的增删改语句是通过Executor接口的update方法进行的，查询是通过query方法进行的。

    2.ParameterHandler

    1. /** Eclipse Class Decompiler plugin, Copyright (c) 2017 Chen Chao. */
    2. package org.apache.ibatis.executor.parameter;
    3. import java.sql.PreparedStatement;
    4. import java.sql.SQLException;
    5.  
    6. /**
    7.  * A parameter handler sets the parameters of the {@code PreparedStatement}
    8.  *
    9.  * @author Clinton Begin
    10.  */
    11. public interface ParameterHandler {
    12.  
    13.   Object getParameterObject();
    14.  
    15.   void setParameters(PreparedStatement ps)
    16.       throws SQLException;
    17.  
    18. }

    　　ParameterHandler用来设置参数规则，当StatementHandler使用prepare()方法后，接下来就是使用它来设置参数。所以如果有对参数做自定义逻辑处理的时候，可以通过拦截ParameterHandler来实现。

    3.StatementHandler

    1. /** Eclipse Class Decompiler plugin, Copyright (c) 2017 Chen Chao. */
    2. package org.apache.ibatis.executor.statement;
    3. import java.sql.Connection;
    4. import java.sql.SQLException;
    5. import java.sql.Statement;
    6. import java.util.List;
    7.  
    8. import org.apache.ibatis.cursor.Cursor;
    9. import org.apache.ibatis.executor.parameter.ParameterHandler;
    10. import org.apache.ibatis.mapping.BoundSql;
    11. import org.apache.ibatis.session.ResultHandler;
    12.  
    13. /**
    14.  * @author Clinton Begin
    15.  */
    16. public interface StatementHandler {
    17.  
    18.   Statement prepare(Connection connection, Integer transactionTimeout)
    19.       throws SQLException;
    20.  
    21.   void parameterize(Statement statement)
    22.       throws SQLException;
    23.  
    24.   void batch(Statement statement)
    25.       throws SQLException;
    26.  
    27.   int update(Statement statement)
    28.       throws SQLException;
    29.  
    30.    List query(Statement statement, ResultHandler resultHandler)
    31.       throws SQLException;
    32.  
    33.    Cursor queryCursor(Statement statement)
    34.       throws SQLException;
    35.  
    36.   BoundSql getBoundSql();
    37.  
    38.   ParameterHandler getParameterHandler();
    39.  
    40. }

    　　StatementHandler负责处理Mybatis与JDBC之间Statement的交互。

    4.ResultSetHandler

    1. /** Eclipse Class Decompiler plugin, Copyright (c) 2017 Chen Chao. */
    2. package org.apache.commons.dbutils;
    3. import java.sql.ResultSet;
    4. import java.sql.SQLException;
    5.  
    6. public interface ResultSetHandler {
    7.  
    8.     T handle(ResultSet rs) throws SQLException;
    9.  
    10. }

    　　ResultSetHandler用于对查询到的结果做处理。所以如果你有需求需要对返回结果做特殊处理的情况下可以去拦截ResultSetHandler的处理。

    3.拦截器实现数据库查询完加密，编辑关联查询解密

    　　今天遇到个需求是查询之后需要对身份证以及住址信息，并且在关联查询的时候需要使用原字符串，也就是需要解密。并且在编辑完保存的时候需要还原成原字符串。

    1. 自定义注解Crypt

    1. package cn.xm.exam.mybatis;
    2.  
    3. import java.lang.annotation.ElementType;
    4. import java.lang.annotation.Retention;
    5. import java.lang.annotation.RetentionPolicy;
    6. import java.lang.annotation.Target;
    7.  
    8. /**
    9.  * 加密解密注解
    10.  * 
    11.  * @author Administrator
    12.  *
    13.  */
    14. @Target(ElementType.FIELD)
    15. @Retention(RetentionPolicy.RUNTIME)
    16. public @interface Crypt {
    17.  
    18. }

    2. 加密工具类

    1. package cn.xm.exam.mybatis;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. import org.apache.commons.lang3.StringUtils;
    7.  
    8. import cn.xm.exam.utils.SHAUtils;
    9.  
    10. public class CryptUtils {
    11.  
    12.     /**
    13.      * 加密后字符串-原字符串
    14.      */
    15.     private static final Map cryptedValues = new HashMap<>();
    16.  
    17.     public static String crypt(String originValue) {
    18.         String encode = SHAUtils.sha1Hex(originValue + "mysalt");
    19.         if (!cryptedValues.containsKey(encode)) {
    20.             cryptedValues.put(encode, originValue);
    21.         }
    22.  
    23.         return encode;
    24.     }
    25.  
    26.     public static boolean hasCryptedVal(String value) {
    27.         return cryptedValues.containsKey(value);
    28.     }
    29.  
    30.     public static String decrypt(String value) {
    31.         if (StringUtils.isBlank(value) || !hasCryptedVal(value)) {
    32.             return value;
    33.         }
    34.  
    35.         String decodeVal = cryptedValues.get(value);
    36.         if (StringUtils.isBlank(decodeVal)) {
    37.             return decodeVal;
    38.         }
    39.  
    40.         return StringUtils.substringBeforeLast(decodeVal, "mysalt");
    41.     }
    42.  
    43. }

    SHA摘要算法如下：

    1. package cn.xm.exam.utils;
    2.  
    3.  
    4. import org.apache.commons.codec.digest.DigestUtils;
    5.  
    6. /**
    7.  * 摘要算法：SHA算法Secure Hash Algorithm（安全hash算法） 安全散列算法（hash函数 将原始信息压缩
    8.  * 返回散列值）可以是SHA-1，SHA1是目前最安全 的摘要算法 摘要的长度为 20字节
    9.  * 
    10.  * 其他的SHA 包括 SHA-256（32字节）
    11.  * 
    12.  * 20byte = 160 bit,换成16进制字符串就是40位字符串
    13.  * 
    14.  * @author Administrator
    15.  *
    16.  */
    17. public class SHAUtils {
    18.  
    19.     /**
    20.      * 
    21.      * @param sourceCode
    22.      * @return 40位的16进制字符串
    23.      */
    24.     public static String sha1Hex(String sourceCode) {
    25.         return DigestUtils.sha1Hex(sourceCode);
    26.     }
    27.  
    28.     /**
    29.      * 
    30.      * @param sourceCode
    31.      * @return length为20的字节数组，如果转为字符串需要new String(Hex.encodeHex(return))
    32.      */
    33.     public static byte[] sha1(String sourceCode) {
    34.         // length为20的字节数组
    35.         return DigestUtils.sha1(sourceCode);
    36.     }
    37.  
    38.     /**
    39.      * 
    40.      * @param sourceCode
    41.      * @return 40位的16进制字符串
    42.      */
    43.     public static String sha256Hex(String sourceCode) {
    44.         return DigestUtils.sha256Hex(sourceCode);
    45.     }
    46.  
    47.     /**
    48.      * 
    49.      * @param sourceCode
    50.      * @return length为20的字节数组，如果转为字符串需要new String(Hex.encodeHex(return))
    51.      */
    52.     public static byte[] sha256(String sourceCode) {
    53.         // length为20的字节数组
    54.         return DigestUtils.sha256(sourceCode);
    55.     }
    56.  
    57.     public static void main(String[] args) {
    58.         System.out.println(sha1Hex("qlq"));
    59.     }
    60.  
    61. }

    　　SHA应该是不可逆的，我是将加密后的字符串作为key、原字符串作为value存入了map中来实现可逆。

    3. 加密拦截器以及解密拦截器

    　　加密拦截器，拦截 ResultSetHandler 的Statement 方法，对查出的数据进行加密。

    1. package cn.xm.exam.mybatis;
    2.  
    3. import java.lang.reflect.Field;
    4. import java.sql.Statement;
    5. import java.util.ArrayList;
    6. import java.util.LinkedList;
    7. import java.util.List;
    8. import java.util.Map;
    9. import java.util.Properties;
    10. import java.util.Set;
    11.  
    12. import org.apache.commons.collections.CollectionUtils;
    13. import org.apache.commons.collections.MapUtils;
    14. import org.apache.commons.lang3.StringUtils;
    15. import org.apache.commons.lang3.reflect.FieldUtils;
    16. import org.apache.ibatis.executor.resultset.ResultSetHandler;
    17. import org.apache.ibatis.plugin.Interceptor;
    18. import org.apache.ibatis.plugin.Intercepts;
    19. import org.apache.ibatis.plugin.Invocation;
    20. import org.apache.ibatis.plugin.Plugin;
    21. import org.apache.ibatis.plugin.Signature;
    22. import org.slf4j.Logger;
    23. import org.slf4j.LoggerFactory;
    24.  
    25. /**
    26.  * 加密。出库后加密(加密后传到界面)
    27.  * 
    28.  * @author Administrator
    29.  *
    30.  */
    31. @Intercepts({ @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = { Statement.class }) })
    32. public class EncryptInterceptor implements Interceptor {
    33.  
    34.     private static final Logger log = LoggerFactory.getLogger(EncryptInterceptor.class);
    35.  
    36.     private static final List cryptedKeys = new LinkedList<>();
    37.     static {
    38.         cryptedKeys.add("fullname");
    39.         cryptedKeys.add("idCode");
    40.         cryptedKeys.add("idCard");
    41.         cryptedKeys.add("userIDCard");
    42.         cryptedKeys.add("userIdCard");
    43.         cryptedKeys.add("username");
    44.         cryptedKeys.add("address");
    45.     }
    46.  
    47.     @Override
    48.     public Object intercept(Invocation invocation) throws Throwable {
    49.         Object resultObject = invocation.proceed();
    50.         if (resultObject == null) {
    51.             return null;
    52.         }
    53.  
    54.         // 基于selectList
    55.         if (resultObject instanceof ArrayList) {
    56.             ArrayList resultList = (ArrayList) resultObject;
    57.             if (CollectionUtils.isNotEmpty(resultList)) {
    58.                 for (Object result : resultList) {
    59.                     doEncrypt(result);
    60.                 }
    61.             }
    62.         } else {
    63.             doEncrypt(resultObject);
    64.         }
    65.  
    66.         return resultObject;
    67.     }
    68.  
    69.     private void doEncrypt(Object result) {
    70.         if (result instanceof Map) {
    71.             Map resultMap = (Map) result;
    72.             doEncryptMap(resultMap);
    73.             return;
    74.         }
    75.  
    76.         doEncryptPlainBean(result);
    77.     }
    78.  
    79.     /**
    80.      * 加密普通bean，用反射获取字段进行加密
    81.      * 
    82.      * @param result
    83.      */
    84.     private void doEncryptPlainBean(Object result) {
    85.         List allFieldsList = FieldUtils.getFieldsListWithAnnotation(result.getClass(), Crypt.class);
    86.         for (Field field : allFieldsList) {
    87.             field.setAccessible(true);
    88.             try {
    89.                 Class type = field.getType();
    90.                 if (!type.equals(String.class)) {
    91.                     continue;
    92.                 }
    93.                 String value = (String) field.get(result);
    94.                 if (StringUtils.isBlank(value)) {
    95.                     continue;
    96.                 }
    97.  
    98.                 value = encrypt(value);
    99.                 field.set(result, value);
    100.             } catch (Exception e) {
    101.                 log.error("doEncryptPlainBean error", e);
    102.             }
    103.         }
    104.     }
    105.  
    106.     private String encrypt(String value) {
    107.         return CryptUtils.crypt(value);
    108.     }
    109.  
    110.     /**
    111.      * 加密map
    112.      * 
    113.      * @param resultMap
    114.      */
    115.     private void doEncryptMap(Map resultMap) {
    116.         if (MapUtils.isEmpty(resultMap)) {
    117.             return;
    118.         }
    119.  
    120.         Set keySet = resultMap.keySet();
    121.         for (Object key : keySet) {
    122.             String keyStr = (String) key;
    123.             if (cryptedKeys.contains(keyStr)) {
    124.                 resultMap.put(key, encrypt(String.valueOf(resultMap.get(key))));
    125.             }
    126.         }
    127.     }
    128.  
    129.     @Override
    130.     public Object plugin(Object target) {
    131.         return Plugin.wrap(target, this);
    132.     }
    133.  
    134.     @Override
    135.     public void setProperties(Properties properties) {
    136.  
    137.     }
    138.  
    139. }

    解密拦截器：对入参进行解密。先判断类型，只对string、list、map中的string、bean中的string属性进行解密

    1. package cn.xm.exam.mybatis;
    2.  
    3. import java.lang.reflect.Field;
    4. import java.sql.PreparedStatement;
    5. import java.util.ArrayList;
    6. import java.util.Iterator;
    7. import java.util.List;
    8. import java.util.Map;
    9. import java.util.Properties;
    10. import java.util.Set;
    11.  
    12. import org.apache.commons.collections.CollectionUtils;
    13. import org.apache.commons.collections.MapUtils;
    14. import org.apache.commons.lang3.reflect.FieldUtils;
    15. import org.apache.ibatis.executor.parameter.ParameterHandler;
    16. import org.apache.ibatis.plugin.Interceptor;
    17. import org.apache.ibatis.plugin.Intercepts;
    18. import org.apache.ibatis.plugin.Invocation;
    19. import org.apache.ibatis.plugin.Plugin;
    20. import org.apache.ibatis.plugin.Signature;
    21. import org.slf4j.Logger;
    22. import org.slf4j.LoggerFactory;
    23.  
    24. /**
    25.  * 解密拦截器。(查询或者进行修改等操作时对参数进行解密)
    26.  * 
    27.  * @author Administrator
    28.  *
    29.  */
    30. @Intercepts({ @Signature(type = ParameterHandler.class, method = "setParameters", args = PreparedStatement.class) })
    31. public class DecryptInterceptor implements Interceptor {
    32.  
    33.     private static final Logger log = LoggerFactory.getLogger(DecryptInterceptor.class);
    34.  
    35.     @Override
    36.     public Object intercept(Invocation invocation) throws Throwable {
    37.         // @Signature 指定了 type= parameterHandler 后，这里的 invocation.getTarget()
    38.         // 便是parameterHandler
    39.         // 若指定ResultSetHandler ，这里则能强转为ResultSetHandler
    40.         ParameterHandler parameterHandler = (ParameterHandler) invocation.getTarget();
    41.         // 获取参数对像，即 mapper 中 paramsType 的实例
    42.         Field parameterField = parameterHandler.getClass().getDeclaredField("parameterObject");
    43.         parameterField.setAccessible(true);
    44.         // 取出实例(参数实例)
    45.         Object parameterObject = parameterField.get(parameterHandler);
    46.         if (parameterObject != null) {
    47.             int count = 0;
    48.             Class parameterObjectClass = parameterObject.getClass();
    49.             // 集合
    50.             if (parameterObject instanceof List) {
    51.                 ArrayList resultList = (ArrayList) parameterObject;
    52.                 if (CollectionUtils.isNotEmpty(resultList)) {
    53.                     for (Object result : resultList) {
    54.                         result = doDecrypt(result);
    55.                     }
    56.                 }
    57.             }
    58.  
    59.             // 普通的bean
    60.             parameterObject = doDecrypt(parameterObject);
    61.         }
    62.         // 重新赋值引用
    63.         parameterField.set(parameterHandler, parameterObject);
    64.  
    65.         Object proceed = invocation.proceed();
    66.         return proceed;
    67.     }
    68.  
    69.     private Object doDecrypt(Object result) {
    70.         if (result == null) {
    71.             return result;
    72.         }
    73.  
    74.         Classextends Object> clazz = result.getClass();
    75.         // String 类型
    76.         if (clazz != null && clazz.equals(String.class)) {
    77.             return decryptStr(result.toString());
    78.         }
    79.  
    80.         if (result instanceof Map) {
    81.             return decryptMap((Map) result);
    82.         }
    83.  
    84.         // 普通bean
    85.         return decryptPlainBean(result);
    86.     }
    87.  
    88.     private Object decryptPlainBean(Object result) {
    89.         List allFieldsList = FieldUtils.getFieldsListWithAnnotation(result.getClass(), Crypt.class);
    90.         for (Field field : allFieldsList) {
    91.             field.setAccessible(true);
    92.             try {
    93.                 Class type = field.getType();
    94.                 if (!type.equals(String.class)) {
    95.                     continue;
    96.                 }
    97.  
    98.                 Object object = field.get(result);
    99.                 field.set(result, decryptStr((String) object));
    100.             } catch (Exception e) {
    101.                 log.error("doEncryptPlainBean error", e);
    102.             }
    103.         }
    104.  
    105.         return result;
    106.     }
    107.  
    108.     private Object decryptMap(Map result) {
    109.         if (result == null || MapUtils.isEmpty(result)) {
    110.             return result;
    111.         }
    112.  
    113.         Set keySet = result.keySet();
    114.         Iterator iterator = keySet.iterator();
    115.         while (iterator.hasNext()) {
    116.             Object key = iterator.next();
    117.             Object object = result.get(key);
    118.             if (object == null) {
    119.                 continue;
    120.             }
    121.  
    122.             if (object instanceof String) {
    123.                 result.put(key, decryptStr((String) object));
    124.             }
    125.         }
    126.  
    127.         return result;
    128.     }
    129.  
    130.     private Object decryptStr(String string) {
    131.         return CryptUtils.decrypt(string);
    132.     }
    133.  
    134.     @Override
    135.     public Object plugin(Object target) {
    136.         return Plugin.wrap(target, this);
    137.     }
    138.  
    139.     @Override
    140.     public void setProperties(Properties properties) {
    141.  
    142.     }
    143.  
    144. }

    5.自定义的注解加在bean对应的实体类上，会被上面拦截器反射的时候读取到了

    1.    @Crypt
    2.     private String useridcard;

  • 相关阅读:
    Linux编写脚本使用Docker部署项目
    Flutter 打包APK aab
    JasperReports做报表嵌套显示子报表显示不出来
    springboot基于Java Web的华家医疗器械商城设计与实现毕业设计源码261620
    虚拟机搭建负载均衡，mysql主从复制和读写分离（三、搭建负载均衡）
    Rust所有权及引用
    【计算机视觉 | 目标检测】arxiv 计算机视觉关于目标检测的学术速递（9 月 4 日论文合集）
    预制菜行业数据分析（京东数据挖掘）
    Java反射面试题及答案
    mininet 和 ryu 的安装
  • 原文地址：https://blog.csdn.net/weixin_58670730/article/details/126954268