MyBatis源码阅读「执行」SqlSession执行主流程


一、相关类与接口

MyBatis源码阅读「执行」SqlSession执行主流程

image

二、流程图

MyBatis源码阅读「执行」SqlSession执行主流程

image

三、流程分析

   @Override
    public  List selectList(String statement, Object parameter, RowBounds rowBounds) {
        try {
            // 根据传入的statementId，获取MappedStatement对象
            MappedStatement ms = configuration.getMappedStatement(statement);
            // 调用执行器的查询方法
            // RowBounds是用来逻辑分页（按照条件将数据从数据库查询到内存中，在内存中进行分页）
            // wrapCollection(parameter)是用来装饰集合或者数组参数
            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();
        }
    }


  //第一步
  @Override
  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 获取绑定的SQL语句，比如“SELECT * FROM user WHERE id = ? ” 
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    // 生成缓存Key
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);

    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  //第二步
  @Override
  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    // 获取二级缓存
    Cache cache = ms.getCache();
    if (cache != null) {
      // 当为select语句时，flushCache默认为false，表示任何时候语句被调用，都不会去清空本地缓存和二级缓存
      // 当为insert、update、delete语句时,useCache默认为true，表示会将本条语句的结果进行二级缓存
      // 刷新二级缓存 （存在缓存且flushCache为true时）
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        // 从二级缓存中查询数据
        @SuppressWarnings("unchecked")
        List list = (List) tcm.getObject(cache, key);
        // 如果二级缓存中没有查询到数据，则查询数据库
        if (list == null) {
          // 委托给BaseExecutor执行
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    // 委托给BaseExecutor执行
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }


@Override
  public  List 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 list;
    try {
      queryStack++;
      // 从一级缓存中获取数据
      list = resultHandler == null ? (List) 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;
  }


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


    @Override
    public  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,
            BoundSql boundSql) throws SQLException {
        Statement stmt = null;
        try {
            // 获取Configuration对象
            Configuration configuration = ms.getConfiguration();
            // 创建RoutingStatementHandler，用来处理Statement
            // RoutingStatementHandler类中初始化delegate类（SimpleStatementHandler、PreparedStatementHandler）
            StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds,
                    resultHandler, boundSql);
            // 子流程1：设置参数
            stmt = prepareStatement(handler, ms.getStatementLog());
            // 子流程2：执行SQL语句（已经设置过参数），并且映射结果集
            return handler.query(stmt, resultHandler);
        } finally {
            closeStatement(stmt);
        }
    }


public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,
            Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        // 创建路由功能的StatementHandler，根据MappedStatement中的StatementType
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject,
                rowBounds, resultHandler, boundSql);
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
        return statementHandler;
    }


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:
        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());
    }

  }


    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Statement stmt;
        // 获取连接
        Connection connection = getConnection(statementLog);
        // 创建Statement（PreparedStatement、Statement、CallableStatement）
        stmt = handler.prepare(connection, transaction.getTimeout());
        // SQL参数设置
        handler.parameterize(stmt);
        return stmt;
    }


protected Connection getConnection(Log statementLog) throws SQLException {
    Connection connection = transaction.getConnection();
    if (statementLog.isDebugEnabled()) {
      return ConnectionLogger.newInstance(connection, statementLog, queryStack);
    } else {
      return connection;
    }
  }


 @Override
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      // 实例化Statement，比如PreparedStatement
      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);
    }
  }


@Override
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    // 获取带有占位符的SQL语句
    String sql = boundSql.getSql();
    // 处理带有主键返回的SQL
    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
      String[] keyColumnNames = mappedStatement.getKeyColumns();
      if (keyColumnNames == null) {
        return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
      } else {
        return connection.prepareStatement(sql, keyColumnNames);
      }
    } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
      return connection.prepareStatement(sql);
    } else {
      return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    }
  }


@Override
  public void parameterize(Statement statement) throws SQLException {
    // 通过ParameterHandler处理参数
    parameterHandler.setParameters((PreparedStatement) statement);
  }


@Override
  public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    // 执行PreparedStatement，也就是执行SQL语句
    ps.execute();
    // 处理结果集
    return resultSetHandler.handleResultSets(ps);
  }


