MyBatis原理分析之获取SqlSessionFactory

桃扇骨 2022-09-02 11:35 264阅读 0赞

**流程原理分析系列：**  
[MyBatis原理分析之获取SqlSessionFactory][MyBatis_SqlSessionFactory]  
[MyBatis原理分析之获取SqlSession][MyBatis_SqlSession]  
[MyBatis原理分析之获取Mapper接口的代理对象][MyBatis_Mapper]  
[MyBatis原理分析之查询单个对象][MyBatis]

**MyBatis的执行原理分为如下四步:**

*  ① 获取SqlSessionFactory
 *  ② 获取SqlSession
 *  ③ 获取mapper的代理对象
 *  ④ sqlsession进行具体CRUD过程

**这里又分为三种场景：**

*  ① 无spring环境
    
    > 自己手动根据mybatis配置文件获取SqlSessionFactory和SqlSession
 *  ② 传统ssm环境
    
    > 通常在applicationContext.xml中注册了SqlSessionFactory和SqlSession
 *  ③ SpringBoot环境
    
    > SpringBoot做了自动化配置，当然你也可以自定义注册

这里咱们从第一种场景(无spring)进行分析。

# 【1】抽象类BaseBuilder与子类 #

**BaseBuilder 有如下子类：**

*  XMLConfigBuilder
    
    > 用来解析mybatis全局配置，初步获取Configuration实例
 *  XMLMapperBuilder
    
    > 解析mapper.xml文件，每个XMLMapperBuilder实例有成员实例MapperBuilderAssistant
 *  MapperBuilderAssistant
 *  XMLStatementBuilder
    
    > 解析mapper.xml中每个`select|insert|update|delete`结点  
    > 有成员属性MapperBuilderAssistant builderAssistant
 *  XMLScriptBuilder
    
    > XMLScriptBuilder和SqlSourceBuilder获取sqlsource片段
 *  SqlSourceBuilder

这里需要注意的是，上述子类在实例化时，会显示调用父类有参构造方法`super(configuration);`来为当前子类实例拥有的来自于父类的成员属性赋值。如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center]

## ① 抽象父类BaseBuilder ##

如下所示，有属性configuration、typeAliasRegistry、typeHandlerRegistry，上述子类都有这三个成员属性。在创建configuration实例时，会进行初始化。

public abstract class BaseBuilder { 
      protected final Configuration configuration;
      protected final TypeAliasRegistry typeAliasRegistry;
      protected final TypeHandlerRegistry typeHandlerRegistry;
    
      public BaseBuilder(Configuration configuration) { 
        this.configuration = configuration;
        this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
        this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
      }
      //...
    }

**typeAliasRegistry**维护了一个map`private final Map<String, Class<?>> TYPE_ALIASES = new HashMap<>();`，里面放了类型别名与class类型。如`(string,class java.lang.String)`,参考其源码可发现在其实例化的时候就注册了值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]  
**typeHandlerRegistry**维护了了六个`final Map`，同样在实例化时就进行了Map初始化。

public final class TypeHandlerRegistry { 
    
