mybatis实现自定义插件

浅浅的花香味﹌ 2022-10-07 14:57 168阅读 0赞

mybatis实现自定义插件

写本文的原因是在写制品库代码时遇到了下面了两个问题:

1.  Signature注解的各个属性的可选值
2.  为什么会@component和@bean注释的拦截器的不生效

遂阅读了mybatis部分源码，找出问题2症结所在

@Signature(
    			type = StatementHandler.class,
    			method = "prepare",
    			args = { Connection.class, Integer.class})

type:  
ParameterHanlder  
ResultSetHanler  
StatementHanlder  
Executor

method:  
四个被拦截接口的所有方法  
ParameterHanlder: getParameterObject, setParameters  
ResultSetHanler: handlerResultSets,handlerOutputParameters  
StatementHanlder: prepare,parameterize,batch,update,query  
Executor: update,query,flushStatements,commit,rollback,getTransaction,close,isClosed

args:  
被拦截方法参数的类

## 自定义插件 ##

@Intercepts(
            { @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class, Integer.class})}
    )
    //
    @Component
    public class SQLStatsInterceptor implements Interceptor { 
    
        private final Logger logger = LoggerFactory.getLogger(SQLStatsInterceptor.class);
    
        @Override
        public Object intercept(Invocation invocation) throws Throwable { 
            //自定义插件主要逻辑代码
    
            return invocation.proceed();
        }
    
        @Override
        public Object plugin(Object o) { 
            return Plugin.wrap(o, this);
        }
    
        @Override
        public void setProperties(Properties properties) { 
            logger.info(properties.toString());
        }
    }

## 加载自定义插件的三种方式 ##

### 1. 手动使用sqlSessionFactory加载插件 ###

public String myInterceptor(SqlSessionFactory sqlSessionFactory) { 
    
            sqlSessionFactory.getConfiguration().addInterceptor(new MyInterceptor());
            return "interceptor";
        }

### 2. 使用@bean的方式加载插件 ###

@Bean
        public MyInterceptor generalPlugin() { 
            return new MyInterceptor();
        }

### 3. @Component直接注解在自定义插件加载 ###

