Mybatis中SQL语句执行过程详解

最新推荐文章于 2024-07-29 14:21:29 发布
最新推荐文章于 2024-07-29 14:21:29 发布
阅读量7.4k 收藏 15
点赞数 7
分类专栏： Mybatis应用及原理探析 Mybatis 深入了解Mybatis使用及实现原理 文章标签： 数据库 mybatis 架构 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/majinggogogo/article/details/72179560
版权

前面的十来篇文章我们对Mybatis中的配置和使用已经进行了比较详细的说明，想了解的朋友可以查看一下我专栏中的其他文章。

但是你对整个SQL语句操作的流程了解吗？如果你还不是很了解，那么可以继续往下看，如果你已经了解了，那么可以跳过啦大笑（因为一大推的源码估计要看的你头晕啊！！！）


所有语句的执行都是通过SqlSession对象来操作的，SqlSession是由SqlSessionFactory类生成的。

首先根据配置文件来创建一个SqlSessionFactory，然后调用openSession来获取一个SqlSession。我们从时序图来看看可能会更加清晰：

（1）生成SqlSessionFactory对象（默认实现是DefaultSqlSessionFactory）的过程

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

 
// Mybatis 通过SqlSessionFactory获取SqlSession, 然后才能通过SqlSession与数据库进行交互
	private static SqlSessionFactory getSessionFactory() {
		SqlSessionFactory sessionFactory = null;
		String resource = "configuration.xml";
		try {
			sessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return sessionFactory;
	}

（2）获取SqlSession对象

通过调用DefaultSqlSessionFactory的openSession()方法来获取SqlSession对象。

@Override
  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), 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);
      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实例对象。接下来就是根据这个DefaultSqlSession来获取对应的Mapper对象。


（3）获取MapperProxy对象

UserDao userMapper = sqlSession.getMapper(UserDao.class);

如上所示，通过SqlSession对象调用getMapper()方法来获取相应的Dao接口实现。我们通过代码跟踪一直往下看：

DefaultSqlSession类中：

@Override
  public <T> T getMapper(Class<T> type) {
    return configuration.<T>getMapper(type, this);
  }

Configuration类中：

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

MapperRegistry类中： 

 @SuppressWarnings("unchecked")
  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);
    }
  }

在MapperRegistry类中维护着一个Map，这个Map中存储着每个Mapper类型和其对应的代理对象工厂类，如下定义所示： 

private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();

在mybatis初始化的过程中就根据配置文件<mappers>元素的配置，将相关的映射文件给加载到了内存，同时保存到了这个knownMappers中。这里，在调用getMapper()的时候，就会从这个knownMappers中寻找该Dao接口，如果没有找到，就直接抛出异常，说明没有在配置文件中配置说明，如果获取到了，那么就拿出其对应的代理对象工厂类出来，并从工厂类中通过newInstance()方法来获取一个代理对象。


MapperProxyFactory类中：

@SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

从代码可以看出来，其实我们调用sqlSession.getMapper(UserDao.class)方法的时候,返回的是一个和UserDao接口对应的MapperProxy代理对象。如下定义所示，MapperProxy类是一个实现了InvocationHandler的代理类： 

public class MapperProxy<T> implements InvocationHandler, Serializable

上面的代码，如果整理成时序图，如下所示：

拿到了Dao接口的代理对象后，我们应该就可以进行具体的增删改查了，我们继续往下看。


（4）Executor对象

当拿到了UserDao对象（其实是MapperProxy代理对象）后，我们调用Dao接口中定义的方法，如下所示：

User user = userMapper.findUserById(10);

这时候便调用了MapperProxy对象的invoke方法了； 

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

MapperMethod类中： 

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {
      case INSERT: {
    	Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      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;
      case FLUSH:
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName() 
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }

从上面这个方法实现上可以看出，已经根据执行方法(CRUD)进行了不同的处理，我们简单看一个方法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;
  }

通过观察这些代码，发现最终的实现都是通过sqlSession对象来进行操作的。我们继续往里看，看看selectList方法： 

@Override
  public <E> List<E> selectList(String statement) {
    return this.selectList(statement, null);
  }

  @Override
  public <E> List<E> selectList(String statement, Object parameter) {
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }

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