      private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<>(JdbcType.class);
      private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<>();
      private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);
      private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<>();
    
      private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();
    
      private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;
    
      public TypeHandlerRegistry() { 
        register(Boolean.class, new BooleanTypeHandler());
        register(boolean.class, new BooleanTypeHandler());
        register(JdbcType.BOOLEAN, new BooleanTypeHandler());
        register(JdbcType.BIT, new BooleanTypeHandler());
    
        register(Byte.class, new ByteTypeHandler());
        register(byte.class, new ByteTypeHandler());
        register(JdbcType.TINYINT, new ByteTypeHandler());
    
        register(Short.class, new ShortTypeHandler());
        register(short.class, new ShortTypeHandler());
        register(JdbcType.SMALLINT, new ShortTypeHandler());
    
        register(Integer.class, new IntegerTypeHandler());
        register(int.class, new IntegerTypeHandler());
        register(JdbcType.INTEGER, new IntegerTypeHandler());
    
        register(Long.class, new LongTypeHandler());
        register(long.class, new LongTypeHandler());
    
        register(Float.class, new FloatTypeHandler());
        register(float.class, new FloatTypeHandler());
        register(JdbcType.FLOAT, new FloatTypeHandler());
    
        register(Double.class, new DoubleTypeHandler());
        register(double.class, new DoubleTypeHandler());
        register(JdbcType.DOUBLE, new DoubleTypeHandler());
    
        register(Reader.class, new ClobReaderTypeHandler());
        register(String.class, new StringTypeHandler());
        register(String.class, JdbcType.CHAR, new StringTypeHandler());
        register(String.class, JdbcType.CLOB, new ClobTypeHandler());
        register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
        register(String.class, JdbcType.LONGVARCHAR, new ClobTypeHandler());
        register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
        register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
        register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
        register(JdbcType.CHAR, new StringTypeHandler());
        register(JdbcType.VARCHAR, new StringTypeHandler());
        register(JdbcType.CLOB, new ClobTypeHandler());
        register(JdbcType.LONGVARCHAR, new ClobTypeHandler());
        register(JdbcType.NVARCHAR, new NStringTypeHandler());
        register(JdbcType.NCHAR, new NStringTypeHandler());
        register(JdbcType.NCLOB, new NClobTypeHandler());
    
        register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
        register(JdbcType.ARRAY, new ArrayTypeHandler());
    
        register(BigInteger.class, new BigIntegerTypeHandler());
        register(JdbcType.BIGINT, new LongTypeHandler());
    
        register(BigDecimal.class, new BigDecimalTypeHandler());
        register(JdbcType.REAL, new BigDecimalTypeHandler());
        register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
        register(JdbcType.NUMERIC, new BigDecimalTypeHandler());
    
        register(InputStream.class, new BlobInputStreamTypeHandler());
        register(Byte[].class, new ByteObjectArrayTypeHandler());
        register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
        register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
        register(byte[].class, new ByteArrayTypeHandler());
        register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
        register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
        register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
        register(JdbcType.BLOB, new BlobTypeHandler());
    
        register(Object.class, UNKNOWN_TYPE_HANDLER);
        register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
        register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
    
        register(Date.class, new DateTypeHandler());
        register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
        register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
        register(JdbcType.TIMESTAMP, new DateTypeHandler());
        register(JdbcType.DATE, new DateOnlyTypeHandler());
        register(JdbcType.TIME, new TimeOnlyTypeHandler());
    
        register(java.sql.Date.class, new SqlDateTypeHandler());
        register(java.sql.Time.class, new SqlTimeTypeHandler());
        register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());
    
        register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());
    
        register(Instant.class, InstantTypeHandler.class);
        register(LocalDateTime.class, LocalDateTimeTypeHandler.class);
        register(LocalDate.class, LocalDateTypeHandler.class);
        register(LocalTime.class, LocalTimeTypeHandler.class);
        register(OffsetDateTime.class, OffsetDateTimeTypeHandler.class);
        register(OffsetTime.class, OffsetTimeTypeHandler.class);
        register(ZonedDateTime.class, ZonedDateTimeTypeHandler.class);
        register(Month.class, MonthTypeHandler.class);
        register(Year.class, YearTypeHandler.class);
        register(YearMonth.class, YearMonthTypeHandler.class);
        register(JapaneseDate.class, JapaneseDateTypeHandler.class);
    
        // issue #273
        register(Character.class, new CharacterTypeHandler());
        register(char.class, new CharacterTypeHandler());
      }
    //...
    }

## ② final修饰符 ##

为什么这里提到final修饰符呢？跟踪源码会看到上面提到的BaseBuilder的几个子类，包括configuration类中很多成员都是final。

**final修饰符只能够作用在类、方法和变量上。它的作用是所有被final修饰的内容不能被改变。**

*  final类不能被继承。
 *  final变量一旦被赋值就不能被改变。
 *  final方法不能被重写(可以被重载)。
 *  final变量允许在构造函数中对其进行赋值

**注意**：如果一个final变量是对象的引用，这意味着该引用的值是一定不会改变的，但是对象的成员值可以改变。

# 【2】源码分析 #

**源码分析时序图如下所示：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center 1]

