mybatis高级特性

插件机制

mybatis采用责任链模式，通过动态代理组织多个插件，通过插件改变默认的sql的行为，myabtis允许通过插件来拦截四大对象：Executor、ParameterHandler、ResultSetHandler以及StatementHandler。

1、插件机制源码

  //创建参数处理器
  public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    //创建ParameterHandler
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    //插件在这里插入
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
  }

  //创建结果集处理器
  public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
      ResultHandler resultHandler, BoundSql boundSql) {
    //创建DefaultResultSetHandler(稍老一点的版本3.1是创建NestedResultSetHandler或者FastResultSetHandler)
    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
    //插件在这里插入
    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
    return resultSetHandler;
  }

  //创建语句处理器
  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;
  }

  public Executor newExecutor(Transaction transaction) {
    return newExecutor(transaction, defaultExecutorType);
  }

  //产生执行器
  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    //判断使用的执行器类型
    executorType = executorType == null ? defaultExecutorType : executorType;
    //这句再做一下保护,囧,防止粗心大意的人将defaultExecutorType设成null?
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    //然后就是简单的3个分支，产生3种执行器BatchExecutor/ReuseExecutor/SimpleExecutor
    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);
    }
    //如果要求缓存，生成另一种CachingExecutor(默认就是有缓存),装饰者模式,所以默认都是返回CachingExecutor
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    //此处调用插件,通过插件可以改变Executor行为
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

每一个拦截器对目标类都进行一次代理

     /**
     *@target
     *@return 层层代理后的对象
     */
    public Object pluginAll(Object target) {
        //循环调用每个Interceptor.plugin方法
        for (Interceptor interceptor : interceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    }

Interceptor 接口说明

/**
 * 拦截器接口
 *
 * @author Clinton Begin
 */
public interface Interceptor {

  /**
   * 执行拦截逻辑的方法
   *
   * @param invocation 调用信息
   * @return 调用结果
   * @throws Throwable 异常
   */
  Object intercept(Invocation invocation) throws Throwable;

  /**
   * 代理类
   *
   * @param target
   * @return
   */
  Object plugin(Object target);

  /**
   * 根据配置来初始化 Interceptor 方法
   * @param properties
   */
  void setProperties(Properties properties);

}

注解拦截器并签名

@Intercepts(@Signature(
        type = StatementHandler.class,
        method = "prepare",
        args = {Connection.class, Integer.class}
))
参数说明:
type 要拦截四大对象的类型
method 拦截对象中哪个方法
args 需要传入的参数

2、手写分页插件

基于ThreadLocal传递分页参数，拦截StatementHandler

@Intercepts(@Signature(
        type = StatementHandler.class,
        method = "prepare",
        args = {Connection.class, Integer.class}
))
public class PagePlugin implements Interceptor {
    // 插件的核心业务
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        /**
         * 1、拿到原始的sql语句
         * 2、修改原始sql，增加分页  select * from t_user limit 0,3
         * 3、执行jdbc去查询总数
         */
        // 从invocation拿到我们StatementHandler对象
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        // 拿到原始的sql语句
        BoundSql boundSql = statementHandler.getBoundSql();
        String sql = boundSql.getSql();

        // statementHandler 转成 metaObject
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);

        // spring context.getBean("userBean")
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        // 获取mapper接口中的方法名称  selectUserByPage
        String mapperMethodName = mappedStatement.getId();
        if (mapperMethodName.matches(".*ByPage")) {
            Page page = PageUtil.getPaingParam();
            //  select * from user;
            String countSql = "select count(0) from (" + sql + ") a";
            System.out.println("查询总数的sql : " + countSql);

            // 执行jdbc操作
            Connection connection = (Connection) invocation.getArgs()[0];
            PreparedStatement countStatement = connection.prepareStatement(countSql);
            ParameterHandler parameterHandler = (ParameterHandler) metaObject.getValue("delegate.parameterHandler");
            parameterHandler.setParameters(countStatement);
            ResultSet rs = countStatement.executeQuery();
            if (rs.next()) {
                page.setTotalNumber(rs.getInt(1));
            }
            rs.close();
            countStatement.close();

            // 改造sql limit
            String pageSql = this.generaterPageSql(sql, page);
            System.out.println("分页sql：" + pageSql);

            //将改造后的sql设置回去
            metaObject.setValue("delegate.boundSql.sql", pageSql);

        }
        // 把执行流程交给mybatis
        return invocation.proceed();
    }

    // 把自定义的插件加入到mybatis中去执行
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    // 设置属性
    @Override
    public void setProperties(Properties properties) {

    }

    // 根据原始sql 生成 带limit sql
    public String generaterPageSql(String sql, Page page) {

        StringBuffer sb = new StringBuffer();
        sb.append(sql);
        sb.append(" limit " + page.getStartIndex() + " , " + page.getTotalSelect());
        return sb.toString();
    }

}

