Mybatis插件原理

最新推荐文章于 2024-06-17 08:25:01 发布
最新推荐文章于 2024-06-17 08:25:01 发布
阅读量282 收藏 1
点赞数 1
文章标签： mybatis java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44099102/article/details/125804353
版权
本文详细介绍了MyBatis拦截器的使用，包括Executor和StatementHandler的拦截实现，展示了如何通过拦截器修改SQL语句和处理数据。同时，文章深入解析了拦截器的JDK动态代理原理，解释了为何拦截器能作用于四大对象，并概述了Executor的执行流程。最后，总结了涉及的设计模式，如模板模式、装饰者模式等。
摘要由CSDN通过智能技术生成

一、插件的使用

2. 介绍

        MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的对象方法调用包括：

Executor：MyBatis 执行器，负责 SQL 语句的生成和查询缓存的维护，继承关系如下：

StatementHandler：封装了JDBC Statement 操作，继承关系如下：

 

ParameterHandler：负责SQL参数的组装

ResultSetHandler：负责SQL结果的组装

2. 实现

（1）定义拦截器

StatementHandler拦截的实现：

@Intercepts({@Signature(type = Executor.class, method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})})
@Slf4j
public class MybatisInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable{
		log.info("拦截器内部处理");
        return invocation.proceed();
    }
    @Override
    public Object plugin(Object target){
        return Plugin.wrap(target, this);
    }
    @Override
    public void setProperties(Properties properties){
    }
}

 Executor拦截的实现：

import com.example.demo.mybatis.domain.BasePO;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.DefaultReflectorFactory;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
import org.apache.ibatis.reflection.wrapper.DefaultObjectWrapperFactory;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.Objects;
import java.util.Properties;


@Intercepts({@Signature(type = Executor.class, method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})
        , @Signature(type = Executor.class, method = "query",
                args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
        , @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})
@Slf4j
@Component
//@Order(10)
public class MybatisInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable{

        // 执行器
        Executor executor = (Executor)invocation.getTarget();

        // 方法参数
        Object[] args = invocation.getArgs();
        MappedStatement ms = (MappedStatement)args[0];
        Object parameter = args[1];

        switch (ms.getSqlCommandType()){
            case SELECT:
                RowBounds rowBounds = (RowBounds)args[2];
                ResultHandler resultHandler = (ResultHandler)args[3];
                CacheKey cacheKey;
                BoundSql boundSql;
                if (args.length == 4) {
                    boundSql = ms.getBoundSql(parameter);
                    cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
                } else {
                    cacheKey = (CacheKey)args[4];
                    boundSql = (BoundSql)args[5];
                }
                String originSql = boundSql.getSql();
                log.info("【MybatisInterceptor】原始SQL: {}", originSql);
                String newSql = originSql + " order by id desc";

                SqlSource newSqlSource = this.buildSqlSource(boundSql, newSql);

//                MetaObject msObject = MetaObject.forObject(ms, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
//                msObject.setValue("sqlSource", newSqlSource);
//                log.info("【MybatisInterceptor】增强后SQL: {}", ms.getBoundSql(parameter).getSql());

                MappedStatement newMs = this.buildMappedStatement(ms, newSqlSource);
                log.info("【MybatisInterceptor】增强后SQL: {}", newMs.getBoundSql(parameter).getSql());
                args[0] = newMs;
                break;
            case INSERT:
                if(parameter instanceof BasePO){
                    ReflectUtil.setSuperValue("createTime", LocalDateTime.now(), parameter);
                }
            case UPDATE:
                if(parameter instanceof BasePO){
                    ReflectUtil.setSuperValue("updateTime", LocalDateTime.now(), parameter);
                }
        }
        return invocation.proceed();
    }

    /**
     * 新建一个 MappedStatement
     * 避免修改 Configuration中的 mappedStatements
     * 导致从自定义的 SqlSource 中获取增强后的SQL
     * getSqlBoundSql -> sqlSource.getBoundSql -> XML原始SQL
     * @param ms
     * @param sqlSource
     * @return
     */
    private MappedStatement buildMappedStatement(MappedStatement ms, SqlSource sqlSource) {
        MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(), ms.getId(), sqlSource, ms.getSqlCommandType());
        builder.resource(ms.getResource())
                .parameterMap(ms.getParameterMap())
                .resultMaps(ms.getResultMaps())
                .fetchSize(ms.getFetchSize())
                .timeout(ms.getTimeout())
                .statementType(ms.getStatementType())
                .resultSetType(ms.getResultSetType())
                .cache(ms.getCache())
                .flushCacheRequired(ms.isFlushCacheRequired())
                .useCache(ms.isUseCache())
                .resultOrdered(ms.isResultOrdered())
                .keyGenerator(ms.getKeyGenerator())
                .keyProperty(Objects.isNull(ms.getKeyProperties())?null:String.join(",", ms.getKeyProperties()));

        return builder.build();
    }

    private BoundSqlSqlSource buildSqlSource(BoundSql boundSql, String sql){
        // Mybatis 反射工具
        MetaObject msObject = MetaObject.forObject(boundSql, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
        msObject.setValue("sql", sql);
        return new BoundSqlSqlSource(boundSql);
    }

    /**
     * 自定义内部类，利用反射赋值boundSql
     * boundSql 使用原MapperStatement不受影响
     * getSqlBoundSql -> sqlSource.getBoundSql 会从 StaticSqlSource 中获取XML原始SQL
     */
    static class BoundSqlSqlSource implements SqlSource {

        private BoundSql boundSql;

        BoundSqlSqlSource(BoundSql boundSql) {
            this.boundSql = boundSql;
        }

        @Override
        public BoundSql getBoundSql(Object parameterObject) {
            return boundSql;
        }
    }

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

    @Override
    public void setProperties(Properties properties){

    }

}