## ① SqlSessionFactoryBuilder ##

SqlSessionFactoryBuilder提供了诸多重载方法build来创建DefaultSqlSessionFactory。更多参考[MyBatis中SqlSessionFactory和SqlSession简解][MyBatis_SqlSessionFactory_SqlSession]

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
        try { 
          XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
          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 ##

**这个类主要作用如下：**

*  ① 创建configuration实例，进行初步初始化
 *  ② 解析mybatis全局配置，对configuration做进一步赋值

public Configuration parse() { 
        if (parsed) { 
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
      }
    
      private void parseConfiguration(XNode root) { 
        try { 
          // issue #117 read properties first
          propertiesElement(root.evalNode("properties"));
          Properties settings = settingsAsProperties(root.evalNode("settings"));
          loadCustomVfs(settings);
          loadCustomLogImpl(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);
        }
      }

熟系mybatis全局配置的同学应该对上面代码很容易理解，解析mybatis的全局配置，为configuration实例属性赋值。

**解释如下：**

*  解析properties结点
 *  解析settings结点
 *  解析typeAliases结点
 *  解析plugins结点
 *  解析objectFactory结点
 *  解析objectWrapperFactory结点
 *  解析reflectorFactory结点
 *  根据settings结点为configuration设置对应的成员变量
 *  解析environments结点
 *  解析databaseIdProvider结点
 *  解析typeHandlers结点
 *  解析mappers结点-这个也是我们着重关注的

**从 mapperElement(root.evalNode(“mappers”))方法中会根据[映射器mappers][mappers]的配置类型进行不同的处理。代码如下所示：**

private void mapperElement(XNode parent) throws Exception { 
        if (parent != null) { 
          for (XNode child : parent.getChildren()) { 
          //解析包
            if ("package".equals(child.getName())) { 
              String mapperPackage = child.getStringAttribute("name");
              configuration.addMappers(mapperPackage);
            } else { 
         		//获取resource url 或者完全限定类名
              String resource = child.getStringAttribute("resource");
              String url = child.getStringAttribute("url");
              String mapperClass = child.getStringAttribute("class");
              //解析resource
              if (resource != null && url == null && mapperClass == null) { 
                ErrorContext.instance().resource(resource);
                InputStream inputStream = Resources.getResourceAsStream(resource);
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                mapperParser.parse();
                //解析url
              } else if (resource == null && url != null && mapperClass == null) { 
                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.");
              }
            }
          }
        }
      }

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

## ③ XMLMapperBuilder ##

每一个mapper资源都会创建一个`XMLMapperBuilder`实例，而每一个`XMLMapperBuilder`实例都会有一个私有的成员实例`MapperBuilderAssistant` 。

**这里从其构造函数即可看出：**

private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map<String, XNode> sqlFragments) { 
     super(configuration);
     this.builderAssistant = new MapperBuilderAssistant(configuration, resource);
     this.parser = parser;
     this.sqlFragments = sqlFragments;
     this.resource = resource;
    }

### 核心方法parse ###

**源码如下：**

public void parse() { 
        if (!configuration.isResourceLoaded(resource)) { 
          configurationElement(parser.evalNode("/mapper"));
          configuration.addLoadedResource(resource);
          bindMapperForNamespace();
        }
    //下面代码可以理解为mybatis"后手"，对前面不能确定的ResultMap、ChacheRef、Statement再次处理
        parsePendingResultMaps();
    
    //若是在某个地方看到了parsePendingChacheRefs()，也是正确的。这是mybatis框架开发工程师写错单词了；不过已经修正
        parsePendingCacheRefs();
        parsePendingStatements();
      }

**代码解释如下**

*  ① 判断当前资源是否被加载。通过判断configuration实例的成员属性`Set<String> loadedResources = new HashSet<>()`是否contains当前resource来判断
 *  ② 如果没有加载，执行以下步骤
    
     *  ③ 解析mapper结点
     *  ④ 将当前`resource`放到`configuration`实例中`Set<String> loadedResources = new HashSet<>()`属性里
     *  ⑤ bindMapperForNamespace();
        
         *  判断当前resource对应的namespace是否已经在configuration实例的MapperRegistry成员实例的knownMappers集合中。`Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>()`
         *  如果不在，则执行以下步骤
            
             *  将`"namespace:" + namespace`添加到configuration实例的成员loadedResources中
             *  `configuration.addMapper(boundType)`;
                
                 *  `knownMappers.put(type, new MapperProxyFactory<>(type))`
                 *  创建MapperAnnotationBuilder实例，解析命名空间对应的mapper接口(也就是解析接口上面的注解)
 *  ⑥ 尝试处理待解决的ResultMaps
 *  ⑦ 尝试处理待解决的CacheRefs
 *  ⑧ 尝试处理待解决的Statements

### 核心方法configurationElement ###

private void configurationElement(XNode context) {
        try {
          String namespace = context.getStringAttribute("namespace");
          if (namespace == null || namespace.isEmpty()) {
            throw new BuilderException("Mapper's namespace cannot be empty");
          }
          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"));
          buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
        } catch (Exception e) {
          throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
        }
      }

**代码解释如下：**

*  ① 获取namespace
 *  ② 为当前mapper的`builderAssistant`(`MapperBuilderAssistant`实例，是`XMLMapperBuilder`成员变量)设置`namespace`
 *  ③ 解析cache-ref结点，处理缓存引用
 *  ④ 解析cache结点，为当前namespace创建缓存实例
 *  ⑤ 解析parameterMap结点，参数映射
 *  ⑥ 解析resultMap结点，结果映射
 *  ⑦ 解析sql结点，SQL片段
 *  ⑧ 解析`select|insert|update|delete`结点，这里最终会创建一个个`MappedStatement`放入`configuration`实例的`Map<String, MappedStatement> mappedStatements`中

关于缓存解析参考博文[Mybatis二级缓存创建过程与使用详解][Mybatis]。

### 核心方法parameterMapElement ###

参数映射解析

private void parameterMapElement(List<XNode> list) { 
        for (XNode parameterMapNode : list) { 
          String id = parameterMapNode.getStringAttribute("id");
          String type = parameterMapNode.getStringAttribute("type");
          Class<?> parameterClass = resolveClass(type);
          List<XNode> parameterNodes = parameterMapNode.evalNodes("parameter");
          List<ParameterMapping> parameterMappings = new ArrayList<>();
          for (XNode parameterNode : parameterNodes) { 
            String property = parameterNode.getStringAttribute("property");
            String javaType = parameterNode.getStringAttribute("javaType");
            String jdbcType = parameterNode.getStringAttribute("jdbcType");
            String resultMap = parameterNode.getStringAttribute("resultMap");
            String mode = parameterNode.getStringAttribute("mode");
            String typeHandler = parameterNode.getStringAttribute("typeHandler");
            Integer numericScale = parameterNode.getIntAttribute("numericScale");
            ParameterMode modeEnum = resolveParameterMode(mode);
            Class<?> javaTypeClass = resolveClass(javaType);
            JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
            Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
            ParameterMapping parameterMapping = builderAssistant.buildParameterMapping(parameterClass, property, javaTypeClass, jdbcTypeEnum, resultMap, modeEnum, typeHandlerClass, numericScale);
            parameterMappings.add(parameterMapping);
          }
          builderAssistant.addParameterMap(id, parameterClass, parameterMappings);
        }
      }

**一个parameterMap结点格式可能如下：**

**代码解释如下：**

*  ① 遍历循环每一个parameterMap结点
 *  ② 解析parameterMap结点的id 、type属性并遍历循环其子结点parameter
 *  ③ 解析每一个子结点parameter的属性，封装为一个`ParameterMapping` 实例对象，放到list集合`List<ParameterMapping> parameterMappings`中
 *  ④ 当前调用parameterMap结点解析完，调用 `builderAssistant.addParameterMap(id, parameterClass, parameterMappings);`。
    
     *  ⑤ `new ParameterMap.Builder(configuration, id, parameterClass, parameterMappings).build();`获取parameterMap实例对象然后放入configuration实例的成员属性`Map<String, ParameterMap> parameterMaps`集合中。放入格式为：`namespace+'.'+id=parameterMap`
        
            public ParameterMap addParameterMap(String id, Class<?> parameterClass, List<ParameterMapping> parameterMappings) { 
                id = applyCurrentNamespace(id, false);
                ParameterMap parameterMap = new ParameterMap.Builder(configuration, id, parameterClass, parameterMappings).build();
                configuration.addParameterMap(parameterMap);
                return parameterMap;
              }
        
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 1]
 *  ⑥ 重复执行①-⑤

