Mybatis---学习过程---Mybatis架构原理之executor执行原理

最新推荐文章于 2023-09-02 20:06:24 发布
最新推荐文章于 2023-09-02 20:06:24 发布
阅读量126 收藏
点赞数
分类专栏： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39314972/article/details/107747022
版权

Mybatis—学习过程—Mybatis架构原理之executor执行原理

1.继续进行源码中selectList中的步骤，进入executor.query()

  1. 点击query方法，进入实现类BaseExecutor
        //此方法在SimpleExecutor的父类BaseExecutor中实现
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        //根据传入的参数动态获得SQL语句，最后返回用BoundSql对象表示
        BoundSql boundSql = ms.getBoundSql(parameter);
        //为本次查询创建缓存的Key
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        // 查询
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        // 判断执行器是否已经关闭，则抛出 ExecutorException 异常
        if (closed) {
            throw new ExecutorException("Executor was closed.");
        }
        // 清空本地缓存，如果 queryStack 为零，并且要求清空本地缓存。
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
            clearLocalCache();
        }
        List<E> list;
        try {
            // queryStack + 1
            queryStack++;
            // Mybatis的一级缓存默认开启，根据刚才创建的catchKey从一级缓存中，获取查询结果
            list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
            // 获取到，则进行处理
            if (list != null) {
                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            // 获得不到，则从数据库中查询
            } else {
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
            }
        } finally {
            // queryStack - 1
            queryStack--;
        }
        if (queryStack == 0) {
            // 执行延迟加载
            for (DeferredLoad deferredLoad : deferredLoads) {
                deferredLoad.load();
            }
            // issue #601
            // 清空 deferredLoads
            deferredLoads.clear();
            // 如果缓存级别是 LocalCacheScope.STATEMENT ，则进行清理
            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                // issue #482
                clearLocalCache();
            }
        }
        return list;
    }
  2. 点击queryFromDatabase进入方法，在一级缓存中没查到就到到数据库中查的方法
    // 从数据库中读取操作
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    // 在缓存中，添加占位对象。此处的占位符，和延迟加载有关，可见 `DeferredLoad#canLoad()` 方法
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
        // 执行读操作
        list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
        // 从缓存中，移除占位对象
        localCache.removeObject(key);
    }
    // 添加到缓存中
    localCache.putObject(key, list);
    // 暂时忽略，存储过程相关
    if (ms.getStatementType() == StatementType.CALLABLE) {
        localOutputParameterCache.putObject(key, parameter);
    }
    return list;
}
  3. 点击doQuery进入SimpleExecutor实现类中的doQuery方法,可以看到执行器最终是将查询的操作过程交给了StatementHandler对象来处理
    @Override
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
        Configuration configuration = ms.getConfiguration();
        // 传入参数创建StatementHanlder对象来执行查询
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
        // 创建jdbc中的statement对象
        stmt = prepareStatement(handler, ms.getStatementLog());
        // 执行 StatementHandler  ，进行读操作，到这一步的时候已经将查询任务交给StatementHandler了
        return handler.query(stmt, resultHandler);
    } finally {
        // 关闭 StatementHandler 对象
        closeStatement(stmt);
    }
}
  4. 点击prepareStatement
    // 初始化 StatementHandler 对象
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    // 获得 Connection 对象
    Connection connection = getConnection(statementLog);
    // 创建 Statement 或 PrepareStatement 预编译对象
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 设置 SQL 上的参数，例如 PrepareStatement 对象上的占位符
    handler.parameterize(stmt);
    //最终将预编译对象进行返回
    return stmt;
}

Mybatis架构原理之StatementHandler

1.StatementHandler主要完成两步

  1. 总结就是参数的传递和结果集的转化
    在这里插入图片描述

  2. 在SimpleExecutor实现类中的doQuery方法中

    1. 在执行return handler.query(stmt, resultHandler);这一步操作（进行读操作）之前的一行代码stmt = prepareStatement(handler, ms.getStatementLog());,执行了prepareStatement方法，这个方法中的handler.parameterize(stmt);这一步进行了参数设置

  3. 点击parameterize方法，进入PreparedStatementHandler的parameterize方法中

    @Override
