Mybatis源码之Sql执行

最新推荐文章于 2024-08-21 23:39:15 发布
最新推荐文章于 2024-08-21 23:39:15 发布
阅读量115 收藏
点赞数
分类专栏： mybatis 文章标签： mybatis

原文地址 https://www.jianshu.com/p/937a797d5d11

获取 SqlSession

mapper 解析完毕后，整个 configuration 就算解析完成，根据 sqlSessionFactory 获取 session，然后获取 mapper 执行 sql

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();

openSession() 方法调用重载方法

//DefaultSqlSessionFactory
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  Transaction tx = null;
  try {
    final Environment environment = configuration.getEnvironment();
      // JdbcTransactionFactory
    final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // JdbcTransaction
    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      // CachingExecutor、
    final Executor executor = configuration.newExecutor(tx, execType);
    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();
  }
}

返回创建 DefaultSqlSession

获取 Mapper

BlogDao blogDao = sqlSession.getMapper(BlogDao.class);

从已解析的结果集合中取出对应的 MapperProxyFactory，创建相应的代理

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

通过 mapperProxyFactory 来创建 MapperProxy 代理类，代码如下

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

MapperProxy 实现了 InvocationHandler 接口，也就是说获取的 Mapper 对象方法调用最后会调用 MapperProxy.invoke()

执行 SQL

调用 MapperProxy.invoke() 方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    } else if (isDefaultMethod(method)) {
      return invokeDefaultMethod(proxy, method, args);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
  final MapperMethod mapperMethod = cachedMapperMethod(method);
  return mapperMethod.execute(sqlSession, args);
}

如果是 Object 类的方法或者 default 方法直接执行，其它方法 执行 mapperMethod.execute()，execute 方法根据类型执行相应的语句

  1. INSERT -> sqlSession.insert
  2. UPDATE -> sqlSession.update
  3. DELETE-> sqlSession.delete
  4. SELECT-> sqlSession.select*
  5. FLUSH-> sqlSession.flushStatements

select 方法 有多种，需要进行结果集映射，以 executeForMany(sqlSession, args) 为例来看，方法会调用 sqlSession.selectList()

// DefaultSqlSession.selectList
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    MappedStatement ms = configuration.getMappedStatement(statement);
    return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
}

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

boundSql 中包含之中要执行的 sql，getBoundSql 方法会通过 SqlSource 来获取 ，这里的 sqlSource 为之前解析的，存在两种：DynamicSqlSource，RawSqlSource。

  1. RawSqlSource 相比 DynamicSqlSource 就简单多了，在创建 RawSqlSource 时直接就将 sql 解析了，直接获取即可。
  2. 动态 sql 会在执行时解析并转化为静态 sql

调用 query 方法，这里调用的虽然是 CachingExecutor 类，但最后会委派给 SimpleExecutor 调用，调用会访问 cache，并把结果放在 cache 中

@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();
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 这里才开始获取连接
    stmt = prepareStatement(handler, ms.getStatementLog());
    return handler.<E>query(stmt, resultHandler);
  } finally {
    closeStatement(stmt);
  }
}

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
String sql = boundSql.getSql();
statement.execute(sql);
return resultSetHandler.<E>handleResultSets(statement);
}

结果映射

在处理结果集行值时分为两部分，处理简单 resultMap 对应的行值和处理嵌套 resultMap 对应的行值，是否嵌套映射在解析 mapper resultMap 的时候已经解释过了，这里不再重复。处理简单 resultMap 对应的行值稍微简单些，先看简单的映射

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
    throws SQLException {
  DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
    //处理分页，跳过指定的行，如果rs类型不是TYPE_FORWARD_ONLY，直接absolute，否则的话循环rs.next
  skipRows(rsw.getResultSet(), rowBounds);
  while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
    ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
      //处理行值，重点分析
    Object rowValue = getRowValue(rsw, discriminatedResultMap);
      //保存对象，通过list保存生成的对象Object
    storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
  }
} 


