Mybatis 源码解析(五) 从SELETE语句理解Mybatis执行全流程

深碍√TFBOYSˉ_ 2023-06-13 15:24 6阅读 0赞

## 背景 ##

对于我们经常写的SQL代码，我们经常会写到

select * from tb_user

不知道大家还记不记得使用jdbc接口时候的场景。

public static void main(String[] args) { 
            String driver = "com.mysql.jdbc.Driver";
            String url = "jdbc:mysql://192.168.1.101:3306/test";
            String user = "root";
            String password = "123456";
            try { 
                // 1. 加载驱动
                Class.forName(driver);
                // 2. 建立连接
                Connection con = DriverManager.getConnection(url, user, password);
                if (!con.isClosed()) { //判断数据库是否链接成功
                    //3、创建Statement对象
                    Statement st = con.createStatement();
                    //4、执行sql语句
                    String sql = "select * from tb_user";//查询user表的所有信息
                    ResultSet rs = st.executeQuery(sql);//查询之后返回结果集
                    //5、打印出结果
                    System.out.println("ID" + "\t" + "NAME" + "\t");
                    while (rs.next()) { 
                        System.out.println(rs.getString("Id") + "\t" + rs.getString("name") + "\t");
                    }
                    rs.close();//关闭资源
                    con.close();//关闭数据库
                }
    
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }

以上是一个最简单的场景，当我们想把传入一个ID作为查询条件的时候，

select * from tb_user where id = 1

再说一个场景： 我们想把查询的结果作为一个User实例的时候，这样我们就可以使用user.getName来访问数据库查询出来的结果了，那么这就需要一个框架来做一些事情了。

第一步和第二部现在有数据库连接池做掉，但是3、4、 5 是由`mybatis`框架封装做掉的。

1.  id=1这里对应的是`ParameterHandler` （参数处理器）
2.  Statement执行对应`StatementHandler` （`SQL`语句处理器）
3.  封装为User对象对应的`ResultSetHandler` （结果集处理器）

## 实现 ##

### StatementHandler ###

首先开看一下`StatementHandler`

public interface StatementHandler { 
    
      Statement prepare(Connection connection, Integer transactionTimeout)
          throws SQLException;
    
      void parameterize(Statement statement)
          throws SQLException;
    
      void batch(Statement statement)
          throws SQLException;
    
      int update(Statement statement)
          throws SQLException;
    
      <E> List<E> query(Statement statement, ResultHandler resultHandler)
          throws SQLException;
    
      <E> Cursor<E> queryCursor(Statement statement)
          throws SQLException;
    
      BoundSql getBoundSql();
    
      ParameterHandler getParameterHandler();
    
    }

1.  准备Statement
2.  参数化Statement
3.  批量执行
4.  更新
5.  查询
6.  查询游标
7.  绑定的SQL
8.  参数处理器

默认的Statement处理器是`PreparedStatementHandler`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]

我们首先来学习一下最简单的`PreparedStatementHandler`。

--------------------

**PreparedStatement**（延伸阅读，可跳过）

首先我们了解以下什么是`PreparedStatement`,估计大家经常听到说这个是预编译的Statement，效率高，那么到底高在哪里？

其实是这样子的，首先这个`PreparedStatement`是JDBC的一个规范，所有的数据库写的对应的驱动都需要遵守这个规范。以至于以为这个预编译是在驱动 层面的预编译，其实不是的，而是在数据库服务器层面的预编译，也就是说在分布式的情况下或者使用多次这个sql的情况下，只要是一个数据库的实例的话，那么这个对于所有的应用都是有效的。所以它的效率会高很多。那么真实是这样吗？**其实不是的，具体可以看这个分析 https://www.iteye.com/blog/cs-css-1847772，我自己测试了一下，Mysql5.6.27版本的数据库，也发现并没有想能进行提升，oracle的没有进行测试，抽空测试一下。**

**那么具体是怎么实现的呢？**

> MySQL执行预编译分为如三步：
> 
> 1.执行预编译语句，例如：prepare showUsersByLikeName from ‘select \* from user where username like ?’;  
> 2.设置变量，例如：set @username=’%小明%’;  
> 3.执行语句，例如：execute showUsersByLikeName using @username;
> 
> 如果需要再次执行myfun，那么就不再需要第一步，即不需要再编译语句了：
> 
> 1.设置变量，例如：set @username=’%小宋%’;  
> 2.执行语句，例如：execute showUsersByLikeName using @username;  
> ————————————————  
> 版权声明：本文为CSDN博主「marvel\_\_dead」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
> 原文链接：https://blog.csdn.net/Marvel\_\_Dead/article/details/69486947

