mybatis+mybatisplus源码学习（四）执行流程分析

最新推荐文章于 2024-05-29 16:16:20 发布
最新推荐文章于 2024-05-29 16:16:20 发布
阅读量332 收藏
点赞数
分类专栏： spring boot mybatis 文章标签： spring boot mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RenshenLi/article/details/118002802
版权

目录

前言

本文分析从SqlSessionInterceptor的invoke方法开始的执行流程。

一、SqlSession的获取

以selectList方法为例

（1）invoke( )方法中

SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);

（2）getSqlSession( )方法

 public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType,
      PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
    notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
	//从ThreadLocal里获取SqlSessionHolder 
    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
	//从SqlSessionHolder里获取SqlSession 
    SqlSession session = sessionHolder(executorType, holder);
    if (session != null) {
      return session;
    }

    LOGGER.debug(() -> "Creating a new SqlSession");
    //开启一个新的SqlSession 
    session = sessionFactory.openSession(executorType);
	//缓存SqlSession 到SqlSessionHolder、ThreadLocal
    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

    return session;
  }

（3）openSession( )

public SqlSession openSession(ExecutorType execType) {
    return openSessionFromDataSource(execType, null, false);
  }

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);
      //创建执行器
      final Executor executor = configuration.newExecutor(tx, execType);
      //创建默认的SqlSession 
      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();
    }
  }

（4）newExecutor( )方法

 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 MybatisBatchExecutor(this, transaction);
        } else if (ExecutorType.REUSE == executorType) {
            executor = new MybatisReuseExecutor(this, transaction);
        } else {
  			//普通执行器
            executor = new MybatisSimpleExecutor(this, transaction);
        }
        if (cacheEnabled) {
            executor = new MybatisCachingExecutor(executor);
        }
        //对Executor扩展的拦截器链
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
    }

二、SqlSession的调用

获取SqlSession之后，进入到DefaultSqlSession的selectList方法
（5）selectList( )

 public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      //获取MappedStatement 
      MappedStatement ms = configuration.getMappedStatement(statement);
      //执行查询
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

（6）query( )

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
	//获取BoundSql 
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

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());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      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--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

（7）queryFromDatabase( )

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    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;
  }

（8）doQuery( )

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();
            //创建StatementHandler
            StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            //prepareStatement
            stmt = prepareStatement(handler, ms.getStatementLog(), false);
            //query
            return stmt == null ? Collections.emptyList() : handler.query(stmt, resultHandler);
        } finally {
            closeStatement(stmt);
        }
    }

（9）newStatementHandler( )

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
	 //创建StatementHandler
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    //对StatementHandler进行扩展的拦截器链
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

（10）RoutingStatementHandler( )

 public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

    switch (ms.getStatementType()) {
      case STATEMENT:
        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case PREPARED:
      	//创建PreparedStatementHandler
        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case CALLABLE:
        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      default:
        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
    }

  }

（11）PreparedStatementHandler

public PreparedStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
  }

protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    this.configuration = mappedStatement.getConfiguration();
    this.executor = executor;
    this.mappedStatement = mappedStatement;
    this.rowBounds = rowBounds;

    this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
    this.objectFactory = configuration.getObjectFactory();

    if (boundSql == null) { // issue #435, get the key before calculating the statement
      generateKeys(parameterObject);
      boundSql = mappedStatement.getBoundSql(parameterObject);
    }

    this.boundSql = boundSql;
	//创建ParameterHandler
    this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
    //创建ResultSetHandler
    this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
  }

（12）newParameterHandler

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
	//创建ParameterHandler
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    //ParameterHandler扩展的拦截器链
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
  }

（13）newResultSetHandler

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
      ResultHandler resultHandler, BoundSql boundSql) {
    //创建ResultSetHandler
    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
    //ResultSetHandler扩展的拦截器链
    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
    return resultSetHandler;
  }

此时，创建好StatementHandler，回到第（8）步

（14）prepareStatement( )

 private Statement prepareStatement(StatementHandler handler, Log statementLog, boolean isCursor) throws SQLException {
        Statement stmt;
        //获取数据库连接
        Connection connection = getConnection(statementLog);
        //Statement prepare
        stmt = handler.prepare(connection, transaction.getTimeout());
        //游标不支持返回null.
        if (stmt == null && !isCursor) {
            return null;
        } else {
        	//处理参数
            handler.parameterize(stmt);
            return stmt;
        }
    }

（15）prepare( )

进入到RoutingStatementHandler的prepare( )

public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    return delegate.prepare(connection, transactionTimeout);
  }

再进入BaseStatementHandler的prepare( )

public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      statement = instantiateStatement(connection);
      setStatementTimeout(statement, transactionTimeout);
      setFetchSize(statement);
      return statement;
    } catch (SQLException e) {
      closeStatement(statement);
      throw e;
    } catch (Exception e) {
      closeStatement(statement);
      throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
    }
  }

（16）parameterize( )
对参数的处理，通过parameterHandler

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

通过TypeHandler来处理

public void setParameters(PreparedStatement ps) {
        ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings != null) {
            for (int i = 0; i < parameterMappings.size(); i++) {
                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 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);
                    }
                }
            }
        }
    }

此时，执行完prepareStatement，回到第（8）步
（17）query( )

RoutingStatementHandler

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    return delegate.query(statement, resultHandler);
  }

PreparedStatementHandler

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    //执行查询
    ps.execute();
    //处理结果
    return resultSetHandler.handleResultSets(ps);
  }