（2）配置拦截器

  • 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>

    <plugins>
        <plugin interceptor="com.example.demo.mybatis.interceptor.MybatisInterceptor"/>
    </plugins>

</configuration>
  •  Spring中添加Mybatis插件
@Configuration
@MapperScan({"com.example.demo.mybatis.mapper"})
public class MyBatisConfig {

    @Resource
    private DataSource dataSource;

    @Resource
    private MybatisInterceptor mybatisInterceptor;

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*Mapper.xml"));
        sqlSessionFactoryBean.setPlugins(new Interceptor[] {mybatisInterceptor});
        return sqlSessionFactoryBean.getObject();
    }

二、原理

1. JDK动态代理

        定义代理类实现InvocationHandler，持有被代理类的引用，重写invoke方法，获取代理类实例的方法：

Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

        这里简单介绍jdk的动态代理，因为mybatis插件的实现原理基于此，只有在完全理解动态代理的基础上才能更好的理解mybatis插件的实现原理

2. 源码解析

（1）Interceptor

// 用于覆盖被拦截对象的原有方法（在调用代理对象 Plugin 的 invoke()方法时被调用） 
Object intercept(Invocation invocation) throws Throwable; 

// target 是被拦截对象，这个方法的作用是给被拦截对象生成一个代理对象，并返回
Object plugin(Object target); 

// 设置参数 
void setProperties(Properties properties);

（2）Plugin

// 基于动态代理实现
public class Plugin implements InvocationHandler{

    // 生成代理类
public static Object wrap(Object target, Interceptor interceptor) {
......
      return Proxy.newProxyInstance(
            type.getClassLoader(),
            interfaces,
            new Plugin(target, interceptor, signatureMap));
    }

    // 重写invoke方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
......
      return interceptor.intercept(new Invocation(target, method, args));
}    
}

（3）Invocation

// 被代理对象
private final Object target;

private final Method method;
private final Object[] args;

// 反射执行被代理的方法
Public Object proceed() throws InvocationTargetException, IllegalAccessException {
  return method.invoke(target, args);
}

3. 执行流程

（1）Mapper动态代理

public class MapperProxy<T> implements InvocationHandler, Serializable {
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    ......
    return mapperMethod.execute(sqlSession, args);
  }
}

 这里是基于JDK动态代理实现调用mapper接口，最终实现由代理类执行XML中SQL.。承上启下，不做详细介绍，感兴趣的小伙伴可以另行查阅，或者留言有机会我来总结一下一起学习。如下执行流程Mapper -> MapperMethod -> SqlSession -> Executor，自此便到了我们拦截器可拦截器的对象

