Mybatis的plugins的入门helloworld介绍以及原理分析

短命女 2022-01-30 12:13 201阅读 0赞

### Mybatis的plugins ###

先看一下官方文档对mybatis的plugins的介绍：

> MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：  
> Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)  
> ParameterHandler (getParameterObject, setParameters)  
> ResultSetHandler (handleResultSets, handleOutputParameters)  
> StatementHandler (prepare, parameterize, batch, update, query)  
> 这些类中方法的细节可以通过查看每个方法的签名来发现，或者直接查看 MyBatis 发行包中的源代码。 如果你想做的不仅仅是监控方法的调用，那么你最好相当了解要重写的方法的行为。 因为如果在试图修改或重写已有方法的行为的时候，你很可能在破坏 MyBatis 的核心模块。 这些都是更低层的类和方法，所以使用插件的时候要特别当心。  
> **通过 MyBatis 提供的强大机制，使用插件是非常简单的，只需实现 Interceptor 接口，并指定想要拦截的方法签名即可。**

看完这段介绍，可以了解到，插件与**Executor** ，**ParameterHandler** ，**StatementHandler** ，**ResultSetHandler** ，这四大对象密切相关，并且是在执行过程中进行拦截。至于为什么是拦截，后面会进行说明。  
上面引用的最后一句话，让我们知道，插件的使用步骤。  
（1）实现Interceptor 接口  
（2）指定想要拦截的方法签名即可（官方文档使用个是@Intercepts注解）  
（3）其实还有第三步，就是把插接注册到`mybatis-config.xml`中，上面没有提及到。

**（1）实现Interceptor 接口**

@Intercepts(value={ 
        @Signature(type = ParameterHandler .class ,method = "setParameters" ,args = PreparedStatement.class)
    })
    public class MyPlugin implements Interceptor { 
        @Override
        public Object intercept(Invocation invocation) throws Throwable { 
            /** * 拦截目标方法的执行方法 * */
            //显示的执行目标方法
            Object proceed = invocation.proceed();
            System.out.println("MyPlugin.....intercept....拦截的目标方法执行");
    
            //输出一下目标方法的对象
            Object target = invocation.getTarget();
            //输出一下目标方法
            Method method = invocation.getMethod();
            //目标方法的参数
            Object[] args = invocation.getArgs();
            System.out.println("对象target======>"+target+"方法method=====>"+method.getName());
            for (Object arg : args) { 
                System.out.println("参数arg======>"+arg);
            }
            return proceed;
        }
    
        @Override
        public Object plugin(Object target) { 
            System.out.println("当前执行对象======>"+target.getClass().getSimpleName());
            System.out.println("执行wrap包装前方法......plugin=======>包装前的对象"+target);
            //包装目标方法 返回代理对象
            Object wrap = Plugin.wrap(target, this);
            System.out.println("执行wrap包装方法......plugin=======>包装后的对象"+target);
            return wrap;
        }
    
        @Override
        public void setProperties(Properties properties) { 
            //这个是我们在注册plugins时候设置的参数
        }
    }

**(2)指定想要拦截的方法签名即可（官方文档使用个是@Intercepts注解）**  
在`MyPlugin` 这个类上加上这段注解。设置需要拦截的方法签名：  
属性 `type`代表需要拦截方法所属的类  
属性 `method`需要拦截的方法的具体方法名  
属性`args`需要拦截方法的参数列表。（为了区别重载方法）

@Intercepts(value={ 
    	    @Signature(type = ParameterHandler .class ,method = "setParameters" ,args = PreparedStatement.class)
    	})

**（3）就是把插接注册到`mybatis-config.xml`中**

**最后开始测试输出日志：**

当前执行对象======>CachingExecutor
    执行wrap包装前方法......plugin=======>包装前的对象org.apache.ibatis.executor.CachingExecutor@4d50efb8
    执行wrap包装方法......plugin=======>包装后的对象org.apache.ibatis.executor.CachingExecutor@4d50efb8
    当前执行对象======>DefaultParameterHandler
    执行wrap包装前方法......plugin=======>包装前的对象org.apache.ibatis.scripting.defaults.DefaultParameterHandler@12f41634
    执行wrap包装方法......plugin=======>包装后的对象org.apache.ibatis.scripting.defaults.DefaultParameterHandler@904a546
    当前执行对象======>DefaultResultSetHandler
    执行wrap包装前方法......plugin=======>包装前的对象org.apache.ibatis.executor.resultset.DefaultResultSetHandler@7a3d45bd
    执行wrap包装方法......plugin=======>包装后的对象org.apache.ibatis.executor.resultset.DefaultResultSetHandler@7a3d45bd
    当前执行对象======>RoutingStatementHandler
    执行wrap包装前方法......plugin=======>包装前的对象org.apache.ibatis.executor.statement.RoutingStatementHandler@77ec78b9
    执行wrap包装方法......plugin=======>包装后的对象org.apache.ibatis.executor.statement.RoutingStatementHandler@77ec78b9
    DEBUG [main] - Opening JDBC Connection
    DEBUG [main] - Created connection 376416077.
    DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@166fa74d]
    DEBUG [main] - ==>  Preparing: SELECT * FROM department WHERE id = ? 
    MyPlugin.....intercept....拦截的目标方法执行
    对象target======>org.apache.ibatis.scripting.defaults.DefaultParameterHandler@12f41634方法method=====>setParameters
    参数arg======>org.apache.ibatis.logging.jdbc.PreparedStatementLogger@2bbaf4f0
    DEBUG [main] - ==> Parameters: 1(Integer)
    DEBUG [main] - <==      Total: 1
    Department{ id=1, depName='技术部门', description='对产品的技术支撑'}

