mybatis在spring中的执行流程

最新推荐文章于 2023-05-23 21:50:33 发布
最新推荐文章于 2023-05-23 21:50:33 发布
阅读量358 收藏 2
点赞数 1
文章标签： mybatis spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kznsbs/article/details/125391189
版权

简介

mybatis最终的 执行对象是一个代理对象，所以想要弄清mybatis的执行流程，就得从这个代理对象开始分析

MapperProxy

public class MapperProxy<T> implements InvocationHandler, Serializable {
	.....
	@Override
  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);
  }
	.....
}

实现了InvocationHandler，使用的是jdk的动态代理，通过打断点继续往下看

  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {
      case INSERT: .....
      case UPDATE: .....
      case DELETE: .....
      case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        }
        break;
      ......
    }
   
    return result;
  }

execute方法中，针对不同的执行类型进行了不同的操作，这些执行 类型对应了sql
下面以select 的executeForMany进行分析

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
    } else {
      result = sqlSession.<E>selectList(command.getName(), param);
    }
    // issue #510 Collections & arrays support
    if (!method.getReturnType().isAssignableFrom(result.getClass())) {
      if (method.getReturnType().isArray()) {
        return convertToArray(result);
      } else {
        return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
      }
    }
    return result;
  }

1.将参数封装到RowBounds
2.执行sql

SqlSessionInterceptor.invoke(…)

