Mybatis源码简析

作者: 烽火戏码农 | 来源:发表于2017-08-22 16:27 被阅读114次

本文将按mybatis中主要数据库查询操作的流程对其源码进行简单分析。目录如下：

1、mybatis的主要工作流程

2、mybatis进行数据查询的小实例

3、源码分析

3.1、获取SqlSessionFactory（配置文件解析）

3.2、Mapper对象获取

3.3、Mapper方法执行

4、总结

1、mybatis的主要工作流程

mybatis的工作流程：

加载配置-->SQL解析-->SQL执行-->结果映射

加载配置：配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。
SQL解析：当API接口层接收到调用请求时，会接收到传入SQL的ID和传入对象（可以是Map、JavaBean或者基本数据类型），Mybatis会根据SQL的ID找到对应的MappedStatement，然后根据传入参数对象对MappedStatement进行解析，解析后可以得到最终要执行的SQL语句和参数。
SQL执行：将最终得到的SQL和参数拿到数据库进行执行，得到操作数据库的结果。
结果映射：将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回

后面将按这个步骤来注解分析源码.

2、mybatis进行数据查询的小实例

下面代码主要展示了mybatis中进行数据库操作的几个核心要素。

public void testFindUserById(int userId) throws IOException {
        // mybatis配置文件
        String resource = "mybatis-config.xml";

        // mybatis通过SqlSessionFactory获取SessionFactory
        // 然后获取SqlSession，通过sqlSession来获取映射执行SQL的。
        SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));;
        SqlSession sqlSession = null;
        
        if (sf != null) {
            sqlSession = getSqlSessionFactory().openSession();

            SysUserDao userDao = sqlSession.getMapper(SysUserDao.class);
            SysUser user = userDao.findUserById(userId);
        }
    }

通过配置文件，生成了SqlSessionFactory，从而创建 SqlSession，在mybatis中，所有的sql执行，都是通过SqlSession来实现的。
获取到sqlSession对象后，即可通过对应的getMapper方法来获取接口的动态实现类了，从而完成接口方法的执行。

3、源码分析

本节开始，将按照上面的代码执行过程，对mybatis的源码进行分析。分析涉及到以下几个大的过程：

1、对配置文件的解析。需要搞明白配置文件中的数据解析存储到哪儿了
2、接口类实现的获取。由于mybatis中是通过接口定义方法+xml配置方式来完成对数据库的操作，核心是通过动态代理的方式来构造接口实现类的，对这个获取过程和方法的执行需要分析。
3、接口类中的方法的执行。同上

3.1、获取SqlSessionFactory（配置文件解析）

配置文件的解析过程，实际上是通过获取SqlSessionFactory来实现的，这个过程看下图：

获取SqlSessionFactory流程.png

在前面的例子中有一行代码：

SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));;

调用SqlSessionFactoryBuilder().build方法来创建sqlSession工厂，builder方法的入口参数是Reader，通过调用Resources.getResourceAsReader(resource)来实现的。

mybatis中的Resources类主要是通过类加载器来简化对各种资源的获取操作

SqlSessionFactoryBuilder类主要提供了基于Reader和InputStream来解析xml文件的方法，主要依赖于XMLConfigBuilder来实现,通过XMLConfigBuilder的parse方法解析xml配置文件得到Configuration对象，通过configuration对象构造默认的SqlFactory实现类DefaultSqlSessionFactory实例

SqlSessionFactoryBuilder的build方法最终调用到以下方法：

/**
   * 解析xml文件两个步骤：
   * 1、读取xml信息；
   * 2、根据xml信息构建SqlSession工厂
   */
  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
    
        logger.info("build init.");
      // 1. 通过XMLConfigBuilder来解析xml配置文件
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);

      // 2. 调用xml解析器进行解析得到Configuration对象,xml文件中的配置信息都存储到configuration对象中了
      // 3. 创建defaultSessionFactory对象
      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.
      }
    }
  }

创建SelSessionFactory对象

// 创建SelSessionFactory对象
  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

实际上，创建SessionFactory对象的过程分为以下3大步骤：

通过XMLConfigBuilder来解析xml配置文件
调用xml解析器进行解析得到Configuration对象
创建defaultSessionFactory对象

// 进行解析操作 将最终解析到的数据存储在configuration对象中
public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    
    // 从根节点configuration上开始解析
    parseConfiguration(parser.evalNode("/configuration"));
    // 这个地方的configuration是在当前类XMLConfigBuilder的父类BaseBuilder中定义的，在本类的构造方法中创建
    //  这儿configuration对象已经返回了，通过上面的代码可以构造出SqlSessionFactory的实现对象了。
    return configuration;
}