可以看到，内部是把查询操作委托给了一个Executor对象（即executor.query()），Executor是一个接口，mybatis为其实现了一个抽象基类BaseExecutor，我们跟踪上面的代码中的query方法继续往里看：


BaseExecutor类中：

@Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    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());
    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;
  }

在上面的方法中，我们看到当list==null的时候会调用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;
  }

然后会调用doQuery()方法，BaseExecutor中的doQuery方法定义成了抽象方法，由具体的继承类进行个性化的实现。这里，我们拿mybatis中默认使用的SimpleExecutor来看看：

SimpleExecutor类中：

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

从这个方法可以看到，首先根据调用Configuration类的newStatementHandler方法来获取一个sql操作对象：

Configuration类中：

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

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

  }

可以看到，这里根据配置来创建Statement、PreparedStatement或者CallableStatement三者之中的一个。然后调用相应的方法，如query（）方法。以SimpleStatementHandler为例，我们看看具体的sql操作： 

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

看到这里，我们终于看到了黎明的曙光，因为这里已经看到Jdbc中的数据库操作代码了，即statement.execute(sql)。在查询完之后使用resultSetHandler来进行查询结果集的处理。

上面的代码的整体流程图大概如下所示：

至此，一次完整的sql解析和处理过程便讲解完毕了，感兴趣的可以自己对着源码看看。


如果想了解我最新的博文，请关注我的博客。如果想看到更多相关技术文章并愿意支持我继续写下去，欢迎给我打赏，对您的打赏我表示感谢。吐舌头