public void parameterize(Statement statement) throws SQLException {
    //使用ParameterHandler对象来完成对Statement的设值，所以说真正设置参数的还是parameterHandler对象
    parameterHandler.setParameters((PreparedStatement) statement);
}

  4. 点击setParameters方法，进入到实现类中，同时也说明了ParametorHandler在设置参数的时候还要调用TypeHandler，TypeHandler设置了Java的类型和jdbc的数据类型转换,在代码的最后TypeHandler也设置了？占位符的参数

    @SuppressWarnings("Duplicates")
@Override
public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    // 遍历 ParameterMapping 数组
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
        for (int i = 0; i < parameterMappings.size(); i++) {
            // 获得 ParameterMapping 对象
            ParameterMapping parameterMapping = parameterMappings.get(i);
            if (parameterMapping.getMode() != ParameterMode.OUT) {
                // 获得值
                Object value;
                String propertyName = parameterMapping.getProperty();
                if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
                    value = boundSql.getAdditionalParameter(propertyName);
                } else if (parameterObject == null) {
                    value = null;
                } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                    value = parameterObject;
                } else {
                    MetaObject metaObject = configuration.newMetaObject(parameterObject);
                    value = metaObject.getValue(propertyName);
                }
                // 获得 typeHandler、jdbcType 属性
                TypeHandler typeHandler = parameterMapping.getTypeHandler();
                JdbcType jdbcType = parameterMapping.getJdbcType();
                if (value == null && jdbcType == null) {
                    jdbcType = configuration.getJdbcTypeForNull();
                }
                // 设置 ? 占位符的参数
                try {
                    typeHandler.setParameter(ps, i + 1, value, jdbcType);
                } catch (TypeException | SQLException e) {
                    throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                }
            }
        }
    }
}

  5. 设置参数结束之后可以继续回到SimpleExecutor中的doQuery方法

    1. 上一步结束了参数的设置，接下来就要进行真正的读操作了，执行return handler.query(stmt, resultHandler);这一步了
    2. 点击query方法，找到实现类PreparedStatementHandler中的query方法
      @Override
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        PreparedStatement ps = (PreparedStatement) statement;
        // 执行查询
        ps.execute();
        // 处理返回结果
        return resultSetHandler.handleResultSets(ps);
    }
    3. 查看handleResultSet中的handleResultSets是怎么执行的，点击handleResultSets，找到实现类
      //
    // HANDLE RESULT SETS
    //
    // 处理 {@link java.sql.ResultSet} 结果集
    @Override
    public List<Object> handleResultSets(Statement stmt) throws SQLException {
        ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

        // 多 ResultSet 的结果集合，每个 ResultSet 对应一个 Object 对象。而实际上，每个 Object 是 List<Object> 对象。
        // 在不考虑存储过程的多 ResultSet 的情况，普通的查询，实际就一个 ResultSet ，也就是说，multipleResults 最多就一个元素。
        final List<Object> multipleResults = new ArrayList<>();

        int resultSetCount = 0;
        // 获得首个 ResultSet 对象，并封装成 ResultSetWrapper 对象
        ResultSetWrapper rsw = getFirstResultSet(stmt);

        // 获得 ResultMap 数组
        // 在不考虑存储过程的多 ResultSet 的情况，普通的查询，实际就一个 ResultSet ，也就是说，resultMaps 就一个元素。
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        validateResultMapsCount(rsw, resultMapCount); // 校验
        while (rsw != null && resultMapCount > resultSetCount) {
            // 获得 ResultMap 对象
            ResultMap resultMap = resultMaps.get(resultSetCount);
            // 处理 ResultSet ，将结果添加到 multipleResults 中
            handleResultSet(rsw, resultMap, multipleResults, null);
            // 获得下一个 ResultSet 对象，并封装成 ResultSetWrapper 对象
            rsw = getNextResultSet(stmt);
            // 清理
            cleanUpAfterHandlingResultSet();
            // resultSetCount ++
            resultSetCount++;
        }

        // 因为 `mappedStatement.resultSets` 只在存储过程中使用，本系列暂时不考虑，忽略即可
        String[] resultSets = mappedStatement.getResultSets();
        if (resultSets != null) {
            while (rsw != null && resultSetCount < resultSets.length) {
                ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
                if (parentMapping != null) {
                    String nestedResultMapId = parentMapping.getNestedResultMapId();
                    ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
                    handleResultSet(rsw, resultMap, null, parentMapping);
                }
                rsw = getNextResultSet(stmt);
                cleanUpAfterHandlingResultSet();
                resultSetCount++;
            }
        }

        // 如果是 multipleResults 单元素，则取首元素返回
        return collapseSingleResultList(multipleResults);
    }
