mybatis源码解析之插件模块

客官°小女子只卖身不卖艺 2022-09-03 14:21 196阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  1.mybatis执行流程回顾
         *  2.插件使用
         *   *  2.1 wrap对象介绍
             *  2.2 插件编码
             *  2.3 执行
         *  3.源码剖析
         *  总结

--------------------

### 前言 ###

本文主要介绍下关于mybatis插件这块的知识，包括插件使用，源码剖析等等，在mybatis执行流程中，Executor，StatementHandler,ResultSetHandler,ParameterHandler这四个组件起着至关重要的作用，mybatis的插件正好能够作用在这个四个组件上，起到拦截增强的作用，使得执行流程更加灵活，扩展性更强，自由定制。

### 1.mybatis执行流程回顾 ###

我们先来回顾下mybatis的执行流程，当我们启动项目的时候，会创建SqlSessionFactory对象，在创建这个对象的时候，解析mybatis配置文件，解析我们的mapper 文件等等，它的作用就是创建SqlSession，与此同时，会扫描我们的mapper 接口，创建对应的动态代理实现类。创建SqlSessionTemplate， 这个里面持有SqlSessionFactory对象，这是项目初始化流程，接着我们看下执行流程。  
我们在执行某个sql语句的时候，其实就是执行的某个mapper接口（dao接口）的方法，实现类就是mybatis为我们创建的动态代理类（这个动态代理是用jdk的proxy创建出来的），会找到SqlSessionTemplate 对象，这个对象里面也就个动态代理类，然后会找到SqlSessionFactory创建一个SqlSession,创建sqlSession对象的时候会创建一个Executor对象，这个Executor对象会被插件进行包装（wrap），之后的执行其实就是调用的Executor的一些方法，会经过一级缓存，二级缓存，接着就是找到Configuration创建一个StatementHandler ，创建StatementHandler对象的同时会创建ParameterHandler与ResultSetHandler对象，StatementHandler ，ParameterHandler ，ResultSetHandler 这个三个对象都会被插件拦截增强包装 ，接着就是调用StatementHandler 的一些方法获取数据库连接，创建statement对象，在执行sql之前会调用ParameterHandler对象往statement中设置参数，接着就是执行sql了，执行完成后，会调用ResultSetHandler 进行结果集的处理，封装成我们想要的那种结果集，然后返回会给我们的调用方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]

### 2.插件使用 ###

#### 2.1 wrap对象介绍 ####

我们先不着急介绍它怎样使用，我们先来介绍下它能增强哪些组件的哪些方法

1.  Executor:

int update(MappedStatement ms, Object parameter) throws SQLException;
    <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
    <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
    <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;
    List<BatchResult> flushStatements() throws SQLException;
    void commit(boolean required) throws SQLException;
    void rollback(boolean required) throws SQLException;
    CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
    boolean isCached(MappedStatement ms, CacheKey key);
    void clearLocalCache();
    void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
    Transaction getTransaction();
    void close(boolean forceRollback);
    boolean isClosed();
    void setExecutorWrapper(Executor executor);

1.  StatementHandler

Statement prepare(Connection connection, Integer transactionTimeout)
        throws SQLException;
    void parameterize(Statement statement)
        throws SQLException;
    void batch(Statement statement)
        throws SQLException;
    int update(Statement statement)
        throws SQLException;
    <E> List<E> query(Statement statement, ResultHandler resultHandler)
        throws SQLException;
    <E> Cursor<E> queryCursor(Statement statement)
        throws SQLException;
    BoundSql getBoundSql();
    ParameterHandler getParameterHandler();

1.  ParameterHandler

Object getParameterObject();
      void setParameters(PreparedStatement ps) throws SQLException;

1.  ResultSetHandler

<E> List<E> handleResultSets(Statement stmt) throws SQLException;
    <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;
    void handleOutputParameters(CallableStatement cs) throws SQLException;

#### 2.2 插件编码 ####

这里随便举个例子，比如说我要打印一下我执行之前的参数，我这里就可以 增强一个下Executor的update方法，对它的parameter 参数进行打印，我们的增删改sql都会走 update 方法，我们来看看怎么写这个插件。

1.  实现Interceptor 接口，重写intercept 方法。

public class TestMybatisInterceptor implements Interceptor { 
        @Override
        public Object intercept(Invocation invocation) throws Throwable { 
            Object[] args = invocation.getArgs();
            System.out.println(args[1]);
            return invocation.proceed();
        }
    }

1.  添加注解  
    @Intercepts 告诉mybatis要对哪些步骤进行来拦截。

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Intercepts { 
      /** * Returns method signatures to intercept. * * @return method signatures */
      Signature[] value();
    }

它里面的这个value （@Signature注解）就是具体的拦截那个接口的哪个方法。  
@Signature 里面有个三个属性  
type：拦截哪个接口  
method：哪个方法名  
args：参数类型  
现在我就可以在我写的这个插件上面添加注解了。

@Intercepts({ 
         @Signature(type = Executor.class,method = "update", args = { MappedStatement.class,Object.class})
    })
    @Component
    public class TestMybatisInterceptor implements Interceptor { 
        @Override
        public Object intercept(Invocation invocation) throws Throwable { 
            Object[] args = invocation.getArgs();
            System.out.println(args[1]);
            return invocation.proceed();
        }
    }

可以看到我还加了个@Component交给spring管理了。

#### 2.3 执行 ####

由于我这里环境是个多数据源的，这个插件也交给spring管理了我这里直接就往SqlSessionFactory里面塞了

@Autowired
    private Interceptor interceptor;
    @Primary
    @Bean("mainSqlSessionFactory")
    public SqlSessionFactory  createMainSqlSessionFactory(@Qualifier("mainDataSource") DataSource dataSource) throws Exception { 
        SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dataSource);
        sqlSessionFactory.setPlugins(interceptor);
        sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().
                getResources("classpath:mapper/main/*.xml"));
        return sqlSessionFactory.getObject();
    }

### 3.源码剖析 ###

接下来我们就要看下实现原理了，我们这里以Executor为例子，直接看看创建Executor 那块代码

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { 
        Transaction tx = null;
        try { 
          final Environment environment = configuration.getEnvironment();
          final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
          tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
    
          //创建executor
          final Executor executor = configuration.newExecutor(tx, execType);
          //创建DefaultSqlSession对象
          return new DefaultSqlSession(configuration, executor, autoCommit);
        } catch (Exception e) { 
          closeTransaction(tx); // may have fetched a connection so lets call close()
          throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
        } finally { 
          ErrorContext.instance().reset();
        }
      }

这段代码是创建sqlSession的，可以看到在创建SqlSession之前要创建一个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) { // 使用CachingExecutor包装
          executor = new CachingExecutor(executor);
        }// 使用 插件包装
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }

可以看到 `executor = (Executor) interceptorChain.pluginAll(executor);`这行代码，这个就是插件进行增强。

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 对象
      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;
    }

首先是解析我们插件上面的@Intercepts注解信息。  
获取要增强的接口（也就是@Intercepts 注解中要增强的接口）  
使用jdk创建动态代理类，它的invocationHandler就是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);
        }
      }

其实很简单，就是去signatureMap 这个map中找到对应的方法，如果有的话，就调用插件进行拦截，没有的话，就使用反射执行方法了。  
signatureMap 就是我们@Intercepts注解解析出来的。

### 总结 ###

本文回顾了一下mybatis的核心执行流程，编写了一个简单的插件，并剖析了mybatis插件实现源码。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]: /images/20220829/1d7d7235ce804139bd50f72aee0a0a36.png