跳至主要內容

原理与插件 - MyBatis 面试题及答案

Java突击队2025/12/19大约 11 分钟高频面试题面试题

15.能说说MyBatis的工作原理吗？

我们已经大概知道了MyBatis的工作流程，按工作原理，可以分为两大步：生成会话工厂、会话运行。

MyBatis的工作流程

MyBatis是一个成熟的框架，篇幅限制，这里抓大放小，来看看它的主要工作流程。

构建会话工厂

构造会话工厂也可以分为两步：

构建会话工厂

  • 获取配置

    获取配置这一步经过了几步转化，最终由生成了一个配置类Configuration实例，这个配置类实例非常重要，主要作用包括：

    • 读取配置文件，包括基础配置文件和映射文件

    • 初始化基础配置，比如MyBatis的别名，还有其它的一些重要的类对象，像插件、映射器、ObjectFactory等等

    • 提供一个单例，作为会话工厂构建的重要参数

    • 它的构建过程也会初始化一些环境变量，比如数据源

    public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
   SqlSessionFactory var5;
   //省略异常处理
       //xml配置构建器
       XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
       //通过转化的Configuration构建SqlSessionFactory
       var5 = this.build(parser.parse());
}

  • 构建SqlSessionFactory

    SqlSessionFactory只是一个接口，构建出来的实际上是它的实现类的实例，一般我们用的都是它的实现类DefaultSqlSessionFactory，

    public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

会话运行

会话运行是MyBatis最复杂的部分，它的运行离不开四大组件的配合：

MyBatis会话运行四大关键组件

  • Executor（执行器）

    Executor起到了至关重要的作用，SqlSession只是一个门面，相当于客服，真正干活的是是Executor，就像是默默无闻的工程师。它提供了相应的查询和更新方法，以及事务方法。

    Environment environment = this.configuration.getEnvironment();
TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//通过Configuration创建executor
Executor executor = this.configuration.newExecutor(tx, execType);
var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);

  • StatementHandler（数据库会话器）

    StatementHandler，顾名思义，处理数据库会话的。我们以SimpleExecutor为例，看一下它的查询方法，先生成了一个StatementHandler实例，再拿这个handler去执行query。

 public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
     Statement stmt = null;

     List var9;
     try {
         Configuration configuration = ms.getConfiguration();
         StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
         stmt = this.prepareStatement(handler, ms.getStatementLog());
         var9 = handler.query(stmt, resultHandler);
     } finally {
         this.closeStatement(stmt);
     }

     return var9;
 }
再以最常用的PreparedStatementHandler看一下它的query方法，其实在上面的`prepareStatement`已经对参数进行了预编译处理，到了这里，就直接执行sql，使用ResultHandler处理返回结果。
```java
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        PreparedStatement ps = (PreparedStatement)statement;
        ps.execute();
        return this.resultSetHandler.handleResultSets(ps);
    }
```

  • ParameterHandler （参数处理器）

    PreparedStatementHandler里对sql进行了预编译处理

    public void parameterize(Statement statement) throws SQLException {
    this.parameterHandler.setParameters((PreparedStatement)statement);
}

    这里用的就是ParameterHandler，setParameters的作用就是设置预编译SQL语句的参数。

    里面还会用到typeHandler类型处理器，对类型进行处理。

        public interface ParameterHandler {
        Object getParameterObject();
    
        void setParameters(PreparedStatement var1) throws SQLException;
    }

  • ResultSetHandler（结果处理器）

    我们前面也看到了，最后的结果要通过ResultSetHandler来进行处理，handleResultSets这个方法就是用来包装结果集的。Mybatis为我们提供了一个DefaultResultSetHandler，通常都是用这个实现类去进行结果的处理的。

        public interface ResultSetHandler {
        <E> List<E> handleResultSets(Statement var1) throws SQLException;
    
        <E> Cursor<E> handleCursorResultSets(Statement var1) throws SQLException;
    
        void handleOutputParameters(CallableStatement var1) throws SQLException;
    }

    它会使用typeHandle处理类型，然后用ObjectFactory提供的规则组装对象，返回给调用者。