**这个日志的输出结果比较有意思，要来探究一下。**  
(1)第一个疑问：可以看出Myplugin这个方法的plugin方法被执行了4次，并且当前的对象分别是**CachingExecutor**，**DefaultParameterHandler**，**DefaultResultSetHandler**，**RoutingStatementHandler**，原来是mybatis的四大对象，也符合了官方文档的介绍，至于是为什么，等一下介绍。

（2）第二个疑问：上面这个四大对象，每次都会被执行 `Plugin.wrap(target, this)`方法，都会返回一个被包装之后的`wrap`对象。然后发现`DefaultParameterHandler`包装之前跟包装之后的对象不一样，其他三个对象都没有变，与包装前相同。

为了解决疑问，开始了查阅源代码，找个了这个四大对象的创建过程（之前我的博客也有简单介绍mabatis的执行过程，有兴趣的可以去看看）  
**Executor的创建过程(代码如下)：**

public Executor newExecutor(Transaction transaction, ExecutorType executorType) { 
        executorType = executorType == null ? defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        Executor executor;
        if (ExecutorType.BATCH == executorType) { 
          executor = new BatchExecutor(this, transaction);
        } else if (ExecutorType.REUSE == executorType) { 
          executor = new ReuseExecutor(this, transaction);
        } else { 
          executor = new SimpleExecutor(this, transaction);
        }
        if (cacheEnabled) { //#7
          executor = new CachingExecutor(executor);
        }
        //重点
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }

**ParameterHandler的创建过程(代码如下)：**  
这个是在执行查询的时候，doQuery()方法中执行的

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { 
        Statement stmt = null;
        try { 
          Configuration configuration = ms.getConfiguration();
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          stmt = prepareStatement(handler, ms.getStatementLog());
          return handler.<E>query(stmt, resultHandler);
        } finally { 
          closeStatement(stmt);
        }
      }
    //newStatementHandler方法的内部
      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);
        //重点
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
        
        return statementHandler;
      }

**StatementHandler,与ResultSetHandler是在创建PreparedStatementHandler方法的时候同时在BaseStatementHandler这个类的构造器当中构造出来的**

protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { 
        this.configuration = mappedStatement.getConfiguration();
        this.executor = executor;
        this.mappedStatement = mappedStatement;
        this.rowBounds = rowBounds;
    
        this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        this.objectFactory = configuration.getObjectFactory();
    
        if (boundSql == null) {  // issue #435, get the key before calculating the statement
          generateKeys(parameterObject);
          boundSql = mappedStatement.getBoundSql(parameterObject);
        }
    
        this.boundSql = boundSql;
        
    	//newnewParameterHandler()的内部 ===》 parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
        this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
     	//newResultSetHandler()的内部======》 resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
        this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
      }

如果看了上面四大对象的创建过程，不难发现他们有一个共有的特点都一段类似的代码：

*  `executor = (Executor) interceptorChain.pluginAll(executor);`
 *  `statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);`
 *  `parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);`
 *  `resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler)`

**下一步就看看pluginAll（）里面到底干了啥，进去瞧一瞧**

public class InterceptorChain { 
    
      private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
    