这里引申看一下ParameterMap类。这个类比较有意思，`其有三个成员属性以及一个静态嵌套类Builder` (注意这里我们没有称之为内部类)。

//...
    public class ParameterMap { 
      private String id;
      private Class<?> type;
      private List<ParameterMapping> parameterMappings;
      private ParameterMap() { 
      }
      public static class Builder { 
        private ParameterMap parameterMap = new ParameterMap();
    	//为parameterMap 实例属性赋值
        public Builder(Configuration configuration, String id, Class<?> type, List<ParameterMapping> parameterMappings) { 
          parameterMap.id = id;
          parameterMap.type = type;
          parameterMap.parameterMappings = parameterMappings;
        }
        public Class<?> type() { 
          return parameterMap.type;
        }
        public ParameterMap build() { 
          //lock down collections
          parameterMap.parameterMappings = Collections.unmodifiableList(parameterMap.parameterMappings);
          return parameterMap;
        }
      }
    //...
    }

> 内部类的实例化对象需要绑定一个外围类的实例化对象，而静态嵌套类的实例化对象不能也无法绑定外围类的实例化对象。  
> 此外MappedStatement、ResultMap也有各自的Builder来创建mappedStatement与resultMap实例对象。

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

### 核心方法buildStatementFromContext ###

private void buildStatementFromContext(List<XNode> list) { 
        if (configuration.getDatabaseId() != null) { 
          buildStatementFromContext(list, configuration.getDatabaseId());
        }
        buildStatementFromContext(list, null);
      }