@Override
    public List handleResultSets(Statement stmt) throws SQLException {
        ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

        // 标签的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++;
            }
        }

        // 如果只有一个结果集合，则直接从多结果集中取出第一个
        return collapseSingleResultList(multipleResults);
    }


四、总结
执行sqlsession：参数有两个（statementId和参数对象）
  1. 根据statementId，去Configuration中的MappedStatement集合中查找
    对应的MappedStatement对象；
  2. 取出MappedStatement中的SQL信息；
  3. 取出MappedStatement中的statementType，用来创建Statement对象；
  4. 取出MappedStatement中的Configuration对象，通过Configuration对象，获取DataSource对象，通过DataSource对象，创建Connection，通过Connection创建Statement对象。
  5. 设置参数
  6. 执行Statement
  7. 处理结果集






展开阅读全文



页面更新：2024-05-12



标签：逗号   缓存   分解   语句   二级缓存   源码   实例   属性   接口   流程   对象   内存   主流   参数   标签   数据   科技   信息





1
2
3
4
5







	

		

		
		

		

			

			
MyBatis源码阅读 SqlSource创建流程

			

			

			 一、相关类及对象XMLLanguageDriverXMLScriptBuilderSqlSource接口SqlSourceBuilderDynamicSqlSource主要是封装动态SQL标签解析之后的SQL语句和带有${}的SQL语句RawSqlSource主要封装带有#{}的SQL语句StaticSqlSour
			

		

	

	

		

		
		

		

			

			
Spark Core源码精读：与存储相关的内存池及内存管理器的具体实现

			

			

			 前言我们用两篇文章的时间搞清楚了Spark存储中的“块”到底是怎么一回事，接下来我们就可以放心来看Spark Core存储子系统的细节了。前面已经提到过，Spark会同时利用内存和外存，尤其是积极地利用内存作为存储媒介。这点
			

		

	

	

		

		
		

		

			

			
Flink源码阅读——Flink 内存模型

			

			

			 本篇文章主要介绍下FLink的内存模型，在介绍Flink内存模型之前，我们首先学习下JVM内存结构1. JVM内存结构Java7 升级为 Java8的时候，JVM内存结构发生了改变，咱们看下区别是什么。这部分内容原文 Java8 JVM内存结构1.1 Jav
			

		

	

	

		

		
		

		

			

			
Apache Spark 内存管理详解

			

			

			 Spark 作为一个基于内存的分布式计算引擎，其内存管理模块在整个系统中扮演着非常重要的角色。理解 Spark 内存管理的基本原理，有助于更好地开发 Spark 应用程序和进行性能调优。本文旨在梳理出 Spark 内存管理的脉络，抛
			

		

	

	

		

		
		

		

			

			
如何利用好Redis、Redisson使用实现分布式锁？

			

			

			 前言1.为什么要使用分布式锁使用分布式锁的目的，无外乎就是保证同一时间只有一个客户端可以对共享资源进行操作。1.1举一个很长的例子系统 A 是一个电商系统，目前是一台机器部署，系统中有一个用户下订单的接口，但是用户
			

		

	

	

		

		
		

		

			

			
Spark的两种内存管理机制：静态内存管理与统一内存管理

			

			

			 在利用Spark开发各类计算任务时，Executor内存的配置永远是重中之重，因此了解Spark的内存管理机制是非常有益的。 在1.6版本之前，Spark只有一种内存管理机制，即静态内存管理（StaticMemoryManager），1.6版本以后又引入了新的统
			

		

	

	

		

		
		

		

			

			
Flink源码阅读——Calcite 语法拓展

			

			

			 Calcite主要是做SQL解析、校验、优化等工作，比如Flink、Hive底层都是使用的calcite。本文内容是基于Flink 1.12来讲解。首先从整体上对Calcite使用做个了解，Calcite 使用 javacc作为语法解析器，并且使用freemarker作为
			

		

	

	

		

		
		

		

			

			
使用Python+Scrapy爬取并保存QQ群空间帖子

			

			

			 首先声明，在Python和爬虫这方面，我是业余的那一卦，只是平时玩一玩，不能当真的，请各位大佬轻拍。虽然爬虫与传统意义上的大数据技术不属于同一类，但大概也只能放在大数据分类下面了。 今天接到了 @小阿妩 的一个需求（她是做
			

		

	

	

		

		
		

		

			

			