接下来，在parseConfiguration方法中开始xml文件的解析：

// 解析configuration节点下的配置，可对照mybatis-config.xml文件
  private void parseConfiguration(XNode root) {
    try {
      // 提取settings
      Properties settings = settingsAsPropertiess(root.evalNode("settings"));    // 解析settings
      
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));                            // 解析properties
      loadCustomVfs(settings);
      
      // 别名解析
      typeAliasesElement(root.evalNode("typeAliases"));
      // 插件解析
      pluginElement(root.evalNode("plugins"));
      // 解析自定义的ObjectFatory实现
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectionFactoryElement(root.evalNode("reflectionFactory"));
      // 解析settings
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      
      // 解析environments 数据源的配置
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      
      // 类型处理解析
      typeHandlerElement(root.evalNode("typeHandlers"));
      
      // mappers映射解析
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

上面的代码中开始对配置文件中的各个节点进行解析，我们目前关注mapper的解析即可：

private void mapperElement(XNode parent) throws Exception {
      logger.info("开始解析Mappers节点");
      if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
            logger.info("开始处理package节点");
          String mapperPackage = child.getStringAttribute("name");
          // 调用configuration的添加方法
          configuration.addMappers(mapperPackage);
        } else {
          // 通常将在另外的配置文件中配置SQL
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
                // <mapper resource="com/xxxxxxx/dao/****Mapper.xml"/>
            logger.info("解析resource:" + resource);
            ErrorContext.instance().resource(resource);
            // 获取配置文件
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());

            // 解析器进行解析
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            // url方式解析
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
      logger.info("解析Mappers节点结束！");
  }

在xml中配置了如下的mapper:
<mapper resource="com/xxxxxxx/dao/****Mapper.xml"/>，通过resource定位到指定的配置文件中，再进行解析，XMLMapperBuilder中parse方法如下：

  public void parse() {
    logger.info(" 开始解析mapper文件：XMLMapperBuilder.parse");  
    if (!configuration.isResourceLoaded(resource)) {
      
      // 对mapper文件中对各个元素进行解析
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingChacheRefs();
    parsePendingStatements();
  }

private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      
      logger.info("解析到mapper文件中的namespace元素：" + namespace);
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      // 解析配置文件中的sql语句，重点关注这儿
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
    }
  }

重点看对sql的解析

  private void buildStatementFromContext(List<XNode> list) {
      logger.info("解析mapper文件中insert | delete | update | select 元素");
      if (configuration.getDatabaseId() != null) {
      buildStatementFromContext(list, configuration.getDatabaseId());
    }
    buildStatementFromContext(list, null);
  }


  private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    
      // 循环遍历sql语句配置
      for (XNode context : list) {
      final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
      try {
          // 解析配置节点，并构造产生SQL封装体
        statementParser.parseStatementNode();
      } catch (IncompleteElementException e) {
        configuration.addIncompleteStatement(statementParser);
      }
    }
  }

SQL的处理，涉及到对配置信息的解析，以及对这些信息对封装处理上

/**
   * 该方法完成：
   * 1、对sql配置中的数据进行解析提取
   * 2、通过builderAssistant的addMappedStatement方法来对解析到的数据进行封装，并保存到configuration中去
   */
  public void parseStatementNode() {

    // 下面对配置信息进行逐个解析
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");

    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }

    Integer fetchSize = context.getIntAttribute("fetchSize");
    Integer timeout = context.getIntAttribute("timeout");
    String parameterMap = context.getStringAttribute("parameterMap");
    String parameterType = context.getStringAttribute("parameterType");
    Class<?> parameterTypeClass = resolveClass(parameterType);
    String resultMap = context.getStringAttribute("resultMap");
    String resultType = context.getStringAttribute("resultType");
    String lang = context.getStringAttribute("lang");
    LanguageDriver langDriver = getLanguageDriver(lang);

    Class<?> resultTypeClass = resolveClass(resultType);
    String resultSetType = context.getStringAttribute("resultSetType");
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);

    String nodeName = context.getNode().getNodeName();
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

    // Include Fragments before parsing
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    includeParser.applyIncludes(context.getNode());

    // Parse selectKey after includes and remove them.
    processSelectKeyNodes(id, parameterTypeClass, langDriver);
    
    // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    String resultSets = context.getStringAttribute("resultSets");
    String keyProperty = context.getStringAttribute("keyProperty");
    String keyColumn = context.getStringAttribute("keyColumn");
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    if (configuration.hasKeyGenerator(keyStatementId)) {
      keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
      keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
          configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
          ? new Jdbc3KeyGenerator() : new NoKeyGenerator();
    }

    // 通过builderAssistant的addMappedStatement方法来对解析到的数据进行封装
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered, 
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