Data
@NoArgsConstructor
public class Page {
    public Page(int currentPage,int pageSize){
        this.currentPage=currentPage;
        this.pageSize=pageSize;
    }

    private int totalNumber;// 当前表中总条目数量
    private int currentPage;// 当前页的位置

    private int totalPage;	// 总页数
    private int pageSize = 3;// 页面大小

    private int startIndex;	// 检索的起始位置
    private int totalSelect;// 检索的总数目

    public void setTotalNumber(int totalNumber) {
        this.totalNumber = totalNumber;
        // 计算
        this.count();
    }

    public void count() {
        int totalPageTemp = this.totalNumber / this.pageSize;
        int plus = (this.totalNumber % this.pageSize) == 0 ? 0 : 1;
        totalPageTemp = totalPageTemp + plus;
        if (totalPageTemp <= 0) {
            totalPageTemp = 1;
        }
        this.totalPage = totalPageTemp;// 总页数

        if (this.totalPage < this.currentPage) {
            this.currentPage = this.totalPage;
        }
        if (this.currentPage < 1) {
            this.currentPage = 1;
        }
        this.startIndex = (this.currentPage - 1) * this.pageSize;// 起始位置等于之前所有页面输乘以页面大小
        this.totalSelect = this.pageSize;// 检索数量等于页面大小
    }
}

@Data
public class PageResponse<T> {
    private int totalNumber;
    private int currentPage;
    private int totalPage;
    private int pageSize = 3;
    private T data;

}

public class PageUtil {
    private static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>();

    public static void setPagingParam(int offset, int limit) {
        Page page = new Page(offset, limit);
        LOCAL_PAGE.set(page);
    }

    public static void removePagingParam() {
        LOCAL_PAGE.remove();
    }

    public static Page getPaingParam() {
        return LOCAL_PAGE.get();
    }

}

使用demo

 PageUtil.setPagingParam(page,size);
        List<TUser> tUsers = tUserDao.queryByPage();
        Page pageInfo = PageUtil.getPaingParam();
        PageResponse<List<TUser>> pageResponse = new PageResponse();
        pageResponse.setData(tUsers);
        pageResponse.setCurrentPage(pageInfo.getCurrentPage());
        pageResponse.setPageSize(pageInfo.getPageSize());
        pageResponse.setTotalNumber(pageInfo.getTotalNumber());
        pageResponse.setTotalPage(pageInfo.getTotalPage());
        PageUtil.removePagingParam();
        return pageResponse;

相关配置

server:
  port: 8085
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3339/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true
    username: root
    password: 123456
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      auto-commit: true   #自动提交
      connection-timeout: 30000 #等待连接池分配连接的最大时长
      minimum-idle: 5   #最小连接数
      maximum-pool-size: 20   #最大连接数
      idle-timeout: 600000   #连接超时的最大时长（毫秒）
      pool-name: DateSourceHikariCP
      max-lifetime: 1800000  #连接的生命时长
      connection-test-query: select 1
mybatis:
  type-aliases-package: com.example.entity
  mapper-locations: classpath:mapper/*.xml
  config-location: classpath:mybatis.xml

3、手写插件实现读写分离

基于spring动态数据源和Theadlocal，拦截Executor

@Intercepts({// mybatis 执行流程
        @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }),
        @Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class })
})
@Slf4j
public class DynamicPlugin implements Interceptor {
    private static final Map<String, String> cacheMap = new ConcurrentHashMap<>();

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object[] objects = invocation.getArgs();
        MappedStatement ms = (MappedStatement) objects[0];

        String dynamicDataSource = null;

        if ((dynamicDataSource = cacheMap.get(ms.getId())) == null) {
            // 读方法
            if (ms.getSqlCommandType().equals(SqlCommandType.SELECT)) { // select * from user;    update insert
                // !selectKey 为自增id查询主键(SELECT LAST_INSERT_ID() )方法，使用主库
                if (ms.getId().contains(SelectKeyGenerator.SELECT_KEY_SUFFIX)) {
                    dynamicDataSource = "write";
                } else {
                    // 负载均衡，针对多个读库
                    dynamicDataSource = "read";
                }
            } else {
                dynamicDataSource = "write";
            }

            log.info("方法[{"+ms.getId()+"}] 使用了 [{"+dynamicDataSource+"}] 数据源, SqlCommandType [{"+ms.getSqlCommandType().name()+"}]..");
            // 把id(方法名)和数据源存入map，下次命中后就直接执行
            cacheMap.put(ms.getId(), dynamicDataSource);
        }
        // 设置当前线程使用的数据源
        DynamicDataSourceHolder.putDataSource(dynamicDataSource);

        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        if (target instanceof Executor) {
            return Plugin.wrap(target, this);
        } else {
            return target;
        }
    }

    @Override
    public void setProperties(Properties properties) {
    }
}

public final class DynamicDataSourceHolder {

    // 使用ThreadLocal记录当前线程的数据源key
    private static final ThreadLocal<String> holder = new ThreadLocal<String>();

    public static void putDataSource(String name){
        holder.set(name);
    }

    public static String getDataSource(){
        return holder.get();
    }

    /**
     * 清理数据源
     */
    public static void clearDataSource() {
        holder.remove();
    }

}

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
      return  DynamicDataSourceHolder.getDataSource();
    }


}