所以默认的情况下Myabtis使用的是**PreparedStatement**，但是据这位博主说`useServerPrepStmts`默认是false。

还有一个好处是防注入，这个是在驱动层面做的，不是在数据库层面做的,它会调用`PreparedStatement#fillSendPacket`,也就是在发送到服务器执行的时候，进行转义。

以上就是`PreparedStatemen`的优点，也许这就是为什么作为默认的实现吧。

--------------------

### 实现过程 ###

闲话不讲，主要我们研究`mybatis`的使用方式吧。

仍然从`select * from tb_user where id = 1`入手，看看是如何处理参数 => 执行语句 => 封装为对象。

首先看一下我们的接口定义

User selectByExample(User queryItem);
    
    ---xml----
        
    <select id="selectByExample" parameterType="User" resultType="User">
            select
            <include refid="baseColumn"/>
            from user
            where
            1 = 1
            <include refid="whereClause"/>
        </select>

我们知道`Mybatis`在初始化的时候，所有的Mapper接口会被`MapperProxy`包装为一个可执行的对象(假设大家都知道，就是对Mapper的一个代理实现)。

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 (method.isDefault()) { 
          if (privateLookupInMethod == null) { 
            return invokeDefaultMethodJava8(proxy, method, args);
          } else { 
            return invokeDefaultMethodJava9(proxy, method, args);
          }
        }
      } catch (Throwable t) { 
        throw ExceptionUtil.unwrapThrowable(t);
      }
      final MapperMethod mapperMethod = cachedMapperMethod(method);
      return mapperMethod.execute(sqlSession, args);
    }

可以真正的执行的看到接口方法会被封装为一个`MapperMethod`，然后传入`SqlSession`和`args`执行返回结果。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UAr9kcky-1573999019723)(docs/images/1573996988968.png)\]][img-UAr9kcky-1573999019723_docs_images_1573996988968.png]

然后看到`MapperMethod#execute` => `SqlSesion#selectOne` => `SqlSession#selectList`

public Object execute(SqlSession sqlSession, Object[] args) { 
        Object result;
        switch (command.getType()) { 
          // 省略 UPDATE、 DELETE、 INSERT
          case SELECT:
            // 省略
              result = sqlSession.selectOne(command.getName(), param);
              if (method.returnsOptional()
                  && (result == null || !method.getReturnType().equals(result.getClass()))) { 
                result = Optional.ofNullable(result);
              }
           // 省略
        return result;
      }

`SqlSession#selectList`

// statement = com.wuhulala.mybatis.mapper.UserMapper.selectByExample
    // parameter = User{id=1, name='null', age=0, sex='null'}
    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();
        }
      }

然后获取到对应的`MapperStatement`,由`BaseExecutor#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);
      }

1.  构造boundSql

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZLgdReRk-1573999019724)(docs/images/1573998270956.png)\]][img-ZLgdReRk-1573999019724_docs_images_1573998270956.png]

1.  创建缓存键
2.  执行

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

从数据库查询

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

1.  先放入一个占位符（为了防止多次初始化）
2.  执行（重点这一步）
3.  放入缓存

`SimpleExecutor#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 handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          stmt = prepareStatement(handler, ms.getStatementLog());
          return handler.query(stmt, resultHandler);
        } finally { 
          closeStatement(stmt);
        }
      }

1.  创建`StatementHandler` — 重点才到
2.  获取`PrepareStatement`
3.  执行 `Statement` ，高潮来了

`PreparedStatementHandler#query`

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

1.  执行`statement`
2.  封装返回数据为对象

`DefaultResultSetHandler#handleResultSets`

public List<Object> handleResultSets(Statement stmt) throws SQLException { 
        ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
    
        final List<Object> multipleResults = new ArrayList<>();
    
        int resultSetCount = 0;
        ResultSetWrapper rsw = getFirstResultSet(stmt);
    
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        validateResultMapsCount(rsw, resultMapCount);
        while (rsw != null && resultMapCount > resultSetCount) { 
          ResultMap resultMap = resultMaps.get(resultSetCount);
          handleResultSet(rsw, resultMap, multipleResults, null);
          rsw = getNextResultSet(stmt);
          cleanUpAfterHandlingResultSet();
          resultSetCount++;
        }
    
        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);
      }

1.  获取resultMap
2.  处理ResultSet和ResultMap的关联关系，从而转化为ResultMap.详细细节就不看了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191117215759847.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[img-UAr9kcky-1573999019723_docs_images_1573996988968.png]: https://img-blog.csdnimg.cn/20191117215824452.png
[img-ZLgdReRk-1573999019724_docs_images_1573998270956.png]: https://img-blog.csdnimg.cn/20191117215836544.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70