SqlSessionTemplate.selectList(…)–>
SqlSessionInterceptor.invoke(…)

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      SqlSession sqlSession = getSqlSession(
          SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType,
          SqlSessionTemplate.this.exceptionTranslator);
      try {
        Object result = method.invoke(sqlSession, args);
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          sqlSession.commit(true);
        }
        return result;
}```
这个invoke 方法中首先获取Sqlsession，然后执行，最后提交事物

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

    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

    SqlSession session = sessionHolder(executorType, holder);COCO
    if (session != null) {
      return session;
    }
    session = sessionFactory.openSession(executorType);
    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
    return session;
  }

这里就能看到非常熟悉的代码了sessionFactory.openSession
通过sessionFactory获取一个openSession

openSessionFromDataSource

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

1.首先是获取了一个Transaction，就是开启一个事物，在spring中，这个事物类型是springManageTransactionFactory
2.这里看到了mybatis中第一个非常重要的对象获取一个Executor，Executor大家应该都了解，这里默认获取的是SIMPLE类型的
3.将Executor封装为DefaultSqlSession返回

selectList(…)

上面获取到了SqlSession方法，就要准备开始真正执行sql了，这个时候可能会有小伙伴要问，
执行sql之前不是还需要获取接口的代理对象么？？？其实这个接口的代理对象早就由spring帮忙生成了，然后我们就可以通过依赖注入使用，还不太了解的小伙伴可以先去了解下spring 与mybatis如何整合的

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      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();
    }
  }

这里看到了第二个非常重要的对象 MappedStatement
在这里插入图片描述

简单看一眼，MappedStatement里面存储的主要是执行sql可能会用到的信息

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

这里看到了CacheKey，这个其实和二级缓存相关，接着往下看

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, parameterObject, boundSql);
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

这里就是根据Cachekey来查看是否有缓存，如果有缓存，那就直接返回缓存内容了，第一次显然是没有的，这里也说明了，二级缓存的优先级比一级缓存高

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

localCache 就是我们常说的一级缓存，这里如果一级缓存有记录了，那么就会直接返回

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;
  }

这里可以看到，会将查询出来的结果缓存到一级缓存

query

  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.<E> handleResultSets(ps);
  }

最后就可以看到，通过PreparedStatement执行sql，将执行的结果通过resultSetHandler进行处理，然后返回，至此，大体的查询流程就结束了

总结

根据不同sqlType进行不同的操作，先获取sqlSession，然后执行sql，如果开启了二级缓存，首先会在二级缓存里面找，找到了就返回。然后会在一级缓存里面找是否有对应缓存，找到了就返回，接着执行sql，将执行的结果添加缓存，最后结果通过ResultSetHandler封装返回

我还没秃，还能学
关注
专栏目录
mybatis整合spring启动和执行流程
qq_38967207的博客
06-19 359
mybatis
【三】MyBatis-Spring最全源码详解之SQL执行流程
人工智障训练师的博客
03-16 944
前面两篇系列文章已经详细介绍了Mapper接口的扫描过程和对应bean的创建过程。本文重点介绍mybatis执行SQL的过程。 DaoService的selectByName方法，拿到的personMapper对象已经是上文介绍的那个superMapperProxy对象。执行personMapper.selectByName(personName)方法，其实就是执行的superMapperPro...
SpringMVC| Mybatis执行流程
S.H.I.T
07-10 257
MVC执行流程 第一步：发起请求到前端控制器(DispatcherServlet) 第二步：前端控制器请求HandlerMapping查找 Handler （可以根据xml配置、注解进行查找） 第三步：处理器映射器HandlerMapping向前端控制器返回Handler，HandlerMapping会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控...
从源码的角度解读Spring中 Mybatis 的执行流程
江城宴的博客
07-16 608
在 spring 项目中不仅要学习 mybatis 还要学习 mybatis 是如何与 spring 完美结合的，这就要归功于 mybatis-spring.jar。今天不仅要学习 mybatis 还要学 如何与 spring 完美结合。 首先回顾一下 mybatis 的执行流程： //mybatis的配置文件 String resource = "hong/helloWorld/Co...
Spring源码剖析(三) [新]Mybatis-Spring最全最详细的调用和执行过程解析
qq_37419449的博客
10-25 5013
前言: 本文将重点讲解Mybatis-spring的执行过程，对比mybatis和Mybatis-spring的流程差异，以及Mybatis-spring一级缓存失效的原因（文章方法15），和spring自动注入的原理和哪些属性不会自动装配的讲解。 解析mybatis-spring源码 文章目录解析mybatis-spring源码启动流程执行过程对象的自动装配 启动流程 Mybatis配置类中的MapperScan @Configuration @EnableTransactionManagement
mybatis_spring_struts2_tjz.zip_ibatis_mybatis_spring_spring stru
09-24
Struts2、Spring和iBATIS（MyBatis）是Java Web开发中常见的三大框架，它们各自...学习过程中，可以逐步理解各框架间的通信机制，以及如何通过日志和调试工具跟踪代码执行流程，这对于提升Java Web开发技能大有裨益。
spring-mybatis-spring-1.0.0-RC3.zip
最新发布
04-19
1. 引入依赖：在项目中添加Spring和MyBatis的依赖库，包括Spring的context和orm模块，以及MyBatis的核心库。 2. 配置MyBatis：创建MyBatis的配置文件（如mybatis-config.xml），定义数据源、事务管理器、...
Spring，Spring MVC、Mybatis和Spring boot（知识点总结）
qq_43655412的博客
10-17 3158
Spring，Spring MVC、Mybatis和Spring boot（知识点总结）
Mybatis在Spring、SSM、SpringBoot中的简化过程详解.docx
07-03
在Spring MVC框架中，Mybatis作为数据访问层（DAO）的一部分，与Service层交互。通常，我们会在Controller中注入Service，Service再调用对应的DAO方法，执行数据库操作。 ### 阶段五：SpringBoot整合Mybatis ...
spring整合mybatis的操作流程（一）
Mia的博客
03-31 365
首先spring整合mybatis需要在pom.xml中引入两个坐标： <properties> <mybatis-spring.version>1.2.2</mybatis-spring.version> <mybatis.version>3.2.3</mybatis.version> </properties&...
Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解
11-26
Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解 理解很透彻， 入门五星推荐
mybatis-spring sql执行过程分析
weixin_33851604的博客
12-08 114
1.参考官方中文文档：http://www.mybatis.org/spring/zh/factorybean.html 2.核心是sqlsessionfactorybean。 它是实现了factorybean接口，最终创建的bean类型由getbobject返回的结果。 且是单例的，通过实现接口 isSingleton()判断 转载于:https://juejin.im/post/5a29f1...
MyBatis执行过程
守正出奇
03-21 958
MyBatis作为常用的ORM框架之一，了解MyBatis中sql执行过程是应用开发必备的技能。
MyBatis和Spring整合，流程浅析 - 20181208
weixin_30263277的博客
12-08 167
【面试题】我们在开发mybaits时候，有几种写sql语句的方式？ 一种是注解、一种是xml文件、还有一种是@Provider 注解形式：简单但是不是很灵活，对于动态条件查询是无法实现的，这时，我们可以使用xml的方式。 xml形式：有xml文件，且约束严格。 @Provider：结合上两种优点，注意：方法不能重载 【面试题】我们都知道myb...
spring源码学习之整合Mybatis之后事务执行
lihuayong的专栏
05-03 634
前面记录了一片《spring源码学习之整合Mybatis原理分析》之后，这篇记录spring在整合mybatis之后，目标方法的调用过程和事物的管理。 通过这篇文章分析之后，至少需要解决本人关注的两个问题： 调用mapper方法的执行过程是怎样的？ mybatis的事物和spring的事物是如何被管理的？ 配置文件还是遵从前面文章的记录，测试用...
mybatis-spring 框架原理与源码解析--执行流程
yange1025的博客
10-23 441
上一篇文章https://blog.csdn.net/yange1025/article/details/84709273介绍了如何在Spring项目中配置mybatis以及mybatis的启动过程。本篇文章将从用户发起一笔查询到返回查询结果来介绍mybatis的执行流程。 入口从用户从Spring容器获取Mapper接口对应的bean，并调用接口方法执行查询开始。我们知道从Spring容器获取...
Spring：Spring 整合 MyBatis 的具体过程
taiyang3285的博客
05-23 1474
介绍了 Spring 整合 MyBatis 的具体过程
spring + mybatis 运行流程
zp1220的专栏
05-31 157
一.pom.xml 1.里面配置都是项目依赖配置 2. spring框架配置，Mybatis的配置，整合配置， 3. 数据圆的依赖p配置，数据库驱动的配置等等。 二.项目启动去寻找web.xml web.xml文件中，需要配置Spring的核心监听器 1.web容器已启动就会被监听到 （通过<listener> ...
Spring框架（四）spring整合mybatis全部流程，附代码
一天不写代码难受的博客
07-01 478
目录回顾使用Servlet+MVC+Mybatis+Jsp完成用户登录Service层使用Spring获取Mapper对象问题:解决:实现:Controller层使用Spring解耦service层问题:解决:实现:分析 回顾 我们的java ee web项目，使用mybatis操作数据库，是写了一个mybatis.xml，里面是数据源。之后写了一个公共类，这个公共类就是利用这个xml创建对象，以后在业务层就利用这个公共类，创建mapper层的对象，然后调用mapper层对象里面的方法，实现对数据库的操作
MyBatis与Spring整合指南
本章详细阐述了如何在Spring中注入映射器，这是MyBatis-Spring的一个重要特性，允许开发者通过Spring的依赖注入机制直接使用Mapper接口，无需手动创建SqlSession。 **第四章 使用SqlSessionDaoTemplate和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值