private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
  final ResultLoaderMap lazyLoader = new ResultLoaderMap();
  Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
  if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
    final MetaObject metaObject = configuration.newMetaObject(rowValue);
    boolean foundValues = this.useConstructorMappings;
    if (shouldApplyAutomaticMappings(resultMap, false)) {
      foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
    }
    foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
    foundValues = lazyLoader.size() > 0 || foundValues;
    rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
  }
  return rowValue;
}

获取行值主要包含如下 3 个步骤：

  1. createResultObject() 方法创建结果集对象
    根据 resultType，通过 ObjectFactory.create 来创建对象，其实现原理还是通过反射来创建对象。在创建对象时如果 resultMap 未配置 constructor，通过默认构造方法来创建对象，否则通过有参的构造方法来创建对象

  2. 自动映射属性
    applyAutomaticMappings()，如果 ResultMap 配置了 autoMapping=“true”，或者 AutoMappingBehavior 为 PARTIAL 会自动映射在 resultSet 查询列中存在但是未在 resultMap 中配置的列。

  3. 人工映射属性
    映射在 resultMap 中配置的列，主要包括两步：获取属性的值和设置属性的值。

    //获取属性的值
Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);
//设置属性的值,通过反射来设置
metaObject.setValue(property, value);

    private Object getPropertyMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix)
    throws SQLException {
    //获取嵌套查询对应的属性值，最终还是通过Executor.query来获取属性值
  if (propertyMapping.getNestedQueryId() != null) {
    return getNestedQueryMappingValue(rs, metaResultObject, propertyMapping, lazyLoader, columnPrefix);
  } else if (propertyMapping.getResultSet() != null) {
    addPendingChildRelation(rs, metaResultObject, propertyMapping);   // TODO is that OK?
    return DEFERED;
  } else {
    final TypeHandler<?> typeHandler = propertyMapping.getTypeHandler();
    final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
      //通过typeHandler来获取属性的值，如StringTypeHandler获取属性值：rs.getString(columnName)
    return typeHandler.getResult(rs, column);
  }
}

嵌套映射

嵌套 resultMap 主要用来处理 collection，association 属性

<resultMap id="detailedBlogResultMap" type="Blog">
    <result property="id" column="id"/>
    <result property="title" column="title"/>
    <result property="content" column="content"/>

    <association property="author" javaType="com.zero.mybatis.bean.Author">
        <id property="id" column="author"/>
        <id property="name" column="name"/>
        <id property="age" column="age"/>
    </association>
</resultMap>

<!--alias Blog-->
<select id="selectBlog" resultMap="detailedBlogResultMap">
    select * from blog join author on blog.author = author.id where blog.id = 1;
</select>

Blog 有一个 author 属性，代表 Author 的 id

处理嵌套映射主要包括如下几个步骤：

  1. skipRows(rsw.getResultSet(), rowBounds); 同简单映射
  2. createRowKey，根据 resultMap 下的列创建 rowKey，很有用。在如上 liveCourseMap 配置中，mybatis 将会根据 id 列和 course_name 列的值来创建 rowKey
  3. getRowValue

在 handleRowValues() 方法中，if 条件成立进入 handleRowValuesForNestedResultMap() 方法

public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
  if (resultMap.hasNestedResultMaps()) {
    ensureNoRowBounds();
    checkResultHandler();
    handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
  } else {
    handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
  }
}
private void handleRowValuesForNestedResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    final DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
    skipRows(rsw.getResultSet(), rowBounds);
    Object rowValue = previousRowValue;
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
      final ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
        //创建rowKey，根据rowKey判断对象创建没创建
      final CacheKey rowKey = createRowKey(discriminatedResultMap, rsw, null);
        //已经创建的对象会保存到nestedResultObjects
      Object partialObject = nestedResultObjects.get(rowKey);
      // issue #577 && #542
      if (mappedStatement.isResultOrdered()) {
        if (partialObject == null && rowValue != null) {
          nestedResultObjects.clear();
          storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
        }
        rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
      } else {
        rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
        if (partialObject == null) {
          storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
        }
      }
    }
    if (rowValue != null && mappedStatement.isResultOrdered() && shouldProcessMoreRows(resultContext, rowBounds)) {
      storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
      previousRowValue = null;
    } else if (rowValue != null) {
      previousRowValue = rowValue;
    }
  }