public MappedStatement addMappedStatement(
      String id,
      SqlSource sqlSource,
      StatementType statementType,
      SqlCommandType sqlCommandType,
      Integer fetchSize,
      Integer timeout,
      String parameterMap,
      Class<?> parameterType,
      String resultMap,
      Class<?> resultType,
      ResultSetType resultSetType,
      boolean flushCache,
      boolean useCache,
      boolean resultOrdered,
      KeyGenerator keyGenerator,
      String keyProperty,
      String keyColumn,
      String databaseId,
      LanguageDriver lang,
      String resultSets) {
      logger.info("解析mapper文件中的sql语句对象 元素 id:" + id);
    if (unresolvedCacheRef) {
      throw new IncompleteElementException("Cache-ref not yet resolved");
    }

    id = applyCurrentNamespace(id, false);
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
        .resource(resource)
        .fetchSize(fetchSize)
        .timeout(timeout)
        .statementType(statementType)
        .keyGenerator(keyGenerator)
        .keyProperty(keyProperty)
        .keyColumn(keyColumn)
        .databaseId(databaseId)
        .lang(lang)
        .resultOrdered(resultOrdered)
        .resulSets(resultSets)
        .resultMaps(getStatementResultMaps(resultMap, resultType, id))
        .resultSetType(resultSetType)
        .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
        .useCache(valueOrDefault(useCache, isSelect))
        .cache(currentCache);

    ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
    if (statementParameterMap != null) {
      statementBuilder.parameterMap(statementParameterMap);
    }

    // 存储解析到到sql语句
    MappedStatement statement = statementBuilder.build();
    // 添加statement对象，对sql 的解析封装完成
    configuration.addMappedStatement(statement);
    return statement;
  }

到此，对sql的解析封装完成，mybatis将mapper中的sql语句封装到MappedStatement对象中，存储到configuration对象的mappedStatements映射中。
Configuration类中的存储SQL封装的集合：

  // 映射的SQL语句
  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");

在执行SQL 的时候还要从上述集合中获取对应的sql相关信息。

3.2 Mapper对象获取

在前面的实例代码中很容易就获取到SqlSession对象了，有一行代码是获取Mapper对象的：

 SysUserDao userDao = sqlSession.getMapper(SysUserDao.class);

先看SqlSession对象的获取，通过上面分析，得到SqlSessionFactory的实现是DefaultSqlSessionFactory类。其openSession方法如下：

/**
   * 创建SqlSession
   * @see org.apache.ibatis.session.SqlSessionFactory#openSession()
   */
  @Override
  public SqlSession openSession() {
      logger.info("open session...");
      return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

/**
   * 获取SqlSession对象
   * @param execType
   * @param level
   * @param autoCommit
   * @return
   */
  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
    
        logger.info("openSessionFromDataSource...");
        
      // environment内包含了数据源和事务相关的配置
      final Environment environment = configuration.getEnvironment();
      
      // 根据environment获取事务管理
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // 从environment中获取DataSource
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      
      // 执行器，通过Excutor来执行SQL语句，Excutor是对Statement的封装
      final Executor executor = configuration.newExecutor(tx, execType);
      
      // 创建了一个DefaultSqlSession对象，传入了执行器
      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();
    }
  }

得到的SqlSession对象是DefaultSqlSession类的对象，现在看其getMapper方法

/**
   * 直接去configuration中找相关的mapper对象
   * @see org.apache.ibatis.session.SqlSession#getMapper(java.lang.Class)
   */
  @Override
  public <T> T getMapper(Class<T> type) {
    logger.info("getMapper name:" + type.getName());
    return configuration.<T>getMapper(type, this);
  }

Configuration类中的getMapper方法：

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