整体上总结一下会话运行：

会话运行的简单示意图

PS：以上源码分析比较简单，在真正的源码大佬面前可能过不了关，有条件的建议Debug一下MyBatis的源码。

我们最后把整个的工作流程串联起来，简单总结一下：

MyBatis整体工作原理图

  1. 读取 MyBatis 配置文件——mybatis-config.xml 、加载映射文件——映射文件即 SQL 映射文件，文件中配置了操作数据库的 SQL 语句。最后生成一个配置对象。

  2. 构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。

  3. 创建会话对象：由会话工厂创建 SqlSession 对象，该对象中包含了执行 SQL 语句的所有方法。

  4. Executor 执行器：MyBatis 底层定义了一个 Executor 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。

  5. StatementHandler：数据库会话器，串联起参数映射的处理和运行结果映射的处理。

  6. 参数处理：对输入参数的类型进行处理，并预编译。

  7. 结果处理：对返回结果的类型进行处理，根据对象映射规则，返回相应的对象。

16.MyBatis的功能架构是什么样的？

MyBatis功能架构

我们一般把Mybatis的功能架构分为三层：

  • API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。
  • 数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。
  • 基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

17.为什么Mapper接口不需要实现类？

四个字回答：动态代理，我们来看一下获取Mapper的过程：

Mapper代理

  • 获取Mapper

    我们都知道定义的Mapper接口是没有实现类的，Mapper映射其实是通过动态代理实现的。

    BlogMapper mapper = session.getMapper(BlogMapper.class);

    七拐八绕地进去看一下，发现获取Mapper的过程，需要先获取MapperProxyFactory——Mapper代理工厂。

    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
    if (mapperProxyFactory == null) {
        throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    } else {
        try {
            return mapperProxyFactory.newInstance(sqlSession);
        } catch (Exception var5) {
            throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
        }
    }
}

    • MapperProxyFactory

      MapperProxyFactory的作用是生成MapperProxy（Mapper代理对象）。

        public class MapperProxyFactory<T> {
        private final Class<T> mapperInterface;
        ……
        protected T newInstance(MapperProxy<T> mapperProxy) {
            return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
        }
    
        public T newInstance(SqlSession sqlSession) {
            MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
            return this.newInstance(mapperProxy);
        }
    }

    这里可以看到动态代理对接口的绑定，它的作用就是生成动态代理对象（占位），而代理的方法被放到了MapperProxy中。

    • MapperProxy

    MapperProxy里，通常会生成一个MapperMethod对象，它是通过cachedMapperMethod方法对其进行初始化的，然后执行excute方法。

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);
    } catch (Throwable var5) {
        throw ExceptionUtil.unwrapThrowable(var5);
    }
}

    • MapperMethod

      MapperMethod里的excute方法，会真正去执行sql。这里用到了命令模式，其实绕一圈，最终它还是通过SqlSession的实例去运行对象的sql。

    public Object execute(SqlSession sqlSession, Object[] args) {
   Object result;
   Object param;
   ……
   case SELECT:
       if (this.method.returnsVoid() && this.method.hasResultHandler()) {
           this.executeWithResultHandler(sqlSession, args);
           result = null;
       } else if (this.method.returnsMany()) {
           result = this.executeForMany(sqlSession, args);
       } else if (this.method.returnsMap()) {
           result = this.executeForMap(sqlSession, args);
       } else if (this.method.returnsCursor()) {
           result = this.executeForCursor(sqlSession, args);
       } else {
           param = this.method.convertArgsToSqlCommandParam(args);
           result = sqlSession.selectOne(this.command.getName(), param);
           if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {
               result = Optional.ofNullable(result);
           }
       }
       break;
       ……
}

18.Mybatis都有哪些Executor执行器？

Mybatis Executor类型

Mybatis有三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。

  • SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
  • ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。简言之，就是重复使用Statement对象。
  • BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。

Mybatis中如何指定使用哪一种Executor执行器？

  • 在Mybatis配置文件中，在设置（settings）可以指定默认的ExecutorType执行器类型，也可以手动给DefaultSqlSessionFactory的创建SqlSession的方法传递ExecutorType类型参数，如SqlSession openSession(ExecutorType execType)。
  • 配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。