**代码解释如下：**

*  ① 判断是否配置了DatabaseId，如果配置了则执行②，否则执行③；
 *  ② 执行`buildStatementFromContext(list, configuration.getDatabaseId());`
 *  ③ 执行`buildStatementFromContext(list, null);`

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) { 
        for (XNode context : list) { 
          final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
          try { 
            statementParser.parseStatementNode();
          } catch (IncompleteElementException e) { 
            configuration.addIncompleteStatement(statementParser);
          }
        }
      }

**代码解释如下：**

*  ①循环遍历`select|insert|update|delete`结点
 *  ② 为每个结点创建XMLStatementBuilder 然后解析
 *  ③ 如果当前结点解析过程中报了异常，则将当前statementParser放入configuration实例的`Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();`属性中，然后留给mybatis的“后手”`parsePendingResultMaps`解决

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

## ④ XMLStatementBuilder ##

public void parseStatementNode() { 
        String id = context.getStringAttribute("id");
        String databaseId = context.getStringAttribute("databaseId");
    
        if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { 
          return;
        }
    
        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());
    
        String parameterType = context.getStringAttribute("parameterType");
        Class<?> parameterTypeClass = resolveClass(parameterType);
    
        String lang = context.getStringAttribute("lang");
        LanguageDriver langDriver = getLanguageDriver(lang);
    
        // Parse selectKey after includes and remove them.
        processSelectKeyNodes(id, parameterTypeClass, langDriver);
    
        // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
        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))
              ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
        }
    
        SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
        StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
        Integer fetchSize = context.getIntAttribute("fetchSize");
        Integer timeout = context.getIntAttribute("timeout");
        String parameterMap = context.getStringAttribute("parameterMap");
        String resultType = context.getStringAttribute("resultType");
        Class<?> resultTypeClass = resolveClass(resultType);
        String resultMap = context.getStringAttribute("resultMap");
        String resultSetType = context.getStringAttribute("resultSetType");
        ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
        if (resultSetTypeEnum == null) { 
          resultSetTypeEnum = configuration.getDefaultResultSetType();
        }
        String keyProperty = context.getStringAttribute("keyProperty");
        String keyColumn = context.getStringAttribute("keyColumn");
        String resultSets = context.getStringAttribute("resultSets");
    
        builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
            fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
            resultSetTypeEnum, flushCache, useCache, resultOrdered,
            keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
      }