DreamMakers
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Mybatis执行SQL语句的方式
12-09
Mybatis执行SQL语句的方式
mybatis动态sql语句详解
04-28
### MyBatis动态SQL语句详解 #### 一、MyBatis简介 MyBatis是一个优秀的持久层框架，它支持自定义SQL语句、存储过程以及高级映射功能。通过使用MyBatis，开发人员可以避免编写大量的JDBC代码和手动设置参数以及...
mybatis/ibatis直接执行sql语句
简约不简单
12-17 1044
在项目中，使用的是mybatis3.0.5，但没有采用其提供的DAO层接口映射的策略，而且在进行多种属性联合查找时，需要底层提供通用的解决方案，所以需要mybatis直接执行sql语句，各个daoImpl均可调用，减少了在每个mybatis文件中配置符合当前对象的select查询。。 （在mybatis中，需要通过传递对象，在select中判断对象属性是否为空进行where语句的拼凑，对后期...
【MyBatis】史上最全的MyBatis执行SQL原理分析
最新发布
小七的博客
07-29 800
史上最全的MyBatis执行SQL的原理分析，深入底层源码，一篇文章带你彻底搞懂MyBayis执行SQL的底层实现，横扫面试场！
mybatis之执行sql语句
wang0907的博客
08-19 4241
写在前面 通过这篇文章的分析，已经生成了可以执行的sql语句了，本文来分析SQL语句具体的执行过程。 想要系统学习的，可以参考这篇文章，重要！！！。
MyBatis源码分析之——执行SQL语句的过程
冰河的专栏
01-05 1271
User user = userMapper.getUserById(1) 调用invoke代理方法 由于所有的 Mapper 都是 MapperProxy 代理对象，所以任意的方法都是执行MapperProxy 的invoke()方法。 public Object invoke(Object proxy, Method method, Object[] args) throws Thr...
Mybatis Sql执行流程
oliver486的博客
04-21 828
执行流程图（不包含缓存） 1:使用Mapper接口调用具体方法，会调用到Mapper接口的代理实现类MapperProxy.invok方法 2:MapperProxy.invok根据method信息找到MapperMethod（每一个mapper.xml文件的方法都会对应一个MapperMethod），MapperMethod执行mapperMethod.execute(sqlSession, args)，参数sqlSession是sqlSessionTemplate对象 3:MapperMeth
MyBatis 执行动态 SQL语句详解
09-01
下面我们将深入探讨如何在 MyBatis 中执行动态 SQL 语句。 首先，我们要理解 MyBatis 中的 SQL 执行方式。基础的 SQL 执行可以通过在 Mapper XML 文件中定义 `<select>` 标签，然后在对应的 Mapper 接口中声明方法...
Mybatis中SQL语句的编写.pdf
06-27
### MyBatis中SQL语句的编写 #### 一、概述 在MyBatis框架中，SQL语句的编写是一项核心任务。MyBatis作为一款优秀的持久层框架，支持多种方式来定义SQL语句，包括XML配置文件和注解等方式。本文档主要介绍在XML配置...
详解Java的MyBatis框架中SQL语句映射部分的编写
09-02
在Java的MyBatis框架中，SQL语句映射部分是整个ORM（对象关系映射）过程中的核心组件，它负责将SQL查询结果转化为Java对象。这篇教程将深入讲解SQL映射XML文件的编写，主要关注`resultMap`以及增删查改（CRUD）的...
详解MyBatis直接执行SQL查询及数据批量插入
09-02
MyBatis是一个强大的持久层框架，它允许开发者直接编写SQL语句，简化了数据库操作。在本文中，我们将深入探讨如何使用MyBatis直接执行SQL查询以及如何进行数据的批量插入。 **一、直接执行SQL查询** 在MyBatis中，...
mybatis直接执行sql语句后续之一
04-18
NULL 博文链接：https://benworld.iteye.com/blog/1841031
mybatis sql执行流程
奋斗的青年
02-23 251
https://www.cnblogs.com/dongying/p/4142476.html
Mybatis之SQL执行
2302_77659577的博客
08-09 837
Mybatis的代码还是比较清晰的,跟着一步一步下来，都能摸清大致的脉络,捋起袖子加油干～～
剖析Mybatis的SQL执行过程
Professor11的博客
07-17 346
SQL 执行过程分析 今天又来一点硬核的东西，我们一起来看看SQL的执行过程 为 Mapper 接口创建代理对象 先看看调用栈： // 本质: // MapperProxyFactory public T newInstance(SqlSession sqlSession) { /* * 创建 MapperProxy 对象，MapperProxy 实现了 * InvocationHandler 接口，代理逻辑封装在此类中 */ final MapperP
MyBatis中一个SQL语句的执行过程解析
董广明的博客
10-19 807
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 平时用MyBatis框架开发时，配置好config.xml和mapper.xml映射文件和定义好java接口，就可以操作数据库了 mybatis配置文...
Mybatis 处理 sql 语句
@Bean
08-09 1799
本文 mybatis 处理 sql 语句主要分为编译期间处理和执行期间处理 另外 sql 语句又分为 静态 sql 语句 和动态 sql 语句，用参数修饰符来区分。 静态 sql 语句：没有参数或者参数修饰符全部是 #{} 这种，并且没有其他标签 动态 sql 语句：参数其中之一被 ${} 修饰，或者有标签 Mybatis 对动态 sql 的定义 mybatis 初始化完成后 所有处理完的 sql 语句都存在 SqlSource Configuration —》 MappedStatement–》 SqlS
MyBatis框架中sql语句的执行过程
m0_57713282的博客
12-20 1964
一：概述 主要思路：dom4j解析配置文件生成一个全局配置对象，利用jdk动态代理创建出接口的代理类，通过代理类完成crud的操作，从而间接完成接口方法中的crud操作（代理通过以接口方法名为id就可以拿到对应的sql语句，所以dao接口的接口方法其中一个作用就是代理类用来寻找对应的sql语句的） 二：MyBatis使用的标准步骤 //通过流的方式加载mybatis配置文件 InputStream in = Resource.getResourseAsStre...
MyBatis是如何执行一条SQL语句的
m0_71777195的博客
07-04 671
在前两天的一次面试中，面试官问了一个和标题一样的问题，由于一直认为MyBatis只是一个ORM框架，所以并没有对他有过深入的了解，于是被问到了，那么这一篇文章来从源码探究一下MyBatis是如何执行一条SQL语句的。源码环境，github直接下载的main分支代码，版本号为 3.5.11-SNAPSHOT github点击跳转Ide Jetbrain Idea 2021.2.1 社区版 Maven 3.8.2 JDK 17配置文件 测试主方法 mapper mapper.xml 阅读过程
Mybatis框架SQL防注入策略详解
在Java Web开发中，Mybatis是一个流行的持久层框架，它允许开发者直接编写SQL语句来进行数据库操作。然而，这同时也增加了SQL注入的风险。SQL注入是一种常见的安全漏洞，攻击者可以通过构造恶意输入来执行非预期的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值