@Configuration
public class DataSourceConfig {
    
    @Value("${spring.datasource.db01.jdbcUrl}")
    private String db01Url;
    @Value("${spring.datasource.db01.username}")
    private String db01Username;
    @Value("${spring.datasource.db01.password}")
    private String db01Password;
    @Value("${spring.datasource.db01.driverClassName}")
    private String db01DiverClassName;

    @Bean("dataSource01")
    public DataSource dataSource01(){
        HikariDataSource dataSource01 = new HikariDataSource();
        dataSource01.setJdbcUrl(db01Url);
        dataSource01.setDriverClassName(db01DiverClassName);
        dataSource01.setUsername(db01Username);
        dataSource01.setPassword(db01Password);
        return dataSource01;
    }

    @Value("${spring.datasource.db02.jdbcUrl}")
    private String db02Url;
    @Value("${spring.datasource.db02.username}")
    private String db02Username;
    @Value("${spring.datasource.db02.password}")
    private String db02Password;
    @Value("${spring.datasource.db02.driverClassName}")
    private String db02DiverClassName;

    @Bean("dataSource02")
    public DataSource dataSource02(){
        HikariDataSource dataSource02 = new HikariDataSource();
        dataSource02.setJdbcUrl(db02Url);
        dataSource02.setDriverClassName(db02DiverClassName);
        dataSource02.setUsername(db02Username);
        dataSource02.setPassword(db02Password);
        return dataSource02;
    }
    @Bean("multipleDataSource")
    public DataSource multipleDataSource(@Qualifier("dataSource01") DataSource dataSource01,
                                         @Qualifier("dataSource02") DataSource dataSource02) {
        Map<Object, Object> datasources = new HashMap<Object, Object>();
        datasources.put("write", dataSource01);
        datasources.put("read", dataSource02);
        DynamicDataSource multipleDataSource = new DynamicDataSource();
        multipleDataSource.setDefaultTargetDataSource(dataSource01);
        multipleDataSource.setTargetDataSources(datasources);
        return multipleDataSource;
    }

}

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
      return  DynamicDataSourceHolder.getDataSource();
    }
}

public class DynamicDataSourceTransactionManager extends DataSourceTransactionManager {
    private static final long serialVersionUID = 1L;

    public DynamicDataSourceTransactionManager(DataSource dataSource){
        super(dataSource);
    }

    /**
     * 只读事务到读库，读写事务到写库
     *
     * @param transaction
     * @param definition
     */
    @Override
    protected void doBegin(Object transaction, TransactionDefinition definition) {

        // 设置数据源
        boolean readOnly = definition.isReadOnly();
        if (readOnly) {
            DynamicDataSourceHolder.putDataSource("read");
        } else {
            DynamicDataSourceHolder.putDataSource("write");
        }
        super.doBegin(transaction, definition);
    }

    /**
     * 清理本地线程的数据源
     *
     * @param transaction
     */
    @Override
    protected void doCleanupAfterCompletion(Object transaction) {
        super.doCleanupAfterCompletion(transaction);
        DynamicDataSourceHolder.clearDataSource();
    }
}

Configuration
@MapperScan("com.example.dao")
@EnableTransactionManagement
public class MybatisConfig implements TransactionManagementConfigurer {

    private static String mybatisConfigPath = "mybatis-config.xml";

    @Autowired
    @Qualifier("multipleDataSource")
    private DataSource multipleDataSource;

    @Bean("sqlSessionFactoryBean")
    public SqlSessionFactory sqlSessionFactoryBean() throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(multipleDataSource);
        bean.setTypeAliasesPackage("com.example.entity");
        bean.setConfigLocation(new ClassPathResource(mybatisConfigPath));
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        bean.setMapperLocations(resolver.getResources("classpath*:mapper/*.xml"));
        return bean.getObject();

    }

    public PlatformTransactionManager annotationDrivenTransactionManager() {
        return new DynamicDataSourceTransactionManager(multipleDataSource);
    }
}

mybatis二级缓存

