Mybaits插件使用示例及原理

一、mybatis插件

MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

• Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
• ParameterHandler (getParameterObject, setParameters)
• ResultSetHandler (handleResultSets, handleOutputParameters)
• StatementHandler (prepare, parameterize, batch, update, query)

即我们可以为上面的四大对象的进行插件的拦截开发

二、使用mybatis进行入库前加密

1、定义加密注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Encryption {
    
    /**
     * 使用的加密算法名称
     * @return
     */
    String value() default "";
}

2、插件代码如下

@Intercepts({@Signature(type = ParameterHandler.class, method = "setParameters", args = {PreparedStatement.class})})
public class ExampleParameterPlugin2 implements Interceptor {
    private final Map<Class<?>, Collection<Field>> filedCache = new ConcurrentHashMap<>();

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        ParameterHandler parameterHandler = (ParameterHandler) invocation.getTarget();

        Object object = parameterHandler.getParameterObject();
        if (object instanceof Map) {
            Map<String, Object> objectMap = (Map<String, Object>) object;
            Set<Object> fieldset = new HashSet<>(objectMap.values());
            fieldset.forEach(this::encryptionParam);
        }
        // implement pre processing if need
        Object returnObject = invocation.proceed();
        // implement post processing if need
        return returnObject;
    }

    private void encryptionParam(Object obj) {
        if (obj == null) {
            return;
        }

        Class<?> clazz = obj.getClass();
        Collection<Field> fieldCollection = filedCache.computeIfAbsent(clazz, cl -> {
            Collection<Field> fields = getAllField(cl);
            Collection<Field> encryptionField = new ArrayList<>();
            fields.forEach(field -> {
                Encryption annotation = field.getAnnotation(Encryption.class);
                if (annotation != null && field.getType() == String.class) {
                    encryptionField.add(field);
                }
            });
            return encryptionField;
        });
        fieldCollection.forEach((field -> {
            field.setAccessible(true);
            try {
                String fieldValue = (String) field.get(obj);
                if (fieldValue == null || "".equals(fieldValue)) {
                    return;
                }
                fieldValue += "加密";
                field.set(obj, fieldValue);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }));

    }

    private Collection<Field> getAllField(Class<?> clazz) {
        Set<Field> filedSet = new HashSet<>();
        while (clazz != null) {
            Field[] declaredFields = clazz.getDeclaredFields();
            filedSet.addAll(Arrays.asList(declaredFields));
            clazz = clazz.getSuperclass();
        }
        return filedSet;
    }

    public static void main(String[] args) {
        Field[] fields = User.class.getDeclaredFields();
        Encryption annotation = fields[0].getAnnotation(Encryption.class);
        Encryption annotation2 = fields[1].getAnnotation(Encryption.class);
        System.out.println(annotation2 + ":" + annotation);
    }

}

 3、在mybatis-config.xml配置该plug

<plugins>
    <plugin interceptor="org.hdsw.ibatis.ExampleParameterPlugin2"></plugin>
</plugins>

User.java 

@Alias("User")
public class User {
    
    private String id;
    
    @Encryption
    private String name;
    
    public String getId() {
        return id;
    }
    
    public void setId(String id) {
        this.id = id;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "User{" + "id='" + id + '\'' + ", name='" + name + '\'' + '}';
    }
}

 userMapper.java

public interface UserMapper {
    
    User selectById(@Param("id") String id);
    
    int insertOne(@Param("user") User user);

}

 userMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.hdsw.ibatis.mapper.UserMapper">
    <select id="selectById" resultType="org.hdsw.ibatis.User">
        select * from t_user where id = #{id}
    </select>
    
    <insert id="insertOne" parameterType="org.hdsw.ibatis.User">
        insert into t_user (id,name) value (#{user.id},#{user.name})
    </insert>
</mapper>

4、测试插件生效 

@Test
public void testUserMapper() throws IOException {
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User selectById = userMapper.selectById("cfd14d1c96694235a4dee855ca55d813");
    System.out.println("查询后得到的数据: " + selectById);
}

三、Mybatis插件运行的原理 

1、插件是在什么时候解析到配置对象的？

我们在解析mybatis-config.xml配置文件中plugs属性，由org.apache.ibatis.builder.xml.XMLConfigBuilder#pluginElement方法解析，解析到plug对象存储在Configuration对象中的interceptorChain里，具体代码如下

private void pluginElement(XNode parent) throws Exception {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      String interceptor = child.getStringAttribute("interceptor");
      Properties properties = child.getChildrenAsProperties();
      Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor()
          .newInstance();
      interceptorInstance.setProperties(properties);
      configuration.addInterceptor(interceptorInstance);
    }
  }
}

2、 四大对象是什么时候生成代理对象的？

在configuration中通过newExecutor、newParameterHandler、newResultSetHandler、newStatementHandler方法时候会调用,使用interceptorChain.pluginAll(Object)

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,
    Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject,
      rowBounds, resultHandler, boundSql);
  return (StatementHandler) interceptorChain.pluginAll(statementHandler);
}

 遍历所有的interceptors的，然后执行plugin方法

public Object pluginAll(Object target) {
  for (Interceptor interceptor : interceptors) {
    target = interceptor.plugin(target);
  }
  return target;
}

default Object plugin(Object target) {
  return Plugin.wrap(target, this);
}

public static Object wrap(Object target, Interceptor interceptor) {
  Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
  Class<?> type = target.getClass();
  Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
  if (interfaces.length > 0) {
    return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));
  }
  return target;
}

可以看到会一个个调用每一个插件interceptor.plugin(target)方法。默认执行的Plugin.wrap()方法。这里的主要逻辑是：

1、解析出来ExampleParameterPlugin2类上的@Intercepts注解，生成一个map对象，key是拦截对象的class类型（ParameterHandler.class），value:需要增强的方法集合

2、获取到目标对象的所有接口，如果第一步中map中的key含有该对象，那么就添加到要增强的接口

3、如果返回的需要增强的接口大于0，说明当前对象需要增强

4、该插件只拦截ParameterHandler类，对其他的类不生效，也就是说只有在新建ParameterHandler才会创建代理对象，否则不进行创建

3、代理对象如何来确定只对某些方法进行增强？

经过上面的分析，我们知道插件生成的代理对象使用的是JDK动态代理。其动态代理类为Plugin,具体invoke方法如下：

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    Set<Method> methods = signatureMap.get(method.getDeclaringClass());
    if (methods != null && methods.contains(method)) {
      return interceptor.intercept(new Invocation(target, method, args));
    }
    return method.invoke(target, args);
  } catch (Exception e) {
    throw ExceptionUtil.unwrapThrowable(e);
  }
}

可以看出来先获取到当前目标的对象中所需要增强的方法类，如果此次执行的方法的在需要增强的方法中，那么就调用 interceptor.intercept方法，否则不需要进行调用。