Mybatis插件的原理

2022-12-24 本文已影响0人刘大平

一、MyBatis插件

自定义插件
插件是一种常见的扩展方式，大多数开源框架也都支持用户通过添加自定义插件的方式来扩展或者
改变原有的功能，MyBatis中也提供的有插件，虽然叫插件，但是实际上是通过拦截器(Interceptor)实现
的，在MyBatis的插件模块中涉及到责任链模式和JDK动态代理，这两种设计模式的技术知识也是大家要
提前掌握的。
首先我们来看下一个自定义的插件我们要如何来实现。
1.1 创建Interceptor实现类
我们创建的拦截器必须要实现Interceptor接口，Interceptor接口的定义为

public interface Interceptor { 
 // 执行拦截逻辑的方法
 Object intercept(Invocation invocation) throws Throwable; 
 // 决定是否触发    intercept()方法
 default Object plugin(Object target) { 
   return Plugin.wrap(target, this);
}
 // 根据配置    初始化    Intercept 对象
 default void setProperties(Properties properties) { 
   // NOP
} 
}

在MyBatis中Interceptor允许拦截的内容是
Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)

ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)

我们创建一个拦截Executor中的query和close的方法

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import java.util.Properties;
/**
* 自定义的拦截器
* @Signature 注解就可以表示一个方法签名，    唯一确定一个方法 
*/
@Intercepts({
       @Signature(
               type = Executor.class // 需要拦截的类型 
              ,method = "query"     // 需要拦截的方法 
               // args 中指定 被拦截方法的 参数列表
               ,args={MappedStatement.class,Object.class, RowBounds.class, 
ResultHandler.class}
       ),
       @Signature(
               type = Executor.class 
               ,method = "close"
               ,args = {boolean.class} 
     )
})
public class FirstInterceptor implements Interceptor {
   private int testProp;
   /**
    * 执行拦截逻辑的方法
    * @param invocation
    * @return
    * @throws Throwable
    */
public Object intercept(Invocation invocation) throws Throwable {
       System.out.println("FirtInterceptor  拦截之前    ....");
       Object obj = invocation.proceed();
       System.out.println("FirtInterceptor  拦截之后    ....");
       return obj;
 }
   /**
    * 决定是否触发    intercept方法
    * @param target
    * @return
    */
   @Override
   public Object plugin(Object target) { 
       return Plugin.wrap(target,this); 
 }
   @Override
   public void setProperties(Properties properties) {
}
 }
   public int getTestProp() { 
       return testProp;
 }
   public void setTestProp(int testProp) { 
       this.testProp = testProp;
 }

1.2 配置拦截器
创建好自定义的拦截器后，我们需要在全局配置文件中添加自定义插件的注册

<plugins>
      <plugin interceptor="com.gupaoedu.interceptor.FirstInterceptor"> 
          <property name="testProp" value="1000"/>
      </plugin> 
   </plugins>

1.3 运行程序
然后我们执行对应的查询操作。

@Test
   public void test1() throws  Exception{
       // 1.获取配置文件
       InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
       // 2.加载解析配置文件并获取SqlSessionFactory对象
       SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
       // 3.根据SqlSessionFactory对象获取SqlSession对象
       SqlSession sqlSession = factory.openSession();
       // 4.通过SqlSession中提供的    API方法来操作数据库
       List<User> list =
sqlSession.selectList("com.gupaoedu.mapper.UserMapper.selectUserList"); 
       for (User user : list) {
           System.out.println(user); 
     }
       // 5.关闭会话
       sqlSession.close(); 
 }

插件实现原理
自定义插件的步骤还是比较简单的，接下来我们分析下插件的实现原理是怎么回事。
2.1 初始化操作
首先我们来看下在全局配置文件加载解析的时候做了什么操作

private void pluginElement(XNode parent) throws Exception {
   if (parent != null) {
     for (XNode child : parent.getChildren()) {
       // 获取<plugin> 节点的    interceptor 属性的值
       String interceptor = child.getStringAttribute("interceptor");
       // 获取<plugin> 下的所有的properties子节点
       Properties properties = child.getChildrenAsProperties();
       // 获取    Interceptor 对象
       Interceptor interceptorInstance = (Interceptor) 
resolveClass(interceptor).getDeclaredConstructor().newInstance(); 
       // 设置    interceptor的    属性
       interceptorInstance.setProperties(properties); 
       // Configuration中记录    Interceptor
       configuration.addInterceptor(interceptorInstance); 
    }
 } 
}