插件

19.说说Mybatis的插件运行原理，如何编写一个插件？

插件的运行原理？

Mybatis会话的运行需要ParameterHandler、ResultSetHandler、StatementHandler、Executor这四大对象的配合，插件的原理就是在这四大对象调度的时候，插入一些我我们自己的代码。

MyBatis插件原理简图

Mybatis使用JDK的动态代理，为目标对象生成代理对象。它提供了一个工具类Plugin，实现了InvocationHandler接口。

Plugin中调用插件方法

使用Plugin生成代理对象，代理对象在调用方法的时候，就会进入invoke方法，在invoke方法中，如果存在签名的拦截方法，插件的intercept方法就会在这里被我们调用，然后就返回结果。如果不存在签名方法，那么将直接反射调用我们要执行的方法。

如何编写一个插件？

我们自己编写MyBatis 插件，只需要实现拦截器接口 Interceptor (org.apache.ibatis. plugin Interceptor ），在实现类中对拦截对象和方法进行处理。

  • 实现Mybatis的Interceptor接口并重写intercept()方法

    这里我们只是在目标对象执行目标方法的前后进行了打印；

  public class MyInterceptor implements Interceptor {
      Properties props=null;
  
      @Override
      public Object intercept(Invocation invocation) throws Throwable {
          System.out.println("before……");
          //如果当前代理的是一个非代理对象，那么就会调用真实拦截对象的方法
          // 如果不是它就会调用下个插件代理对象的invoke方法
          Object obj=invocation.proceed();
          System.out.println("after……");
          return obj;
      }
  }
  • 然后再给插件编写注解，确定要拦截的对象，要拦截的方法
@Intercepts({@Signature(
        type = Executor.class,  //确定要拦截的对象
        method = "update",        //确定要拦截的方法
        args = {MappedStatement.class,Object.class}   //拦截方法的参数
)})
public class MyInterceptor implements Interceptor {
    Properties props=null;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("before……");
        //如果当前代理的是一个非代理对象，那么就会调用真实拦截对象的方法
        // 如果不是它就会调用下个插件代理对象的invoke方法
        Object obj=invocation.proceed();
        System.out.println("after……");
        return obj;
    }
}
  • 最后，再MyBatis配置文件里面配置插件

   <plugins>
       <plugin interceptor="xxx.MyPlugin">
          <property name="dbType",value="mysql"/>
       </plugin>
   </plugins>

20.MyBatis是如何进行分页的？分页插件的原理是什么？

MyBatis是如何分页的？

MyBatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页。可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

分页插件的原理是什么？

  • 分页插件的基本原理是使用Mybatis提供的插件接口，实现自定义插件，拦截Executor的query方法
  • 在执行查询的时候，拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。
  • 举例：select * from student，拦截sql后重写为：select t.* from (select * from student) t limit 0, 10

可以看一下一个大概的MyBatis通用分页拦截器：

Mybatis-通用分页拦截器

作者：三分恶 (已获授权)

来源：https://mp.weixin.qq.com/s/O_5Id2o9IP4loPazJuiHng

最近建一些几十个工作内推群，各大城市都有，群里目前已经收集了很多内推岗位，大厂、中厂、小厂、外包都有。 欢迎HR、开发、测试、运维和产品加入。

内推群海报

扫描下方微信，备注：网站+所在城市，即可拉你进工作内推群。

微信二维码

一个可以快速提升Java技术的神奇网站
Copyright © 2026 Java突击队
推荐
★12 个企业级项目实战（可写进简历）
从业务设计到压测，一套打通：看得懂、抄得走、改得动
企业智能知识库100万QPS短链复杂商城系统RAGSaaS点餐（多租户）SpringCloud系统秒杀系统智能代码审查MCPAI Agent
JDK21 / Spring Boot 3
32库 × 256表（分库分表实战）
2.6 亿+/天写入（高并发链路）
源码 + 教程 + 答疑 + 简历包装
看完就知道怎么写进简历 →