getRowValue() 方法

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, CacheKey combinedKey, String columnPrefix, Object partialObject) throws SQLException {
  final String resultMapId = resultMap.getId();
  Object rowValue = partialObject;
  if (rowValue != null) {
    final MetaObject metaObject = configuration.newMetaObject(rowValue);
    putAncestor(rowValue, resultMapId);
    applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, false);
    ancestorObjects.remove(resultMapId);
  } else {
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
      // 创建外部对象
    rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      boolean foundValues = this.useConstructorMappings;
      if (shouldApplyAutomaticMappings(resultMap, true)) {
          //自动映射
        foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
      }
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
      putAncestor(rowValue, resultMapId);
        //嵌套映射
      foundValues = applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, true) || foundValues;
      ancestorObjects.remove(resultMapId);
      foundValues = lazyLoader.size() > 0 || foundValues;
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    if (combinedKey != CacheKey.NULL_CACHE_KEY) {
      nestedResultObjects.put(combinedKey, rowValue);
    }
  }
  return rowValue;
}
阿沐叨叨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis源码解析之SQL语句执行源码
ccccc202的博客
09-13 383
Mybatis源码解析之DefaultSqlSession#getMapper 上面我们探讨过获取mapper的过程,获取到mapper之后是怎么执行sql语句的呢? 我们一起看下这个MapperProxy#invoke(): @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { //如果是Object,就执行执行(Object的方法toS
Mybatis源码--Sql执行分析
ONROAD0612的博客
10-31 460
1 概述 前面我们分析了一些Sql解析过程中的一些重要类（Executor、StatementHandler等）的源码，现在就需要对将这些类串起来的流程进行一个详细的分析，所以我们现在来分析一下Mybatis中Sql执行的流程。 2 流程图 从流程图我们大致将Sql执行分成四步，针对第一步在前面的文章中我们已经有过分析，所以现在我们就对后面三步进行深入分析。 3 流程分析 在这里我们...
Mybatis源码-SQL的执行过程
R_TJW的博客
05-13 179
以mybatis:3.4.2源码为例 参考文章 1.1 SQL 执行入口 XxxMapper xxxMapper = session.getMapper(XXXMapper.class); XxxObject xxxObject= xxxMapper.sqlMethod(args); 1.1.1 为Mapper接口创建代理对象 public class MapperRegistry { private final Configuration config; private final Map
Mybatis执行sql过程源码解读
m0_58283099的博客
02-08 260
1.SqlSession.openSession()创建了Executor对象（真正的sql执行者），这个对象有两大类普通Executor和CacheExecutor(实现二级缓存),BaseExecutor实现一级缓存。如果配置了插件，在创建Executor的过程中会创建Executor的代理。
Mybatis源码分析-Mybatis是如何执行sql的
qq_40748336的博客
05-01 1923
Mybatis源码分析-Mybatis是如何执行sql的
mybatis 源码分析之执行sql
攻防人生3722的博客
03-20 172
mabatis 如何解析mapper.xml文件里的if等标签，生成执行语句？设置参数？ 下面通过跟踪源码我们来查看下具体是如何执行。 这里我们可以看到我们的mapper接口是通过MapperProxy 生成的代理对象进行调用的。即诸如的是一个动态代理对象。 public class MapperProxy<T> implements InvocationHandle...
(四) mybatis 源码之 SQL 执行
Gp_2512212842的博客
07-29 258
执行 SQL 使用 SqlSession 提供的 API 也能执行 SQL 语句, 不过这种方使用的少, 还是习惯使用接口的方式 直接调用 SqlSession 的 getMapper 方法就可以为接口实现代理, 所以方法执行前会被拦截, 交给 MapperProxy 拦截, 它实现了 InterceptorHandler 接口 // 得到 MapperMethodInvoker 对象, 调用其 invoke 方法 // 最后交给 MapperMethod 执行, 查看他的 executor 方法 pub
mybatis直接执行sql语句后续之一
04-18
在IT行业中，MyBatis是一个广泛使用的持久层框架，它允许开发者直接编写SQL语句，提供了灵活的数据访问和映射机制。这篇博客“mybatis直接...对于那些想要深入理解MyBatis源码的开发者，这个系列可能会提供宝贵的见解。
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
MyBatis 源码解析：通过源码深入理解 SQL 的执行过程 - GitChat
05-13
MyBatis 源码解析：通过源码深入理解 SQL 的执行过程 抓下来打包成了HTML文件, 方便离线观看
5套完整springboot+mybatis源码下载只供学习之用.rar
08-21
通过学习这些源码，你可以深入理解SpringBoot如何启动、如何配置自动装配，以及MyBatis如何与数据库交互。同时，Shiro的使用也能帮助你掌握用户权限的控制。对于初学者，这是一个很好的实践平台，对于有经验的开发者...
mybatis源码，SQL是如何执行的
weixin_44887276的博客
05-20 611
mybatis源码
【项目实战】MyBatis的基础源码 —— MyBatis Executor 执行器（执行SQL语句的核心组件）源码
本本本添哥
04-17 192
MyBatis执行器是什么？它是负责执行SQL语句的核心组件之一。
MyBatis 源码分析 - SQL 的执行过程
攻城狮不是猫
04-17 1282
在前面的文章中，我分析了配置文件和映射文件的解析过程。经过前面复杂的解析过程后，现在，MyBatis 已经进入了就绪状态，等待使用者发号施令。本篇文章我将分析MyBatis 执行 SQL 的过程，该过程比较复杂，涉及的技术点很多。为 mapper 接口生成实现类根据配置信息生成 SQL，并将运行时参数设置到 SQL 中一二级缓存的实现插件机制数据库连接的获取与管理查询结果的处理，以及延迟加载等如果大家能掌握上面的技术点，那么对 MyBatis 的原理将会有很深入的理解。
MyBatis核心源码深度剖析SQL执行过程
赵广陆
05-20 463
目录1 SQL语句的执行过程介绍2 SQL执行的入口分析2.1 为Mapper接口创建代理对象2.2 执行代理逻辑3 查询语句的执行过程分析3.1 selectOne方法分析3.2 sql获取3.3 参数设置3.4 SQL执行和结果集的封装4 更新语句的执行过程分析4.1 sqlsession增删改方法分析4.2 sql获取4.3 参数设置4.4 SQL执行5 小结 1 SQL语句的执行过程介绍 MyBatis核心执行组件： 2 SQL执行的入口分析 2.1 为Mapper接口创建代理对象 // 方式1：
mybatis中ResultSetHandler的设计与实现
多看多听多总结
09-22 1385
ResultSetHandler主要处理statement,cursor,callstatement三种类型的结果集，其接口定义如下： public interface ResultSetHandler { <E> List<E> handleResultSets(Statement stmt) throws SQLException; <E> Cursor<E> handleCursorResultSets(Statement stmt) t
mybatis源码篇（五）—— mybatis创建代理mapper及映射查询结果
zhoushimiao1990的博客
09-06 879
mybatis创建mapper接口的代理对象来执行sql，并且将查询结果与设置的返回值类型进行匹配。 首先来看一下我们的测试类： @Test public void test3() throws IOException { //获取代理对象 StudentMapper mapper = getSqlSession().getMapper(Stu...
MybatisPlus的LambdaQueryWrapper用法
最新发布
2301_79693537的博客
08-21 4203
【代码】MybatisPlus的LambdaQueryWrapper用法。
Mybatis源码解析：执行流程与核心组件
"这篇内容主要讲解了Mybatis的源码分析，包括JDBC执行流程、Mybatis的会话和执行器，以及二级缓存和预处理器的相关知识，还涉及到了Mybatis的配置体系。" 在Mybatis中，了解JDBC执行流程是理解其工作原理的基础。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值