**代码解释如下：**

*  ① 获取当前结点配置的 id和`databaseId`属性
 *  ② `databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)`根据全局配置的requiredDatabaseId和当前结点的databaseId判断是否解析当前结点
    
     *  ③ 如果configuration配置了`requiredDatabaseId`且`requiredDatabaseId.equals(databaseId)`则进行解析否则不解析当前结点
     *  ④ 如果configuration没有配置requiredDatabaseId但是当前结点配置了databaseId，不解析当前结点直接返回
     *  ⑤ 如果configuration已经有了当前id对应的MappedStatement，则不解析当前结点直接返回
 *  ⑥ 解析SqlCommandType与isSelect、flushCache、useCache、resultOrdered
 *  ⑦ 解析`<include/>`结点、`parameterType`、`<selectKey/>`、`keyGenerator`最后获取`sqlSource`
 *  ⑧ 解析`StatementType`，默认是`PREPARED`
 *  ⑨ 解析`fetchSize、timeout、parameterMap、resultType、resultMap、resultSetType、keyProperty、keyColumn、resultSets`
 *  ⑩ `builderAssistant.addMappedStatement`获取MappedStatement并放入configuration的`protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>`集合中

### SqlSource有哪些信息？ ###

顾名思义，包含了当前节点解析的SQL语句、参数映射以及全局配置实例configuration。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 2]

### BoundSql ###

与`SqlSource`紧密相关的是`BoundSql`。与`SqlSource`不同的是,`BoundSql`多了参数值对象(可能是单个值，也可能是map)。

BoundSql主要属性和构造函数如下：

public class BoundSql { 
    
      private String sql;
      private List<ParameterMapping> parameterMappings;
      private Object parameterObject;
      private Map<String, Object> additionalParameters;
      private MetaObject metaParameters;
    
      public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) { 
        this.sql = sql;
        this.parameterMappings = parameterMappings;
        this.parameterObject = parameterObject;
        this.additionalParameters = new HashMap<String, Object>();
        this.metaParameters = configuration.newMetaObject(additionalParameters);
      }
    //...
    }

**一个BoundSql实例可能如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 3]

关于结点属性配置详情说明更多参考[MyBatis中XML映射器使用详解][MyBatis_XML]

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

## ⑤ 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);
        }
    
        MappedStatement statement = statementBuilder.build();
        configuration.addMappedStatement(statement);
        return statement;
      }

**代码解释如下：**

*  ① `applyCurrentNamespace`给ID加上namespace
 *  ② `new MappedStatement.Builder`创建一个`MappedStatement`实例，先在构造方法中进行初步复制，然后使用方法参数给`MappedStatement`实例进行进一步赋值，注意哦，这里同样设置了结点的二级缓存引用`cache(currentCache)`
 *  ③ 尝试获取ParameterMap ，如果不为null，则更新`MappedStatement`实例的parameterMap属性值
 *  ④ 最后得到的MappedStatement 实例，放到configuration实例的`Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>`，会放入两组对象，如下所示：
    
        {com.mybatis.dao.EmployeeMapper.getEmpByIds=org.apache.ibatis.mapping.MappedStatement@279fedbd, 
        getEmpByIds=org.apache.ibatis.mapping.MappedStatement@279fedbd}

如下图所示，MappedStatement 实例可能如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 4]

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

## ⑥ 解析完mapper结点后的动作 ##

**再回头看下方法：**

### 核心方法bindMapperForNamespace ###

`XMLMapperBuilder`的`bindMapperForNamespace`如下：

private void bindMapperForNamespace() { 
        String namespace = builderAssistant.getCurrentNamespace();
        if (namespace != null) { 
          Class<?> boundType = null;
          try { 
            boundType = Resources.classForName(namespace);
          } catch (ClassNotFoundException e) { 
            // ignore, bound type is not required
          }
          if (boundType != null && !configuration.hasMapper(boundType)) { 
            // Spring may not know the real resource name so we set a flag
            // to prevent loading again this resource from the mapper interface
            // look at MapperAnnotationBuilder#loadXmlResource
            configuration.addLoadedResource("namespace:" + namespace);
            configuration.addMapper(boundType);
          }
        }
      }