mybatis默认开启一级缓存，一级缓存是sqlsession级别的，所以在实际场景中并没有什么用，Mybatis二级缓存默认关闭,使用方式如下: 1、在全局配置文件中加入

      <settings>
	<setting name="cacheEnabled" value="true" />
      </settings>

2、在使用二级缓存的mapper.xml中加入

<mapper namespace="com.study.mybatis.mapper.UserMapper">
	<!--开启本mapper的namespace下的二级缓存-->
	<cache eviction="LRU" flushInterval="100000" readOnly="true" size="1024"/>
</mapper>
    <!--eviction:代表的是缓存回收策略，目前MyBatis提供以下策略。
        (1) LRU,最近最少使用的，一处最长时间不用的对象
        (2) FIFO,先进先出，按对象进入缓存的顺序来移除他们
        (3) SOFT,软引用，移除基于垃圾回收器状态和软引用规则的对象
        (4) WEAK,弱引用，更积极的移除基于垃圾收集器状态和弱引用规则的对象。这里采用的是LRU，移除最长时间不用的对形象
        flushInterval:刷新间隔时间，单位为毫秒，这里配置的是100秒刷新，如果你不配置它，那么当
        SQL被执行的时候才会去刷新缓存。
        size:引用数目，一个正整数，代表缓存最多可以存储多少个对象，不宜设置过大。设置过大会导致内存溢出。
        这里配置的是1024个对象
        readOnly:只读，意味着缓存数据只能读取而不能修改，这样设置的好处是我们可以快速读取缓存，缺点是我们没有办法修改缓存，他的默认值是false，不允许我们修改
    -->

这样我们就实现了基于单机jvm内存的myabtis二级缓存，如果是分布式应用，可以引入myabtis-redis相关依赖，实现基于redis的分布式缓存

cache type="org.mybatis.caches.redis.RedisCache" />

也可以自定义缓存，myabtis为我们预留了Cache接口

mybatis自定义类型转换器

通过用于特殊字段的统一转换、敏感字段加密等，使用方式如下：

public class MyTypeHandler implements TypeHandler {

    //private static String KEY = "123456";

    /**
     * 通过preparedStatement对象设置参数，将T类型的数据存入数据库。
     *
     * @param ps
     * @param i
     * @param parameter
     * @param jdbcType
     * @throws SQLException
     */
    @Override
    public void setParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType) throws SQLException {
        try {
            String encrypt = EncryptUtil.encode(((String) parameter).getBytes());
            ps.setString(i, encrypt);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 通过列名或者下标来获取结果数据，也可以通过CallableStatement获取数据。
    @Override
    public Object getResult(ResultSet rs, String columnName) throws SQLException {
        String result = rs.getString(columnName);
        if (result != null && result != "") {
            try {
                return EncryptUtil.decode(result.getBytes());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    @Override
    public Object getResult(ResultSet rs, int columnIndex) throws SQLException {
        String result = rs.getString(columnIndex);
        if (result != null && result != "") {
            try {
                return EncryptUtil.decode(result.getBytes());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    @Override
    public Object getResult(CallableStatement cs, int columnIndex) throws SQLException {
        String result = cs.getString(columnIndex);
        if (result != null && result != "") {
            try {
                return EncryptUtil.decode(result.getBytes());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }
}

public class EncryptUtil {

    //base64 解码
    public static String decode(byte[] bytes) {
        return new String(Base64.decodeBase64(bytes));
    }

    //base64 编码
    public static String encode(byte[] bytes) {
        return new String(Base64.encodeBase64(bytes));
    }
}

mybatis配置文件中引入类型转换器

     <plugins>
        <plugin interceptor="com.example.plugin.PagePlugin" >
            <property name="type" value="mysql"/>
        </plugin>
    </plugins>

在需要使用的字段中指定类型转换器

      <resultMap id="resultListUser" type="com.example.entity.User" >
	<result column="password" property="password" typeHandler="com.example.typehandler.MyTypeHandler" />
      </resultMap>

      <update id="updateUser" parameterType="com.example.entity.User">
	UPDATE user userName=#{userName typeHandler="com.example.typehandler.MyTypeHandler"} WHERE id=#{id}
      </update>

完整mybatis配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 全局配置 -->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true" />
        <!--这个配置使全局的映射器(二级缓存)启用或禁用缓存-->
        <setting name="cacheEnabled" value="true" />
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!-- 自定义类型处理器-->
    <typeHandlers>
        <typeHandler handler="com.study.mybatis.handler.AllenTypeHandle" />
    </typeHandlers> 

    <!-- 插件 -->
    <plugins>
        <plugin interceptor="com.example.plugin.PagePlugin" >
            <property name="type" value="mysql"/>
        </plugin>
    </plugins>
    

</configuration>