_lrs
关注
专栏目录
Mybatis plus 大致执行
weixin_55583216的博客
02-14 168
Mybatis plus 大致执行
ShardingJdbc、Spring和mybatis结合的整个源码执行流程解析
betterMan的专栏
11-08 2509
#一.背景知识 ###1.Sharding jdbc 当当提供的轻量级java框架，通过客户端进行分库分表策略执行等操作，直连到数据库 http://shardingsphere.io/document/current/cn/overview/ ###2.Spring 项目给于spring提供的事务管理和springBoot带来的快速启动 ###3.Mybatis和Mybatis-Spring 使...
mybatisplus入门源码
09-28
SpringBoot整合mybatisPlus入门程序源代码，代码中详细介绍了怎么从一个空白的SpringBoot框架整合mybatisPlus的过程，配套教程在本人博客中
Mybatis-plus 源码执行全流程解析
nandao158的博客
12-09 3724
Mybatis-plus 源码执行全流程解析
MyBatis源码阅读——通过debug解析MyBatis运行流程
热门推荐
yyf的博客
06-07 1万+
最近在阅读MyBatis框架的源码。发现它其实是一个非常值得阅读的框架。它灵活得运用了常见的设计模式去设计。值得我们去学习。我还是比较喜欢以debug阅读MyBatis的源码。
MyBatis-plus使用步骤
weixin_60457220的博客
07-05 160
MyBatis-plus使用步骤
idea+springboot+mybatis+jsp+bootstrap实现从mysql查询出数据并显示(源码)
01-25
标题 "idea+springboot+mybatis+jsp+bootstrap实现从mysql查询出数据并显示(源码)" 描述了一个使用特定技术栈开发的Web应用程序。这个项目整合了IntelliJ IDEA作为开发环境，Spring Boot作为核心框架，MyBatis作为...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
SpringBoot 是一个流行的Java开发框架，它简化了创建独立、生产级别的基于Spring的应用程序的流程。Redis 是一个高性能的键值数据库，常被用于构建高速缓存系统，提高应用程序的性能。MyBatis 是一个优秀的持久层...
mybatis源码学习之mybatis执行流程分析
wsb_2526的博客
06-04 624
2、parse方法则是调用了XPath对象的evalNode方法对配置文件中的configuration节点进行解析，会把节点内容放在XNode对象中然后返回；3、parseConfiguration方法会对configuration节点解析出来的内容再进行解析，会把解析出来的内容放在configuration对象中；
mybatis源码学习篇之——执行流程分析
congge
11-29 784
前言 在正式学习mybatis框架源码之前，需要先弄懂几个问题？myabtis框架是什么？为什么需要mybatis框架？使用mybatis框架带来的好处是什么？ 回答这几个问题之前，我们先来看一下，之前在没有框架的时候，假如使用jdbc的方式进行开发，会怎样呢？下面来看一段使用jdbc的方式查询数据库的代码吧 public class TestJdbc { public static void main(String[] args) { Connection connection
【MyBatis-Plus 源码分析】核心组件、工作流程、SQL执行过程、源码分析
最新发布
好好学习日记
05-29 1795
MyBatis-Plus 是一个增强版的 MyBatis 框架，它在 MyBatis 的基础上增加了许多实用的功能，例如乐观锁插件、字段自动填充、分页插件、条件构造器和 SQL 注入器等。MyBatis-Plus 允许开发者无需编写 XML 文件，直接通过继承 BaseMapper 接口的类来完成数据库操作。MyBatis-Plus 作为 MyBatis 的增强框架，其工作流程在继承 MyBatis 的基础上进行了优化和扩展。继承 BaseMapper。
mybatis的执行流程解析
scryihao的博客
08-09 133
分为几个大模块 1.配置文件解析 2.会话创建 3.方法执行 一.配置文件解析 mybatis-config.xml <configuration> <properties/> <settting/> <typeHandlers/> <..../> <mappers/> </configuration> mybatis-mapper.xml <mapper > <cache/&g
MyBatisPlus使用流程
禾日香的博客
05-22 696
版本号根据需要选取。
MyBatis执行流程
daitianze的博客
04-28 217
通过DefaultSqlSession执行查询的时候例如调用org.apache.ibatis.session.defaults.DefaultSqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds) 方法。1、首选是org.apache.ibatis.session.SqlSessionFactory调用。然后调用SimpleExecutor中的doQuery方法。
Mybatis底层源码执行流程详解
LiuY521的博客
05-15 1133
Mybatis底层源码执行流程详解 目录 Mybatis底层源码执行流程详解 Mybatis底层源码执行流程详解 2.重点解析UserMapper userMapper=sqlSession.getMapper(UserMapper.class)...
MyBatis Plus详细教程
m0_67402235的博客
07-29 1619
为什么要学MybatisPlus？MybatisPlus可以节省大量时间，所有的CRUD代码都可以自动化完成MyBatis-Plus是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。特性无侵入只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作强大的CRUD操作支持Lambda形式调用通过Lambda表达式，方便的编写各类查询条件，无需再担心字段写错。...
mybatis源码分析（六）：执行流程
lxlneversettle的博客
03-15 144
Mapper方法执行流程 在不结合spring的时候，一般都会通过类似如下的方式来执行Mapper的指定方法 try (Reader reader = Resources.getResourceAsReader("org/apache/ibatis/submitted/collectionparameters/mybatis-config.xml")) { sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); SqlSessi
mybatis-plus基本使用流程以及进阶操作
zxyOVO的博客
05-15 1634
就是对于表有哪些操作。
mybatis的执行流程
F_lame的博客
01-26 570
mybatis的查询逻辑
mybatis-plus 实践及架构原理
12-25
mybatis-plus 实践及架构原理，mybatis-plus 实践及架构原理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_lrs

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值