      public Object pluginAll(Object target) { 
        for (Interceptor interceptor : interceptors) { 
          target = interceptor.plugin(target);
        }
        return target;
      }

终于真相大白，可以看到这个方法是拿到所有的拦截器`interceptors`，接着遍历每一个拦截器，调用它们各自的`plugin()`方法，看到这，我们的第一疑问也算是有了答案。这也就是为什么我们自定义的`Myplugin`会在创建这4个对象的时候创建4遍。

接着要看看第二个疑问了，为什么就是**DefaultParameterHandler**这个对象被包装返回代理对象。好进入`Object wrap = Plugin.wrap(target, this);` 这段代码内部一探究竟。

public static Object wrap(Object target, Interceptor interceptor) { 
      //获得 @Signature注解信息的signatureMap 集合
        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;
      }

这就是为什么我们要在`Myplugin`设置拦截的方法签名，在案例中我们设置的是`@Intercepts(value={ @Signature(type = ParameterHandler .class ,method = "setParameters" ,args = PreparedStatement.class) })` 所以对应的就跟我们**ParameterHandler** 类型的创建代理对象，其余的就是返回其本身。

**说完了创建过程，接着看看方法的调用，ParameterHandler对象被包装成动态代理对象，当执行到setParameters看看会发生什么**  
执行`setParameters()`方法时，会进入动态代理的`incoke()`

@Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        try { 
        //@signatureb标注中的所有方法，
          Set<Method> methods = signatureMap.get(method.getDeclaringClass());
          //意思就是判断里面是否包含 我们所设置的 method="方法名" 该方法
          if (methods != null && methods.contains(method)) { 
          // 如果包含，调用interceptor的intercept方法
            return interceptor.intercept(new Invocation(target, method, args));
          }
          //没有就正常执行
          return method.invoke(target, args);
        } catch (Exception e) { 
          throw ExceptionUtil.unwrapThrowable(e);
        }
      }
    	
    	//构造SignatureMap的方法key=sig.type()，也就是我们@signatureb注解里面标注的属性，
    	// value=methods 是与该类相关的所有方法的set集合。
      private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) { 
        Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
        // issue #251
        if (interceptsAnnotation == null) { 
          throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());      
        }
        Signature[] sigs = interceptsAnnotation.value();
        Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
        for (Signature sig : sigs) { 
          Set<Method> methods = signatureMap.get(sig.type());
          if (methods == null) { 
            methods = new HashSet<Method>();
            signatureMap.put(sig.type(), methods);
          }
          try { 
            Method method = sig.type().getMethod(sig.method(), sig.args());
            methods.add(method);
          } catch (NoSuchMethodException e) { 
            throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
          }
        }
        return signatureMap;
      }

再次简单说一下上面的过程，当我们使用ParameterHandlerProxy对象执行方法时，如果是我们是在`@Signature`中method设置了的方法，那么就会执行`interceptor.intercept(new Invocation(target, method, args))`,否则正常执行原方法`return method.invoke(target, args);`  
在执行`intercept（）`方法时候，传入了一个`Invocation`对象，看看这个这个对象的内部。

public class Invocation { 
    
      private final Object target;
      private final Method method;
      private final Object[] args;
    
      public Invocation(Object target, Method method, Object[] args) { 
        this.target = target;
        this.method = method;
        this.args = args;
      }
    
      public Object getTarget() { 
        return target;
      }
    
      public Method getMethod() { 
        return method;
      }
    
      public Object[] getArgs() { 
        return args;
      }
    
      public Object proceed() throws InvocationTargetException, IllegalAccessException { 
        return method.invoke(target, args);
      }
    
    }

这个对象有一个`proceed()`方法，他的返回值居然也是`method.invoke(target, args)`,上面我们在`Myplugin`中的intercept（Invocation invocation）执行的`invocation.proceed()`方法其实就是对源方法进行推进。那这样做的目的是为什么呢？现在就可以解释插件的作用了--------- **拦截调用**。

有了这种机制，我们拦截到目标方法，在目标方法前 后，做一些处理了。

@Override
        public Object intercept(Invocation invocation) throws Throwable { 
            /** * 拦截目标方法的执行方法 * */
              System.out.println("==========前操作==============");
            //显示的执行目标方法
            Object proceed = invocation.proceed();
       		
       		 System.out.println("==========后操作==============");
            return proceed;
        }

如我们拦截到了`setParameters()`方法，我们可以偷梁换柱，在参数预编译设置的时候，换成我门所需要的，像分页插件pageHelper，就是这种机制。

##### 总结一下： #####

*  plugin插件与mybatis的四大对象\`\` **Executor** ，**ParameterHandler** ，**StatementHandler** ，**ResultSetHandler**连接紧密。
 *  四大对象创建过程都会执行`pluginAll(resultSetHandler)`，调用拦截器的plugin()方法，对`@Signature`里设置的type类进行包装成代理对象，否则原对象。
 *  代理对象执行方法的时候：  
    \- 如果是@Signature注解里面标注的method方法，那么调用拦截器的`intercept(Invocation invocation)`方法，可以在放行目标方法前后进行加工  
    \- 否则`method.invoke(target, args);`正常执行。

**后记: 希望通过写博客的方式能让自己对知识更加理解，记录自己学习的点滴。同样也希望自己能在学习的道路上踏出属于自己的一条小路…**