mybatis0080-解析xml文件，创建SqlSessionFactory

雨点打透心脏的1/2处 2022-01-26 20:17 233阅读 0赞

### 文章目录 ###

*   *   *  1. 解析mybatis.xml配置文件，构建SqlSessionFactory
         *  2. mybatis.xml的配置信息都会被解析存储在Configure对象中
         *  3. 创建SqlSessionFactory

### 1. 解析mybatis.xml配置文件，构建SqlSessionFactory ###

String resource = "mybatis.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

注：SqlSessionFactory是通过builder模式构建，SqlSessionFactory在构建的时候逻辑复杂，如果直接放在构造方法中，会让代码令人难以理解，所以使用SqlSessionFactoryBuilder建造者模式构建，将逻辑分开以使个体的逻辑清晰易懂。

### 2. mybatis.xml的配置信息都会被解析存储在Configure对象中 ###

// SqlSessionBuilder
    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
      try { 
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // xml的解析会在parser.parse()中进行
        return build(parser.parse());
      } catch (Exception e) { 
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
      } finally { 
        ErrorContext.instance().reset();
        try { 
          inputStream.close();
        } catch (IOException e) { 
          // Intentionally ignore. Prefer previous error.
        }
      }
    }
    
    // XmlConfigBuilder
    public Configuration parse() { 
      if (parsed) { 
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
      }
      parsed = true;
      // 解析
      parseConfiguration(parser.evalNode("/configuration"));
      return configuration;
    }
    
    // 这里对xml文件中各个配置进行解析
    // properties,settings.... mappers
    private void parseConfiguration(XNode root) { 
      try { 
        //issue #117 read properties first
        propertiesElement(root.evalNode("properties"));
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        typeHandlerElement(root.evalNode("typeHandlers"));
        mapperElement(root.evalNode("mappers"));
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

xml的解析逻辑很多，这边不一一陈述，这边简要说一下mappers元素的解析；这是个很重要的元素，也是mybatis中我们操作最多的元素。

// MapperAnnotationBuilder
    void parseStatement(Method method) { 
        Class<?> parameterTypeClass = getParameterType(method);
        LanguageDriver languageDriver = getLanguageDriver(method);
        SqlSource sqlSource = getSqlSourceFromAnnotations(method, parameterTypeClass, languageDriver);
        if (sqlSource != null) { 
          Options options = method.getAnnotation(Options.class);
          // key
          final String mappedStatementId = type.getName() + "." + method.getName();
          Integer fetchSize = null;
          Integer timeout = null;
          StatementType statementType = StatementType.PREPARED;
          ResultSetType resultSetType = ResultSetType.FORWARD_ONLY;
          SqlCommandType sqlCommandType = getSqlCommandType(method);
          boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
          boolean flushCache = !isSelect;
          boolean useCache = isSelect;
    
          KeyGenerator keyGenerator;
          String keyProperty = "id";
          String keyColumn = null;
          if (SqlCommandType.INSERT.equals(sqlCommandType) || SqlCommandType.UPDATE.equals(sqlCommandType)) { 
            // first check for SelectKey annotation - that overrides everything else
            SelectKey selectKey = method.getAnnotation(SelectKey.class);
            if (selectKey != null) { 
              keyGenerator = handleSelectKeyAnnotation(selectKey, mappedStatementId, getParameterType(method), languageDriver);
              keyProperty = selectKey.keyProperty();
            } else if (options == null) { 
              keyGenerator = configuration.isUseGeneratedKeys() ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
            } else { 
              keyGenerator = options.useGeneratedKeys() ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
              keyProperty = options.keyProperty();
              keyColumn = options.keyColumn();
            }
          } else { 
            keyGenerator = NoKeyGenerator.INSTANCE;
          }
    
          if (options != null) { 
            if (FlushCachePolicy.TRUE.equals(options.flushCache())) { 
              flushCache = true;
            } else if (FlushCachePolicy.FALSE.equals(options.flushCache())) { 
              flushCache = false;
            }
            useCache = options.useCache();
            fetchSize = options.fetchSize() > -1 || options.fetchSize() == Integer.MIN_VALUE ? options.fetchSize() : null; //issue #348
            timeout = options.timeout() > -1 ? options.timeout() : null;
            statementType = options.statementType();
            resultSetType = options.resultSetType();
          }
    
          String resultMapId = null;
          ResultMap resultMapAnnotation = method.getAnnotation(ResultMap.class);
          if (resultMapAnnotation != null) { 
            String[] resultMaps = resultMapAnnotation.value();
            StringBuilder sb = new StringBuilder();
            for (String resultMap : resultMaps) { 
              if (sb.length() > 0) { 
                sb.append(",");
              }
              sb.append(resultMap);
            }
            resultMapId = sb.toString();
          } else if (isSelect) { 
            resultMapId = parseResultMap(method);
          }
    
          assistant.addMappedStatement(
              mappedStatementId,
              sqlSource,
              statementType,
              sqlCommandType,
              fetchSize,
              timeout,
              // ParameterMapID
              null,
              parameterTypeClass,
              resultMapId,
              getReturnType(method),
              resultSetType,
              flushCache,
              useCache,
              // TODO gcode issue #577
              false,
              keyGenerator,
              keyProperty,
              keyColumn,
              // DatabaseID
              null,
              languageDriver,
              // ResultSets
              options != null ? nullOrEmpty(options.resultSets()) : null);
        }
      }
    
    // MapperBuilderAssistant
    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) { 
    
        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)
            .resultSets(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);
        }
    	// value
        MappedStatement statement = statementBuilder.build();
        configuration.addMappedStatement(statement);
        return statement;
      }

注：在解析mappers标签的时候，会将每个mapper接口的每个方法解析为一个MappedStatement 放在configuration的mappedStatements中，key为mapper接口名加方法名。

### 3. 创建SqlSessionFactory ###

// 解析完创建SqlSessionFactory
    public SqlSessionFactory build(Configuration config) { 
      return new DefaultSqlSessionFactory(config);
    }

注：xml元素解析完成以后，返回DefaultSqlSessionFactory的实例。