**代码解释如下：**

*  ① 获取builderAssistant的namespace，如果为null直接结束；
 *  ② 解析namespace对应的Class类型boundType ；
 *  ③ 如果boundType 不为null并且configuration实例的`MapperRegistry mapperRegistry = new MapperRegistry(this);`成员实例的`private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();`中没有boundType，执行如下步骤：
    
     *  ④ 以`"namespace:"+namespace`为值放入configuration实例的`Set<String> loadedResources = new HashSet<>();`成员属性中
     *  ⑤ `mapperRegistry.addMapper(type);`

### 核心方法MapperRegistry.addMapper(Class type) ###

**方法源码如下：**

public <T> void addMapper(Class<T> type) { 
      if (type.isInterface()) { 
        if (hasMapper(type)) { 
          throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
        }
        boolean loadCompleted = false;
        try { 
          knownMappers.put(type, new MapperProxyFactory<>(type));
          // It's important that the type is added before the parser is run
          // otherwise the binding may automatically be attempted by the
          // mapper parser. If the type is already known, it won't try.
          MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
          parser.parse();
          loadCompleted = true;
        } finally { 
          if (!loadCompleted) { 
            knownMappers.remove(type);
          }
        }
      }
    }

**代码解释如下：**

*  ① 判断当前type是否为接口，如果不是直接结束；
 *  ② 判断`Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>()`是否已经有了type，如果是，则抛出异常；
 *  ③ 为当前接口创建MapperProxyFactory实例，然后放入knownMappers 中-`knownMappers.put(type, new MapperProxyFactory<>(type));`
    
    > `{interface com.mybatis.dao.EmployeeMapper=org.apache.ibatis.binding.MapperProxyFactory@6913c1fb}`
 *  ④ 为当前接口创建MapperAnnotationBuilder，然后进行解析(mapper接口上面是可以加注解的)

至于后面的`parsePendingResultMaps(); parsePendingCacheRefs(); parsePendingStatements();`，则是mybatis提供的`后手|二次解析`，获取configuration实例的如下属性，然后遍历进行二次处理。

protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();
      protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<>();
      protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<>();

参考博文：  
[MyBatis二级缓存创建过程与使用详解][Mybatis]  
[MyBatis全局配置文件实例与详解][mappers]  
[MyBatis中XML映射器使用详解][MyBatis_XML]  
[Mybatis中基于注解的增删改查实践][Mybatis 1]  
[Mybatis中使用xml进行增删改查实践][Mybatis_xml]

[MyBatis_SqlSessionFactory]: https://janus.blog.csdn.net/article/details/119334417
[MyBatis_SqlSession]: https://editor.csdn.net/md/?articleId=119485997
[MyBatis_Mapper]: https://blog.csdn.net/J080624/article/details/119510355
[MyBatis]: https://janus.blog.csdn.net/article/details/53203688
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/ff8721abe9b14cf58977bd171c9eb298.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]: /images/20220829/d880322074e34e17994e8e376616901c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/d71d58e0b7ae47faab355d41d102ffa3.png
[MyBatis_SqlSessionFactory_SqlSession]: https://janus.blog.csdn.net/article/details/53437272
[mappers]: https://janus.blog.csdn.net/article/details/69470209
[Mybatis]: https://janus.blog.csdn.net/article/details/78668649
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 1]: /images/20220829/61cb623e0a504d5a89c2d162482cb68d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 2]: /images/20220829/0a4f8cd4624640298b9bee044b62e725.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 3]: /images/20220829/0139a12a195e4a889824c4843ed6be93.png
[MyBatis_XML]: https://janus.blog.csdn.net/article/details/70196848
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 4]: /images/20220829/d310806fb74249958dfa6046095bc631.png
[Mybatis 1]: https://janus.blog.csdn.net/article/details/53374351
[Mybatis_xml]: https://janus.blog.csdn.net/article/details/53374067