调用了MapperRegistry类中的方法，MapperRegistry主要负责mapper的注册，提供mapper代理功能。

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
     
    // 让代理去找mapper
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
        // 关键： 创建,具体的mapper代理执行类来创建。
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

  public T newInstance(SqlSession sqlSession) {
    // 注意MapperProxy代理类，后续mapper方法执行的时候会到该代理的invoke方法中去  
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

protected T newInstance(MapperProxy<T> mapperProxy) { 
      // 动态代理我们写的dao接口
      return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

mybatis通过jdk的动态代理来为我们创建了mapper接口的实现。需要注意：
MapperProxy这个代理类，后续mapper方法执行的时候会到该代理的invoke方法中去

3.3 Mapper方法执行

 /**
   * MapperProxy在执行时会触发此方法
   * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      // 方法所在的是不是一个类？ Mapper是一个接口，不是类，则跳过
      System.out.println("method.getDeclaringClass():" + method.getDeclaringClass());
      if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    // 交给mapperMethod去执行
    return mapperMethod.execute(sqlSession, args);
  }

MapperMethod是整个代理机制中的核心，对SqlSession中的方法做了封装。

/**
   * 根据sql类型去判断执行，最终还是去调用sqlSession中的方法去完成
   * @param sqlSession
   * @param args
   * @return
   */
  public Object execute(SqlSession sqlSession, Object[] args) {

    // 返回结果
    Object result;

    // insert操作
    if (SqlCommandType.INSERT == command.getType()) {
      // 参数转换处理
      Object param = method.convertArgsToSqlCommandParam(args);
      // 调用sqlSession的insert方法
      result = rowCountResult(sqlSession.insert(command.getName(), param));

      // update
    } else if (SqlCommandType.UPDATE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));


      // delete
    } else if (SqlCommandType.DELETE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));

      // select
    } else if (SqlCommandType.SELECT == command.getType()) {

      // 如果返回void,并且参数有结果处理器
      if (method.returnsVoid() && method.hasResultHandler()) {
        executeWithResultHandler(sqlSession, args);
        result = null;

        // 返回多行结果的
      } else if (method.returnsMany()) {
        // 分析这儿
        result = executeForMany(sqlSession, args);


        // 返回类型是map
      } else if (method.returnsMap()) {
        result = executeForMap(sqlSession, args);
      } else {

        // 否则，就是查询单个对象的
        Object param = method.convertArgsToSqlCommandParam(args);
        result = sqlSession.selectOne(command.getName(), param);
      }

      // flush操作
    } else if (SqlCommandType.FLUSH == command.getType()) {
        result = sqlSession.flushStatements();
    } else {
      // 不匹配，说明，mapper中定义的方法不对
      throw new BindingException("Unknown execution method for: " + command.getName());
    }

    //如果返回值为空 并且方法返回值类型是基础类型 并且不是VOID 则抛出异常
    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;
  }

executeForMany方法：

/**
   * 返回多行查询结果的，主要是调用sqlSession的seleceList方法实现
   * @param sqlSession
   * @param args
   * @param <E>
     * @return
     */
  private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);

    // 如果参数中含有rowBounds则调用分页查询
    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(DefaultSqlSession实现）类上了。看查询操作：

/**
   * 在MapperProxy中调用
   * @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds)
   */
  @Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      // 实际上是然executor去执行了。
      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();
    }
  }

DefaultSqlSession中的selectList 方法

/**
   * 在MapperProxy中调用
   * @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds)
   */
  @Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      // 实际上是然executor去执行了。
      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();
    }
  }

BaseExecutor中query方法：

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

SimpleExecutor中的查询方法：

/**
   * 在SqlSession中调用
   * @see org.apache.ibatis.executor.BaseExecutor#doQuery(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler, org.apache.ibatis.mapping.BoundSql)
   */
  @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对象
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 预编译和基础设置
      stmt = prepareStatement(handler, ms.getStatementLog());
      // StatementHandler封装了Statement,让其处理，并通过resultHandler来完成对结果集对回调处理
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

最终通过结果处理器进行回调，完成对查询到的结果集进行处理并返回。

4、总结

整体上，按照查询涉及到的代码过了一遍，对mybatis的源码有了个大体的了解，后续对其逐步进行解析。

Mybatis源码简析

1、mybatis的主要工作流程

2、mybatis进行数据查询的小实例

3、源码分析

3.1、获取SqlSessionFactory（配置文件解析）

3.2、Mapper对象获取

3.3、Mapper方法执行

4、总结

1、mybatis的主要工作流程

2、mybatis进行数据查询的小实例

3、源码分析

3.1、获取SqlSessionFactory（配置文件解析）

3.2 Mapper对象获取

3.3 Mapper方法执行

4、总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

MyBatis+SpringMVC+SpringBoot

程序员

Java服务器端编程

Java学习笔记