馒头太帅了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis BaseExecutor的query()方法
Bandeo的博客
02-18 1489
上一篇说到CachingExecutor的缓存管理，这一篇的话看下BaseExecutor的query()方法
mybatis CachingExecutor的query()方法
Bandeo的博客
02-18 800
org.apache.ibatis.executor.CachingExecutor#query() 先从MappedStatement中获取缓存对象（在xml文件中配置的cache的对象，这里即EhcacheCache类的对象） <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache> ...
MyBatis 核心配置综述之Executor
最新发布
白话机器学习
09-02 171
就是*insert、update、delete在语义上其实都是更新的意思，而查询在语义上仅仅只是表示的查询，那么我们来偷窥一下update方法的执行流程，与select的主要执行流程很相似，所以一次性贴出。: 可重用执行器，这里的重用指的是重复使用Statement，它会在内部使用一个Map把创建的Statement都缓存起来，每次执行SQL命令的时候，都会去判断是否存在基于该SQL的Statement对象，如果存在Statement对象并且。: 缓存执行器，先从缓存中查询结果，如果存在，就返回；
Mybatis 源码学习(二十) —— executor 包(三)
三岁丫的博客
08-27 295
MyBatis Executor、SimpleExecutor、ReuseExecutor、ClosedExecutor、CachingExecutor。 MyBatis 一级缓存和二级缓存。
mybatis源码解读(七)：Executor详解
qq_41063182的博客
07-03 1747
功能 在 mybatis 中执行一次查询时，有个非常重要的类就是 Executor，Executor 有些类似是mybatis心脏一样的作用，它负责这次执行操作的资源调度、流程执行等功能。这个类是由几个实现类的，在前边已经分析过，mybatis默认的策略是 SimpleExecutor ，它完全继承自 BaseExecutor，没有特殊的地方。 Execute所要完成的工作： 根据当前的配置的id找到MappedStatement，然后处理sqlSource拿到BoundSource()，在这里会顺便去检
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
2. **Executor**：执行器接口，包含SimpleExecutor、ReuseExecutor、BatchExecutor等不同类型的执行策略。 3. **AutoFillMetaObjectHandler**：负责实体字段的自动填充逻辑。 4. **GlobalConfig**：全局配置类，包含...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.zip）
02-07
MyBatis 是一款著名的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使你更好地专注于使用 SQL 来编写业务逻辑，而不需要...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.tar.gz）
02-07
源码中，你可以研究这些执行器的工作原理，以及它们在性能优化上的不同之处。 5. **ParameterHandler、ResultSetHandler 和 StatementHandler**：这三个处理器分别负责参数设置、结果集处理和预编译语句的处理。...
MyBatis-Simplified-Chinese.rar_ mybatis-3_Mybatis-spring_mybatis
09-20
3. Executor 执行器：负责执行 SQL 映射文件中的 SQL 语句。 4. ParameterHandler 参数处理器：处理输入参数，将 Java 对象转换为 SQL 执行所需的格式。 5. ResultHandler 结果处理器：处理 SQL 查询的结果，将结果...
mybatis-3.5.6.zip
10-18
8. **Executor执行器**：MyBatis提供多种Executor执行器，包括SimpleExecutor（简单执行器，每次都会开启一个新的Statement）、ReuseExecutor（复用执行器，会复用PreparedStatement）和BatchExecutor（批量执行器，...
MyBatis核心源码深度剖析核心执行器executor和缓存原理
赵广陆
05-19 429
目录1 JDBC回顾2 MyBatis的核心执行组件介绍2.1 SqlSession2.2 Executor2.3 StatementHandler3 Executor执行器分析3.1 JDBC中的执行器3.2 Mybatis执行器3.2.1 Executor接口3.2.2 BaseExecutor（基础执行器）3.2.3 SimpleExecutor（简单执行器）3.2.4 ReuseExecutor（可重用执行器）3.2.5 BatchExecutor（批处理执行器）3.2.6 CachingExecu
【Mybatis】BatchExecutor批量处理逻辑源码解析
11-22 1319
public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException { final Configuration configuration = ms.getConfiguration(); final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, Ro...
Mybatis Executor原理分析
Jaylon Wang的专栏
01-30 450
Executor是Mybatis里面重要的一个接口，是4大对象（Executor、StatementHandler、ParameterHandler、ResultSetHandler）中的一个，下面我们先来看看Executor的继承关系图： Mybatis默认启用了CachingExecutor，它是用来做二级缓存的，但是如果没有配置<cache />的话...
Mybits__Executor源码解析__创建策略__JDBC中Statement&&PrepareStatement批处理原理__BatchExecutor的批处理原理
qq_37432174的博客
07-27 393
建议结合我的Mybaits__Executor源码跟踪解析一起看 Mybatis对数据库的操作，都将委托给执行器Executor来完成，所以执行器Executor是相当重要的，在Mybatis中，SqlSession对数据库的操作，将委托给执行器Executor来完成，Executor由五个不同功能的Executor完成，分别为： 1.基类执行器BaseExecutor 2.简单执行器Simple...
Mybatis原理——执行原理详解
保暖透气大裤衩LeoLee的博客
03-24 2058
概述 JDBC的执行流程可以大致分为： 获得连接 预编译sql 设置参数 执行sql Mybatis执行原理大致分为： 动态代理MapperProxy sql会话Sqlsession 执行器Executor JDBC处理器StatementHandler 图中JDBC圈起来的部分就对应了sql具体的执行过程，属于Mybatis执行器范围内。本文主要针对sql会话与执行器来展开讨论。 Mybatis的执行过程 Mybatis使用门面模式提供了统一的门面接口API： 基本的AP.
Executor.query(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.sessi
你就像甜甜的益达
02-13 2087
在使用mybatis拦截器的时候报错. Executor.query(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler) 发现Executor导入的是util.curren...
Mybatis（八）：源码分析-Executor执行SQL脚本
weixin_40074110的博客
07-01 453
从上篇动态代理对象的方法都调用MapperMethod.execute()中可知，执行不同等SQL命令最终会使用数据库会话对象SqlSession来执行不同的SQL脚本，对应方法如下： INSERT：sqlSession.insert()； UPDATE：sqlSession.update(); DELETE：sqlSession.delete()； SELECT：sqlSession.select() / sqlSession.selectList() / sqlSession.selectCu.
【Mybatis源码分析】08-SimpleExecutor的query分析
通往神秘的道路的专栏
04-22 5210
上一篇分析到如果二级缓存没有命中，则会调用一个Executor(默认是SimpleExecutor)的query方法，SimpleExecutor继承了BaseExecutor，直接调用BaseExecutor的query方法。BaseExecutor有一个PerpetualCache实例localCache(一级缓存，因为生命周期和executor一样)用于缓存查询结果。public &lt;E...
Executor 拦截器高级教程 - QueryInterceptor 规范
偶尔记一下 - mybatis.io
12-31 6890
Executor 拦截器高级教程 - QueryInterceptor 规范这篇文档涉及下面几个方面 1. Executor query 方法介绍 2. 拦截器配置和调用顺序 3. 拦截 query 方法的技巧 4. 拦截 query 方法的规范 5. 如何配置不同的 Executor 插件1. Executor query 方法介绍在 MyBatis 的拦截器的文档部分，我们知道 Exe
如何把mybatis-plus执行过程sql打印出来
06-01
在 MyBatis-Plus 中，可以通过在 `application.yml` 或者 `application.properties` 文件中添加如下配置来打印 SQL 语句： ```yaml mybatis-plus: configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl ``` 其中，`log-impl` 指定了 MyBatis-Plus 使用的日志实现类，这里使用了 `org.apache.ibatis.logging.stdout.StdOutImpl`，表示将日志打印到控制台中。 如果想要打印完整的 SQL 语句和参数，可以在 `application.yml` 或者 `application.properties` 文件中添加如下配置： ```yaml logging: level: com.baomidou.mybatisplus.core.executor.BaseExecutor: debug ``` 其中，`com.baomidou.mybatisplus.core.executor.BaseExecutor` 表示 MyBatis-Plus 中执行 SQL 语句的基础执行器，`debug` 表示打印 debug 级别的日志，会打印完整的 SQL 语句和参数。 如果你使用的是其他日志框架，可以根据具体的框架配置方式进行相应的配置。 以上配置完成之后，重新启动应用程序，就能在控制台或者日志文件中看到 MyBatis-Plus 执行 SQL 语句的日志输出了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值