（2）四大代理对象

Open session时创建executor 

Configuration

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    ......
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

执行SQL时创建StatementHandler

SimpleExecutor

public <E> List<E> doQuery(......) throws SQLException {
......
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
  }


Configuration

public StatementHandler newStatementHandler(......) {
   StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
statementHandler=(StatementHandler)interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

创建StatementHandler时创建ParameterHandler和ResultSetHandler

BaseStatementHandler

protected BaseStatementHandler(......) {
this.parameterHandler=configuration.newParameterHandler(mappedStatement,parameterObject,boundSql);
    this.resultSetHandler=configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
  }


Configuration

public ParameterHandler newParameterHandler(......) {
parameterHandler=(ParameterHandler)interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
  }

public ResultSetHandler newResultSetHandler(......) {
resultSetHandler=(ResultSetHandler)interceptorChain.pluginAll(resultSetHandler);
    return resultSetHandler;
  }

通过以上源码，解释了为什么拦截器会对该四大对象生效 

（3）Executor拦截器

Executor拦截器的执行流程：

  1. 执行query时，由于动态代理，执行Plugin的invoke方法
  2. 继续执行Plugin invoke方法中的interceptor.intercept，进入自定义的拦截器，执行invocation.proceed()
  3. 执行invocation.proceed()，通过代理执行被代理类query方法

4. 设计模式总结

Executor：模板模式、装饰者模式

InterceptorChain：责任链模式

StatementHandler：委派模式、策略模式

Plugin：代理模式

李道存
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
MyBatis插件原理及扩展
光剑书架上的书
07-29 1923
概念：插件（plugin）是Mybatis中的一个重要机制，它可以增强或改变Mybatis核心功能，无需修改源码。这里所说的插件主要包括两类：mybatis-generator、mybatis-pagehelper等。为什么需要插件？从mybatis的官方网站上可知，Mybatis是一个优秀的持久层框架，它支持定制化SQL、缓存、绑定变量和映射，适合中小型项目，但对于复杂的需求却不太好用。因此，mybatis提供了一些扩展插件来满足复杂业务下的需求。
Mybatis插件原理以及自建插件
weixin_45060598的博客
01-16 1014
1.Mybatis架构 把Mybatis的功能架构分为三层: 1. API接口层:提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。 2. 数据处理层:负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。 3. 基础支撑层:负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提
mybatis 插件原理
wtmdcnm的博客
03-25 1017
1.Mybatis插件原理 Mybatis的插件，是采用责任链机制，通过JDK动态代理来实现的。默认情况下，Mybatis允许使用插件来拦截四个对象： Executor：执行CURD操作； StatementHandler：处理sql语句预编译，设置参数等相关工作； ParameterHandler：设置预编译参数用的； ResultSetHandler：处理结果集。 这个我们可以从Mybatis的源码中看到，例如下面创建Executor的时候，就是返回了一个代理Executor对象： 开始
MyBatis 插件机制详解
最新发布
FireFox1997
06-17 1252
MyBatis 的插件机制是基于 Java 的动态代理实现的，允许我们拦截 SQL 执行的某些步骤，如：创建 Executor、ParameterHandler、ResultSetHandler 和 StatementHandler 对象的过程。通过插件机制，开发者可以在这些步骤中添加自定义的逻辑。SQL 日志记录参数验证和修改查询结果处理性能监控MyBatis 插件机制提供了一种灵活的方式，允许开发者在 SQL 执行的各个阶段插入自定义逻辑，极大地增强了 MyBatis 的扩展能力。
mybatis插件原理
u012829112的博客
12-26 1436
MyBatis 插件原理与自定义插件： 　　MyBatis 通过提供插件机制，让我们可以根据自己的需要去增强MyBatis 的功能。需要注意的是，如果没有完全理解MyBatis 的运行原理和插件的工作方式，最好不要使用插件，因为它会改变系底层的工作逻辑，给系统带来很大的影响。 　　MyBatis 的插件可以在不修改原来的代码的情况下，通过拦截的方式，改变四大核心对象的行为，比如处理参数，处理SQL，处理结果。 第一个问题： 　　不修改对象的代码，怎么对对象的行为进行修改，比如说在原来的方法前面做一点
Mybatis插件的原理
weixin_40980639的博客
07-13 755
我们创建的拦截器必须要实现Interceptor接口，Interceptor接口的定义为 在MyBatis中Interceptor允许拦截的内容是 1.2 配置拦截器 创建好自定义的拦截器后，我们需要在全局配置文件中添加自定义插件的注册 2.插件实现原理 2.1初始化操作 首先我们来看下在全局配置文件加载解析的时候做了什么操作。 进入方法内部可以看到具体的解析操作 该方法用来解析全局配置文件中的plugins标签，然后对应的创建Interceptor对象，并且封装对应的 属性信息。最后调用了Configu
02-02-03-MyBatis插件原理及Spring集成1
08-04
总的来说，理解 MyBatis 插件原理和自定义插件的编写，可以帮助我们更好地扩展 MyBatis 的功能，实现更灵活的数据库操作。同时，掌握 Spring 集成 MyBatis 的方法，可以确保事务管理和资源管理的正确性，提升系统的...
Mybatis 插件原理解析
LZN的博客
10-02 421
文章目录一、构建 SqlSessionFactory 的过程1.1 构建 Configuration1.2 映射器内部组成1.3 构建 SqlSessionFactory二、SqlSession 运行过程2.1 映射器动态代理2.2 SqlSession 四大对象2.2.1 Executor2.2.2 StatementHandler2.2.3 ParameterHandler2.2.4 ResultHandler2.3 SqlSession 运行总结三、插件3.1 插件接口3.2 插件初始化3.3 插件的
MyBatis——MyBatis插件原理
庄小焱
08-30 1474
本博文主要介绍MyBatis插件机原理，帮助大家更好的理解和学习MyBatis。
Mybatis插件机制原理
我神级欧文的博客
08-18 684
在Mybatis中，有一个强大的机制可以让我们快速地侵入到Mybatis的底层操作，从而去扩展Mybatis的功能，这就是插件机制，我们也可以叫作Mybatis的拦截器机制。 一.基本原理 在Mybatis架构体系中，有着四大组件（对象），分别是Executor，StatementHandler，ParameterHandler，ResultSetHandler。而我们在阅读Mybatis...
深入剖析 mybatis 原理（四）插件的原理和应用
ignore
12-22 1203
mybatis 插件原理
Mybatis插件原理（一）-- 简单编写Mybatis插件
热门推荐
盐二白
09-03 1万+
引言： 当我们使用Mybatis的时候，总会使用到各种插件，如PageHelper（分页插件）等，当我们需要自定义插件来改变，就必须了解插件的实现原理。 概述 Mybatis插件又称拦截器，Mybatis采用责任链模式，通过动态代理组织多个插件（拦截器），通过这些插件可以改变Mybatis的默认行为。MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis允许使...
MyBatis插件运行原理
qq_46130027的博客
04-23 457
Mybatis的插件相当于拦截器，我们可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件, Mybatis通过动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，先判断执行的方法是否需要代理的方法，如果是则执行插件类的增强方法，进行方法的拦截处理。（面向切面编程的思想）执行器，执行增删改查。对sql参数进行处理。对结果集对象进行处理。对sql语句进行处理。
Mybatis 的插件运行原理
qq_32045991的博客
08-09 438
Mybatis 插件运行原理 Mybatis 中的四大对象 Executor、ParameterHandler、ResultSetHandler、StatementHandler 都是代理对象。 如下代码，在创建时会调用 interceptorChain.pluginAll() 方法，遍历调用 plugin 方法判断是否返回目标对象本身，还是进行拦截返回代理对象。 如果拦截返回代理对象的话，之后调用时，会调用代理对象的拦截方法 intercept 进行拦截增强，从而实现调用插件。这与 RPC 客户端在调用
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值