@Intercepts({ 
    	@Signature(
    			.................
    })
    @Component
    class  MyInterceptor{ 
    
    }
    
    
    上面2，3中方式会在MybatisAutoConfiguration的构造器中获取到自定义插件,当用户没有自己
    创建SqlSessionFactory时会执行sqlSessionFactory()方法，这个时候会加载自定义的插件。
    
    ```java
    //执行完上面的会进入： MybatisAutoConfiguration的构造器加载插件
      public MybatisAutoConfiguration() { 
           this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
       }
    
     @Bean
        @ConditionalOnMissingBean
        public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception { 
            if (!ObjectUtils.isEmpty(this.interceptors)) { 
                factory.setPlugins(this.interceptors);
            }
        }

**pageHelper**的自定配置是在MybatisAutoConfiguration之后的。

@AutoConfigureAfter({ DataSourceAutoConfiguration.class})
    public class MybatisAutoConfiguration { 
        public MybatisAutoConfiguration() { 
          this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
      }
    
    }
    
    @AutoConfigureAfter({ MybatisAutoConfiguration.class})
    public class PageHelperAutoConfiguration { 
    
    }

网上有文章说@Component和@Bean不生效的原因是pageHelper插件导致的。但是经过实测：发现是没有关系。

pageHelper的自定配置是在MybatisAutoConfiguration之后，我们打断点在MybatisAutoConfiguration，发现即使有  
pageHeper但是@Component和@Bean注解的bean是被MybatisAutoConfiguration存储在interceptors属性可，  
但是并没有被执行factory.setPlugins(this.interceptors);方法加载到sqlSessionFactory。因此不存在pageHelper影响了  
自定义插件的加载。

**当有开发者自己创建了sqlSessionFactory那么，自定义插件一定要通过上述方式1手动加载到sqlSessionFactory中.**

## 源码 ##

### 加载插件 ###

sqlSessionFactory.getConfiguration().addInterceptor(new YourInterceptor());
    
     public void addInterceptor(Interceptor interceptor) { 
       //添加插件到责任链中
        interceptorChain.addInterceptor(interceptor);
      }
    
    
    public class InterceptorChain { 
    
      private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
    
    // 四大金刚加入到插件通过责任链设计模式进行链式处理
    // parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    // resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
    // statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    // executor = (Executor) interceptorChain.pluginAll(executor);
      public Object pluginAll(Object target) { 
        // 责任链模式， 多个插件按照加入在list中的顺序进行处理
        for (Interceptor interceptor : interceptors) { 
          //注意这个target是每一上一步处理完返回的对象
          target = interceptor.plugin(target);
        }
        return target;
      }
    
      public void addInterceptor(Interceptor interceptor) { 
        interceptors.add(interceptor);
      }
      
      public List<Interceptor> getInterceptors() { 
        return Collections.unmodifiableList(interceptors);
      }
    
    }
    
    public class Configuration{ 
      public ParameterHandler newParameterHandler(){ 
         parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
      }
    
      public ResultSetHandler newResultSetHandler(){ 
          resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
      }
    
      public StatementHandler newStatementHandler(){ 
          statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
      }
    
      public Executor newExecutor(){ 
          executor = (Executor) interceptorChain.pluginAll(executor);
      }
    }

> 时序  
> new出四大金刚 --> interceptorChain.pluginAll --> target = interceptor.plugin(target); —> Plugin.wrap(target, this); Plugin：动态代理 --> Plugin.invoke --> interceptor.intercept

new出四大金刚

interceptorChain.pluginAll

interceptor.plugin

Plugin.wrap

Plugin.invoke

interceptor.intercept

public class Congiguration{ 
      public Executor newExecutor(Transaction transaction, ExecutorType executorType) { 
      //省略部分代码
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }
    }
    
    
    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;
      }
    }
    
    // Plugin实现jdk的InvocationHandler接口表示这个是动态代理
    public class Plugin implements InvocationHandler { 
    
      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;
      }
    
    //最终通过invoke方法运行具体的代理逻辑
    // method == interceptor(就是用户自己实现的自定义插件)
      @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)) { 
             //调用用户自定义插件重写的intercept方法
            return interceptor.intercept(new Invocation(target, method, args));
          }
          return method.invoke(target, args);
        } catch (Exception e) { 
          throw ExceptionUtil.unwrapThrowable(e);
        }
      }
    }

## 扩展知识 ##

### @ConditionalOnClass ###

条件创建bean当，当SqlSessionFactory，SqlSessionFactoryBean这个两个类存在是，才会创建被注解的bean  
@ConditionalOnClass(\{SqlSessionFactory.class, SqlSessionFactoryBean.class\})

### @ConditionalOnBean ###

条件创建bean，当DataSource的bean存在，才可以创建被这个被注解的bean  
@ConditionalOnBean(\{DataSource.class\})

### @ConditionalOnMissingBean ###

当指定的bean不存在，再执行代码，否则不执行。  
下面代码的意思是：当spring的容器中没有SqlSessionFactory时才执行下面方法的代码  
@ConditionalOnMissingBean  
public SqlSessionFactory sqlSessionFactory() \{

## 总结 ##

1.自定义插件可拦截处理的对象:mybatis四大金刚 ParameterHanlder、 ResultSetHanler、 StatementHanlder、 Executor  
2.插件使用责任链模式：四大金刚加入到插件通过责任链设计模式进行链式处理  
3.有三种方式可以把自定义插件加载到mybatis中  
4.@component和@bean注释的拦截器不生效的原因是用户new sqlSessionFactory  
5.@Signature注解的三个参数type、method、args分别对应的值是：四大金刚、要拦截type指定类的方法、指定methos方法的参数类  
6.插件机制用到用jdk的动态代理：Plugin实现jdk的InvocationHandler接口表示这个是动态代理  
7.扩展知识spring中的注解：@ConditionalOnClass、@ConditionalOnBean、@ConditionalOnMissingBean

https://mybatis.org/mybatis-3/configuration.html\#plugins  
http://www.mybatis.cn/726.html  
http://www.mybatis.cn/archives/685.html

[MyBatis四大核心对象之ParameterHandler][MyBatis_ParameterHandler]

[MyBatis_ParameterHandler]: https://www.jianshu.com/p/25edb3f68b1b