该方法用来解析全局配置文件中的plugins标签，然后对应的创建Interceptor对象，并且封装对应的
属性信息。最后调用了Configuration对象中的方法。
configuration.addInterceptor(interceptorInstance)

public void addInterceptor(Interceptor interceptor) { 
   interceptorChain.addInterceptor(interceptor);
}

通过这个代码我们发现我们自定义的拦截器最终是保存在了InterceptorChain这个对象中。而
InterceptorChain的定义为

public class InterceptorChain {
 // 保存所有的    Interceptor  也就我所有的插件是保存在    Interceptors 这个List集合中的
 private final List<Interceptor> interceptors = new ArrayList<>();
 //
 public Object pluginAll(Object target) {
   for (Interceptor interceptor : interceptors) { // 获取拦截器链中的所有拦截器
     target = interceptor.plugin(target); // 创建对应的拦截器的代理对象
 }
   return target; 
}
 public void addInterceptor(Interceptor interceptor) { 
   interceptors.add(interceptor);
}
 public List<Interceptor> getInterceptors() {
   return Collections.unmodifiableList(interceptors); 
}
}

如何创建代理对象
在解析的时候创建了对应的Interceptor对象，并保存在了InterceptorChain中，那么这个拦截器是如
何和对应的目标对象进行关联的呢？首先拦截器可以拦截的对象是
Executor,ParameterHandler,ResultSetHandler,StatementHandler.那么我们来看下这四个对象在创建
的时候又什么要注意的

/**
  * 创建目标对象的代理对象
  *   目标对象 Executor ParameterHandler ResultSetHandler StatementHandler
  * @param target 目标对象
  * @param interceptor 拦截器
  * @return
  */
 public static Object wrap(Object target, Interceptor interceptor) {
   // 获取用户自定义    Interceptor中@Signature注解的信息
   // getSignatureMap 负责处理@Signature 注解
   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;
}

Plugin中的各个方法的作用

public class Plugin implements InvocationHandler { 
 private final Object target; // 目标对象
 private final Interceptor interceptor; // 拦截器
 private final Map<Class<?>, Set<Method>> signatureMap; // 记录    @Signature 注解的 
信息
 private Plugin(Object target, Interceptor interceptor, Map<Class<?>, 
Set<Method>> signatureMap) {
   this.target = target;
   this.interceptor = interceptor; 
   this.signatureMap = signatureMap;
}
 /**
  * 创建目标对象的代理对象
  *    目标对象    Executor  ParameterHandler  ResultSetHandler StatementHandler
  * @param target 目标对象
  * @param interceptor 拦截器
  * @return
  */
 public static Object wrap(Object target, Interceptor interceptor) {
   // 获取用户自定义    Interceptor中@Signature注解的信息
   // getSignatureMap 负责处理@Signature 注解
   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; 
}
  /**
  * 代理对象方法被调用时执行的代码
  * @param proxy
  * @param method
  * @param args
  * @return
  * @throws Throwable
  */
  
  @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws 
Throwable {
   try {
     // 获取当前方法所在类或接口中，可被当前Interceptor拦截的方法
     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);
 } 
}
 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<>(); 
   for (Signature sig : sigs) {
     Set<Method> methods = signatureMap.computeIfAbsent(sig.type(), k -> new 
HashSet<>());
     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; 
}

                                 
private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, 
Set<Method>> signatureMap) {
   Set<Class<?>> interfaces = new HashSet<>();
   while (type != null) {
     for (Class<?> c : type.getInterfaces()) {
       if (signatureMap.containsKey(c)) {
         interfaces.add(c);
     }
    }
     type = type.getSuperclass();
 }
   return interfaces.toArray(new Class<?>[interfaces.size()]); 
}
}

在创建Executor 其实得到的就是Plugin的代理对象, 在执行sql语句的时候, 就会走到Plugin代理对象里面的invoke方法, 在经过走到自己写的插件方法, 完成插件逻辑执行

Mybatis插件的原理

猜你喜欢

热点阅读