结合JVM深入理解Java字符串

			

			

			 既然题目里就提到了JVM，那么首先必然要奉上两张图。imageimageHotSpot JVM内存模型已经是老生常谈的知识了，所以这里也就不再赘述。直接说String。 在String类的JavaDoc开头，就有这样一句话：Strings are constant; their
			

		

	

	

		

		
		

		

			

			
SimpleDateFormat线程不安全问题与ThreadLocal原理

			

			

			 SimpleDateFormat是JDK中长久以来自带的日期时间格式化类，但是它有线程安全性方面的问题，使用时要避免它带来的影响。SimpleDateFormat是线程不安全的写一个SimpleDateFormat在并发环境下简单的例子先。public class S
			

		

	

	

		

		
		

		

			

			
Flink SQL w/ Blink Planner执行流程解析（上篇）

			

			

			 Foreword大数据领域SQL化的风潮方兴未艾（所谓"Everybody knows SQL"），Flink自然也不能“免俗”。Flink SQL是Flink系统内部最高级别的API，也是流批一体思想的集大成者。用户可以通过简单明了的SQL语句像查表一样执行流任
			

		

	

	

		

		
		

		

			

			
设计HBase RowKey需要注意的二三事

			

			

			在HBase中，定位一条数据（即一个Cell）需要4个维度的限定：行键（RowKey）、列族（Column Family）、列限定符（Column Qualifier）、时间戳（Timestamp）。其中，RowKey是最容易出现问题的。除了根据业务和查询需求来设计之外，还需要注意以下三
			

		

	

	

		

		
		

		

			

			
Flink源码阅读- Flink 内存模型

			

			

			 本篇文章主要介绍下FLink的内存模型，在介绍Flink内存模型之前，我们首先学习下JVM内存结构1. JVM内存结构Java7 升级为 Java8的时候，JVM内存结构发生了改变，咱们看下区别是什么。这部分内容原文 Java8 JVM内存结构1.1 Jav
			

		

	

	

		

		
		

		

			

			
Hive/HiveQL常用优化方法全面总结（下篇）

			

			

			 优化SQL处理join数据倾斜上篇已经多次提到了数据倾斜，包括已经写过的sort by代替order by，以及group by代替distinct方法，本质上也是为了解决它。join操作更是数据倾斜的重灾区，需要多加注意。空值或无意义值这种情况很
			

		

	

	

		

		
		

		

			

			
基于Kafka+Flink+Redis的电商大屏实时计算案例

			

			

			 前言一年一度的双11又要到了，阿里的双11销量大屏可以说是一道特殊的风景线。实时大屏（real-time dashboard）正在被越来越多的企业采用，用来及时呈现关键的数据指标。并且在实际操作中，肯定也不会仅仅计算一两个维度。由于
			

		

	


上滑加载更多 ↓






	

	
推荐阅读：


	

		

		
		

		

			

			
MyBatis源码阅读 SqlSource创建流程

			

		

	


	

		

		
		

		

			

			
Spark Core源码精读：与存储相关的内存池及内存管理器的

			

		

	


	

		

		
		

		

			

			
Flink源码阅读——Flink 内存模型

			

		

	


	

		

		
		

		

			

			
Apache Spark 内存管理详解

			

		

	


	

		

		
		

		

			

			
Spark的两种内存管理机制：静态内存管理与统一内存管理

			

		

	


	

		

		
		

		

			

			
Flink源码阅读——Calcite 语法拓展

			

		

	


	

		

		
		

		

			

			
Flink SQL w/ Blink Planner执行流程解析（上篇）

			

		

	


	

		

		
		

		

			

			
Flink源码阅读- Flink 内存模型

			

		

	


	

		

		
		

		

			

			
Flink源码阅读（七）- Calcite 语法拓展

			

		

	


	

		

		
		

		

			

			
Java对象都是在堆上分配内存吗？

			

		

	


	

	

	
友情链接：

	

		
	

	



	
更多：

	

		
本站资料均由网友自行发布提供，仅用于学习交流。如有版权问题，请与我联系，QQ：4156828  

		
© CopyRight 2020-2024 All Rights Reserved. Powered By 71396.com  闽ICP备11008920号-4
闽公网安备35020302034903号

	



	




Top