mybatis之解析mybatis-config全局配置文件过程分析

一时失言乱红尘 2022-10-13 05:18 155阅读 0赞

## 1：测试环境准备 ##

在[这篇文章][Link 1]基础上进行分析。

## 2：分析 ##

入口`org.apache.ibatis.session.SqlSessionFactoryBuilder#build(java.io.InputStream, java.lang.String, java.util.Properties)`。我们就从这里开始分析。这里贴下测试代码：

private TestTypehandlerMapper testTypehandlerMapper;
    private SqlSession sqlSession;
    
    @Before
    public void setUp() throws Exception { 
        String resource = "mybatis/mybatis-config-1.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        this.sqlSession = sqlSession;
        this.testTypehandlerMapper = sqlSession.getMapper(TestTypehandlerMapper.class);
    }

在代码`SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);`处打上断点开始，开始调试，首先执行到代码：

org.apache.ibatis.session.SqlSessionFactoryBuilder#build(java.io.InputStream)
    public SqlSessionFactory build(InputStream inputStream) { 
      // <202107061531>
      return build(inputStream, null, null);
    }

`<202107061531>`处源码如下：

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
      try { 
        // <202107061542>
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // <202107061543>
        return build(parser.parse());
      } catch (Exception e) { 
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
      } finally { 
        ErrorContext.instance().reset();
        try { 
          inputStream.close();
        } catch (IOException e) { 
        }
      }
    }

`<202107061542>`处是创建XMLConfigBuilder对象，源码如下：

public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) { 
      // 构造解析器，并继续调用构造函数，关于解析器，具体参考:4：解析器XPathParser
      this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
    }
    private XMLConfigBuilder(XPathParser parser, String environment, Properties props) { 
       // 调用父类，BaseBuidler的构造函数，具体参考：3.1：BaseBuilder构造函数
       super(new Configuration());
       // 错误上下文
       ErrorContext.instance().resource("SQL Mapper Configuration");
       // 将用户传入的properties设置到configuration的variables：
       // protected Properties variables = new Properties();中
       this.configuration.setVariables(props);
       // 设置解析标记为没有解析
       this.parsed = false;
       // 设置environment
       this.environment = environment;
       // 设置解析器
       this.parser = parser;
     }

XMLConfigBuilder类继承自`org.apache.ibatis.builder.BaseBuilder`，关于该类具体参考`3：BaseBuilder`。`<202107061543>`处build方法源码如下，构造SqlSessionFactory并返回：

public SqlSessionFactory build(Configuration config) { 
      return new DefaultSqlSessionFactory(config);
    }

`<202107061543>`处`parser.parse()`具体参考`5：XMLConfigBuilder#parse`。

## 3：BaseBuilder ##

### 3.1：BaseBuilder构造函数 ###

org.apache.ibatis.builder.BaseBuilder#BaseBuilder
    protected final Configuration configuration;
    protected final TypeAliasRegistry typeAliasRegistry;
    protected final TypeHandlerRegistry typeHandlerRegistry;
    
    public BaseBuilder(Configuration configuration) { 
      // <202107061557>
      // 封装的是config全局配置文件中<configuration>标签中的信息
      this.configuration = configuration;
      // 将配置中的TypeAliasRegistry信息使用单独的变量typeAliasRegistry存储，方便使用
      this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
      // 将配置中的TypeHandlerRegistry信息使用单独的变量typeHandlerRegistry存储，方便使用
      this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
    }

`<202107061557>`处封装的是config全局配置文件中`<configuration>`标签中的信息,比如进行了如下配置：

然后在`org.apache.ibatis.session.SqlSessionFactoryBuilder#build(java.io.InputStream, java.lang.String, java.util.Properties)`中打断点查看配置信息。

*  typeAliases  
    `注意包含了系统的默认别名配置`，红框中为我们通过package方式配置生成的别名（多图）：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][20210706161507544.png]
 *  typeHandlers  
    红框中为我们自己定义的，其他为系统自带的：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]
 *  plugins  
    这是mybatis让我们扩展使用的，因此没有默认提供。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 2]

### 3.2：各种工具类 ###

*  xxxValueOf

protected Boolean booleanValueOf(String value, Boolean defaultValue) { 
      return value == null ? defaultValue : Boolean.valueOf(value);
    }
    
    protected Integer integerValueOf(String value, Integer defaultValue) { 
      return value == null ? defaultValue : Integer.valueOf(value);
    }
    
    protected Set<String> stringSetValueOf(String value, String defaultValue) { 
      value = (value == null ? defaultValue : value);
      return new HashSet<String>(Arrays.asList(value.split(",")));
    }

*  org.apache.ibatis.builder.BaseBuilder\#resolveJdbcType  
    通过JdbcType字面量获取对应的JdbcType枚举：

protected JdbcType resolveJdbcType(String alias) { 
      if (alias == null) return null;
      try { 
        return JdbcType.valueOf(alias);
      } catch (IllegalArgumentException e) { 
        throw new BuilderException("Error resolving JdbcType. Cause: " + e, e);
      }
    }

`org.apache.ibatis.type.JdbcType`定义如下：

public enum JdbcType { 
      ARRAY(Types.ARRAY),
      BIT(Types.BIT),
      TINYINT(Types.TINYINT),
      SMALLINT(Types.SMALLINT),
      INTEGER(Types.INTEGER),
      BIGINT(Types.BIGINT),
      FLOAT(Types.FLOAT),
      REAL(Types.REAL),
      DOUBLE(Types.DOUBLE),
      NUMERIC(Types.NUMERIC),
      DECIMAL(Types.DECIMAL),
      CHAR(Types.CHAR),
      VARCHAR(Types.VARCHAR),
      LONGVARCHAR(Types.LONGVARCHAR),
      DATE(Types.DATE),
      TIME(Types.TIME),
      TIMESTAMP(Types.TIMESTAMP),
      BINARY(Types.BINARY),
      VARBINARY(Types.VARBINARY),
      LONGVARBINARY(Types.LONGVARBINARY),
      NULL(Types.NULL),
      OTHER(Types.OTHER),
      BLOB(Types.BLOB),
      CLOB(Types.CLOB),
      BOOLEAN(Types.BOOLEAN),
      CURSOR(-10), // Oracle
      UNDEFINED(Integer.MIN_VALUE + 1000),
      NVARCHAR(Types.NVARCHAR), // JDK6
      NCHAR(Types.NCHAR), // JDK6
      NCLOB(Types.NCLOB), // JDK6
      STRUCT(Types.STRUCT);
    
      public final int TYPE_CODE;
      private static Map<Integer,JdbcType> codeLookup = new HashMap<Integer,JdbcType>();
    
      static { 
        for (JdbcType type : JdbcType.values()) { 
          codeLookup.put(type.TYPE_CODE, type);
        }
      }
    
      JdbcType(int code) { 
        this.TYPE_CODE = code;
      }
    
      public static JdbcType forCode(int code)  { 
        return codeLookup.get(code);
      }
    
    }

*  resolveResultSetType

protected ResultSetType resolveResultSetType(String alias) { 
      if (alias == null) return null;
      try { 
      	/* public enum ResultSetType { FORWARD_ONLY(ResultSet.TYPE_FORWARD_ONLY), SCROLL_INSENSITIVE(ResultSet.TYPE_SCROLL_INSENSITIVE), SCROLL_SENSITIVE(ResultSet.TYPE_SCROLL_SENSITIVE); private int value; ResultSetType(int value) { this.value = value; } public int getValue() { return value; } } */
        return ResultSetType.valueOf(alias);
      } catch (IllegalArgumentException e) { 
        throw new BuilderException("Error resolving ResultSetType. Cause: " + e, e);
      }
    }

*  resolveParameterMode  
    解析参数模式，入参，出参，出入参：

protected ParameterMode resolveParameterMode(String alias) { 
      if (alias == null) return null;
      try { 
      	/* org.apache.ibatis.mapping.ParameterMode public enum ParameterMode { IN, OUT, INOUT } */
        return ParameterMode.valueOf(alias);
      } catch (IllegalArgumentException e) { 
        throw new BuilderException("Error resolving ParameterMode. Cause: " + e, e);
      }
    }

*  createInstance

protected Object createInstance(String alias) { 
      Class<?> clazz = resolveClass(alias);
      if (clazz == null) return null;
      try { 
        return resolveClass(alias).newInstance();
      } catch (Exception e) { 
        throw new BuilderException("Error creating instance. Cause: " + e, e);
      }
    }

*  resolveTypeHandler  
    解析类型处理器对象：

protected TypeHandler<?> resolveTypeHandler(Class<?> javaType, Class<? extends TypeHandler<?>> typeHandlerType) { 
      if (typeHandlerType == null) return null;
      // 根据类型类型处理器的class类型获取类型处理器对象
      TypeHandler<?> handler = typeHandlerRegistry.getMappingTypeHandler(typeHandlerType);
      if (handler == null) { 
        // 没有在类型处理器注册机中注册，则重新创建一个新的
        handler = typeHandlerRegistry.getInstance(javaType, typeHandlerType);
      }
      return handler;
    }

## 4：解析器XPathParser ##

该类对应的是mybatis项目中`parsing`模块，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 3]  
作用是辅助解析全局config文件`mybais-config.xml`和mapper映射文件`*Mapper.xml`。

### 4.1：构造函数 ###

源码如下：

public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) { 
      // <202107070928>
      commonConstructor(validation, variables, entityResolver);
      // <202107071139>
      this.document = createDocument(new InputSource(inputStream));
    }

`<202107070928>`处源码如下：

private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) { 
      this.validation = validation;
      // <202107070937>
      // 设置实体解析器，这里为XMLMapperEntityResolver
      this.entityResolver = entityResolver;
      this.variables = variables;
      // 创建XPath工厂，并使用其创建xpath
      XPathFactory factory = XPathFactory.newInstance();
      this.xpath = factory.newXPath();
    }

`<202107070937>`处一般为XMLMapperEntityResolver，用于加载xml的dtd约束文件`mybatis-3-config.dtd`(在全局config文件中使用)和`mybatis-3-mapper.dtd`(在mapper文件中使用),该类实现了接口`org.xml.sax.EntityResolver`，源码如下：

public class XMLMapperEntityResolver implements EntityResolver { 
    
      private static final Map<String, String> doctypeMap = new HashMap<String, String>();
    
      private static final String IBATIS_CONFIG_PUBLIC = "-//ibatis.apache.org//DTD Config 3.0//EN".toUpperCase(Locale.ENGLISH);
      private static final String IBATIS_CONFIG_SYSTEM = "http://ibatis.apache.org/dtd/ibatis-3-config.dtd".toUpperCase(Locale.ENGLISH);
    
      private static final String IBATIS_MAPPER_PUBLIC = "-//ibatis.apache.org//DTD Mapper 3.0//EN".toUpperCase(Locale.ENGLISH);
      private static final String IBATIS_MAPPER_SYSTEM = "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd".toUpperCase(Locale.ENGLISH);
    
      private static final String MYBATIS_CONFIG_PUBLIC = "-//mybatis.org//DTD Config 3.0//EN".toUpperCase(Locale.ENGLISH);
      private static final String MYBATIS_CONFIG_SYSTEM = "http://mybatis.org/dtd/mybatis-3-config.dtd".toUpperCase(Locale.ENGLISH);
    
      private static final String MYBATIS_MAPPER_PUBLIC = "-//mybatis.org//DTD Mapper 3.0//EN".toUpperCase(Locale.ENGLISH);
      private static final String MYBATIS_MAPPER_SYSTEM = "http://mybatis.org/dtd/mybatis-3-mapper.dtd".toUpperCase(Locale.ENGLISH);
    
      private static final String MYBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";
      private static final String MYBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";
    
      static { 
        doctypeMap.put(IBATIS_CONFIG_SYSTEM, MYBATIS_CONFIG_DTD);
        doctypeMap.put(IBATIS_CONFIG_PUBLIC, MYBATIS_CONFIG_DTD);
    
        doctypeMap.put(IBATIS_MAPPER_SYSTEM, MYBATIS_MAPPER_DTD);
        doctypeMap.put(IBATIS_MAPPER_PUBLIC, MYBATIS_MAPPER_DTD);
    
        doctypeMap.put(MYBATIS_CONFIG_SYSTEM, MYBATIS_CONFIG_DTD);
        doctypeMap.put(MYBATIS_CONFIG_PUBLIC, MYBATIS_CONFIG_DTD);
    
        doctypeMap.put(MYBATIS_MAPPER_SYSTEM, MYBATIS_MAPPER_DTD);
        doctypeMap.put(MYBATIS_MAPPER_PUBLIC, MYBATIS_MAPPER_DTD);
      }
     /* 如xml为： <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> 则publicId=-//mybatis.org//DTD Config 3.0//EN，systemId=http://mybatis.org/dtd/mybatis-3-config.dtd */
      public InputSource resolveEntity(String publicId, String systemId) throws SAXException { 
    	// 转大写
        if (publicId != null) publicId = publicId.toUpperCase(Locale.ENGLISH);
        if (systemId != null) systemId = systemId.toUpperCase(Locale.ENGLISH);
    
        InputSource source = null;
        try { 
          // doctypeMap:id->本地dtd字典，如下：
          /* "HTTP://MYBATIS.ORG/DTD/MYBATIS-3-MAPPER.DTD" -> "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd" "HTTP://IBATIS.APACHE.ORG/DTD/IBATIS-3-MAPPER.DTD" -> "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd" "-//MYBATIS.ORG//DTD CONFIG 3.0//EN" -> "org/apache/ibatis/builder/xml/mybatis-3-config.dtd" "-//IBATIS.APACHE.ORG//DTD CONFIG 3.0//EN" -> "org/apache/ibatis/builder/xml/mybatis-3-config.dtd" "-//IBATIS.APACHE.ORG//DTD MAPPER 3.0//EN" -> "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd" "HTTP://MYBATIS.ORG/DTD/MYBATIS-3-CONFIG.DTD" -> "org/apache/ibatis/builder/xml/mybatis-3-config.dtd" "HTTP://IBATIS.APACHE.ORG/DTD/IBATIS-3-CONFIG.DTD" -> "org/apache/ibatis/builder/xml/mybatis-3-config.dtd" "-//MYBATIS.ORG//DTD MAPPER 3.0//EN" -> "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd" */
    	  // 获取本地路径
          String path = doctypeMap.get(publicId);
          // 获取source
          source = getInputSource(path, source);
          // 没有获取到source，则尝试通过systemId获取
          if (source == null) { 
            path = doctypeMap.get(systemId);
            source = getInputSource(path, source);
          }
        } catch (Exception e) { 
          throw new SAXException(e.toString());
        }
        return source;
      }
    
      // 获取指定路径文件的InputSource对象，其中source作为返回值
      private InputSource getInputSource(String path, InputSource source) { 
        if (path != null) { 
          InputStream in;
          try { 
            in = Resources.getResourceAsStream(path);
            source = new InputSource(in);
          } catch (IOException e) { 
          }
        }
        return source;
      }
    
    }

`<202107071139>`处是创建文档，都是SAX的API，源码如下：

private Document createDocument(InputSource inputSource) { 
       try { 
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         factory.setValidating(validation);
    
         factory.setNamespaceAware(false);
         factory.setIgnoringComments(true);
         factory.setIgnoringElementContentWhitespace(false);
         factory.setCoalescing(false);
         factory.setExpandEntityReferences(true);
    
         DocumentBuilder builder = factory.newDocumentBuilder();
         builder.setEntityResolver(entityResolver);
         builder.setErrorHandler(new ErrorHandler() { 
           public void error(SAXParseException exception) throws SAXException { 
             throw exception;
           }
    
           public void fatalError(SAXParseException exception) throws SAXException { 
             throw exception;
           }
    
           public void warning(SAXParseException exception) throws SAXException { 
           }
         });
         return builder.parse(inputSource);
       } catch (Exception e) { 
         throw new BuilderException("Error creating document instance. Cause: " + e, e);
       }
     }

## 5：XMLConfigBuilder\#parse ##

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parse
    public Configuration parse() { 
      // 如果已经解析过，则异常
      if (parsed) { 
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
      }
      // 直接设置为解析过
      parsed = true;
      // <202107071332>
      parseConfiguration(parser.evalNode("/configuration"));
      return configuration;
    }

`<202107071332>`处`parser.evalNode("/configuration")`源码如下：

org.apache.ibatis.parsing.XPathParser#evalNode(java.lang.String)
    public XNode evalNode(String expression) { 
      // <202107071347>
      return evalNode(document, expression);
    }

`<202107071347>`处源码如下：

org.apache.ibatis.parsing.XPathParser#evalNode(java.lang.Object, java.lang.String)
    public XNode evalNode(Object root, String expression) { 
      // DOM操作，获取Node
      Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
      if (node == null) { 
        return null;
      }
      // 封装为XNode，方便进行动态值的替换
      return new XNode(this, node, variables);
    }

`<202107071332>`处`parseConfiguration`是解析获取Configuration对象，具体参考`5.1：parseConfiguration`。

### 5.1：parseConfiguration ###

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
       try { 
         // <202107071413>
         propertiesElement(root.evalNode("properties")); 
         // <202107071414>
         typeAliasesElement(root.evalNode("typeAliases"));
         // <202107071415>
         pluginElement(root.evalNode("plugins"));
         // <202107071416>
         objectFactoryElement(root.evalNode("objectFactory"));
         // <202107071417>
         objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
         // <202107071418>
         settingsElement(root.evalNode("settings"));
         // <202107071419>
         environmentsElement(root.evalNode("environments")); 
         // <202107071420>
         databaseIdProviderElement(root.evalNode("databaseIdProvider"));
         // <202107071421>
         typeHandlerElement(root.evalNode("typeHandlers"));
         // <202107071422>
         mapperElement(root.evalNode("mappers"));
       } catch (Exception e) { 
         throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
       }
     }

`<202107071413>`处是解析`<properties/>`标签，具体参考`5.1.1：propertiesElement`。  
`<202107071414>`处是解析`<typeAliases/>`标签，具体参考`5.1.2：typeAliasesElement`。  
`<202107071415>`处是解析`<plugins/>`标签，具体参考`5.1.3：pluginElement`。  
`<202107071416>`处是解析`<objectFactory/>`标签，具体参考`5.1.4：objectFactory`。  
`<202107071417>`处是解析`<objectWrapperFactory/>`标签，具体参考`5.1.5：objectWrapperFactory`。  
`<202107071418>`处是解析`<settings/>`标签，具体参考`5.1.6：settings`。  
`202107071419`处是解析`<environment/>`标签，具体参考`5.1.7：environment`。  
`202107071420`处是解析`<databaseIdProvider/>`标签，具体参考`5.1.8：databaseIdProvider`。  
`202107071421`处是解析`<typeHandlers/>`标签，具体参考`5.1.9：typeHandlers`。  
`202107071422`处是解析`<mappers/>`标签，具体参考`5.1.10：mappers`。

#### 5.1.1：propertiesElement ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        propertiesElement(root.evalNode("properties")); //issue #117 read properties first
     	...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

org.apache.ibatis.builder.xml.XMLConfigBuilder#propertiesElement
    private void propertiesElement(XNode context) throws Exception { 
      // 这里的context为<properties/>节点对应的对象，如果是配置了该节点就不会为null 
      if (context != null) { 
        // <202107081609>
        // 将配置的信息以java.util.Properties形式返回
        Properties defaults = context.getChildrenAsProperties();
        // 获取resource属性的值，该属性用来配置外部的属性配置文件，如：
        /* <properties resource="org/mybatis/example/config.properties"/> */
        String resource = context.getStringAttribute("resource");
        // 获取url属性的值，这种是通过统一资源定位符方式获取资源，如：
        // <properties url="file:///C:/Users/Administrator/Desktop/temp/my.properties"/>
        String url = context.getStringAttribute("url");
        // 不允resource和url同时指定
        if (resource != null && url != null) { 
          throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference. Please specify one or the other.");
        }
        if (resource != null) {  // 有resource属性的情况
          defaults.putAll(Resources.getResourceAsProperties(resource));
        } else if (url != null) {  // 有url属性的情况
          defaults.putAll(Resources.getUrlAsProperties(url));
        }
        // 从configuration中获取已有的variables信息
        // org.apache.ibatis.session.Configuration#variables
        // protected Properties variables = new Properties();
        Properties vars = configuration.getVariables();
        // 不为空则添加到当前读取到的
        if (vars != null) { 
          defaults.putAll(vars);
        }
        // 设置到parser中
        parser.setVariables(defaults);
        // 设置到configuration中
        configuration.setVariables(defaults);
      }
    }

`<202107081609>`处源码如下：

org.apache.ibatis.parsing.XNode#getChildrenAsProperties
    public Properties getChildrenAsProperties() { 
      Properties properties = new Properties();
      // 获取所有的子节点
      for (XNode child : getChildren()) { 
        // 获取name属性的值
        String name = child.getStringAttribute("name");
        // 获取value属性的值
        String value = child.getStringAttribute("value");
        // name和value都不为空，则添加到结果java.util.Properties中
        if (name != null && value != null) { 
          properties.setProperty(name, value);
        }
      }
      return properties;
    }

#### 5.1.2：typeAliasesElement ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    privatevoid parseConfiguration(XNode root) { 
      try { 
    	...snip...
    	// <202107091108>
        typeAliasesElement(root.evalNode("typeAliases"));
        ...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107091108>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#typeAliasesElement
    private void typeAliasesElement(XNode parent) { 
       if (parent != null) { 
         // 获取所有的子节点，并处理
         for (XNode child : parent.getChildren()) { 
           // 如果当前节点配置的是package
           if ("package".equals(child.getName())) { 
             // 获取pacakge的值
             String typeAliasPackage = child.getStringAttribute("name");
             // 从configuration中获取别名注册器并注册别名
             // <202107091115>
             configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
           } else { 
             // 获取别名
             String alias = child.getStringAttribute("alias");
             // 获取class类型
             String type = child.getStringAttribute("type");
             try { 
               // 转class
               Class<?> clazz = Resources.classForName(type);
               if (alias == null) {  // 没有指定别名
                 typeAliasRegistry.registerAlias(clazz);
               } else {  // 指定了别名
                 typeAliasRegistry.registerAlias(alias, clazz);
               }
             } catch (ClassNotFoundException e) { 
               throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
             }
           }
         }
       }
     }

`<202107091115>`是通过包路径完成包下类的别名的注册，源码如下：

org.apache.ibatis.type.TypeAliasRegistry#registerAliases(java.lang.String)
    public void registerAliases(String packageName){ 
       // <202107091116>
      registerAliases(packageName, Object.class);
    }

`<202107091116>`处源码如下：

org.apache.ibatis.type.TypeAliasRegistry#registerAliases(java.lang.String, java.lang.Class<?>)
    public void registerAliases(String packageName, Class<?> superType){ 
      ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
      // new ResolverUtil.IsA(superType):定义内部类实例，该类用于判断是否为某个类的子类
      // pakcageName：要搜索的包名称
      // find方法源码如下：
      /* org.apache.ibatis.io.ResolverUtil#find public ResolverUtil<T> find(Test test, String packageName) { // 获取路径，如foo.bar->foo/bar String path = getPackagePath(packageName); try { // 获取path下所有的文件（可能是文件，也可能是文件夹）带有路径的名称， 如foo/bar/A.class,foo/bar/B.class List<String> children = VFS.getInstance().list(path); // 循环所有的class for (String child : children) { // 必须以.class结尾 if (child.endsWith(".class")) // 通过test，IsA内部类判断是否（通过java.lang.Class#isAssignableFrom）匹配 // 匹配的话则添加到org.apache.ibatis.io.ResolverUtil#matches中 addIfMatching(test, child); } } catch (IOException ioe) { log.error("Could not read package: " + packageName, ioe); } // 当前对象作为结果，返回 return this; } */
      resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
      // 获取所有的符合要求的class
      Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
      // 循环处理所有的class
      for(Class<?> type : typeSet){ 
        // !type.isAnonymousClass()：不是匿名内部类
        // !type.isInterface()：不是接口
        // !type.isMemberClass()：不是成员类，如下A2222就是成员类
        /* public class Test2222 { class A2222 { } } */
        if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) { 
          // <202107091646>
          registerAlias(type);
        }
      }
    }

`<202107091646>`处是注册类型别名，源码如下：

org.apache.ibatis.type.TypeAliasRegistry#registerAlias(java.lang.Class<?>)
    public void registerAlias(Class<?> type) { 
      // 获取简单类名作为别名，如foo.bar.Mongo,结果就是Mongo
      String alias = type.getSimpleName();
      // 尝试获取org.apache.ibatis.type.Alias注解
      // 通过该注解可以设置别名
      Alias aliasAnnotation = type.getAnnotation(Alias.class);
      // 有org.apache.ibatis.type.Alias注解
      if (aliasAnnotation != null) { 
      	// 使用org.apache.ibatis.type.Alias的value值作为别名
        alias = aliasAnnotation.value();
      } 
      // 注册别名
      /* org.apache.ibatis.type.TypeAliasRegistry#registerAlias(java.lang.String, java.lang.Class<?>) public void registerAlias(String alias, Class<?> value) { if (alias == null) throw new TypeException("The parameter alias cannot be null"); // 转小写 String key = alias.toLowerCase(Locale.ENGLISH); // TYPE_ALIASES.containsKey(key):已经存在key // TYPE_ALIASES.get(key) != null:key对应的值不为空 // !TYPE_ALIASES.get(key).equals(value)：key对应的值和当前要注册的值不相等，说明别名 // 已经注册到其他类了，此时直接异常，并给出异常信息 if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) { // 给出异常信息，告知别名已经注册的信息 throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'."); } // private final Map<String, Class<?>> TYPE_ALIASES = new HashMap<String, Class<?>>(); TYPE_ALIASES.put(key, value); } */
      registerAlias(alias, type);
    }

#### 5.1.3：pluginElement ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        ...snip...
        // <202107091748>
        pluginElement(root.evalNode("plugins"));
        ...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107091748>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#pluginElement
    private void pluginElement(XNode parent) throws Exception { 
      if (parent != null) { 
        for (XNode child : parent.getChildren()) { 
          // 获取拦截器类的值
          String interceptor = child.getStringAttribute("interceptor");
          // 将所有的<property/>子节点配置的name->value读取到Properties中
          Properties properties = child.getChildrenAsProperties();
          // 反射创建拦截器实例
          Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
          // 将配置的属性信息设置到拦截器的properties属性中
          interceptorInstance.setProperties(properties);
          // <202107091800>
          configuration.addInterceptor(interceptorInstance);
        }
      }
    }

`<202107091800>`处源码如下：

org.apache.ibatis.session.Configuration#addInterceptor
    public void addInterceptor(Interceptor interceptor) { 
      // 添加到拦截器链中
      // protected final InterceptorChain interceptorChain = new InterceptorChain();
      interceptorChain.addInterceptor(interceptor);
    }

#### 5.1.4：objectFactory ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        ...snip...
        // <202107101744>
        objectFactoryElement(root.evalNode("objectFactory"));
        ...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107101744>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#objectFactoryElement
    private void objectFactoryElement(XNode context) throws Exception { 
      if (context != null) { 
        // 获取type的值，即自己设置的ObjectFactory，可能设置如下：
        /* <objectFactory type="yudaosourcecode.mybatis.objectfactory.MyObjectFactory"> <property name="name" value="zhangsan"/> <property name="age" value="90"/> </objectFactory> */
        String type = context.getStringAttribute("type");
        // 获取配置的property的值
        Properties properties = context.getChildrenAsProperties();
        // 反射创建指定的ObjectFactory的实例
        ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
        // 设置通过<property/>配置的值到创建的ObjectFactory对象的propertis属性中
        factory.setProperties(properties);
        // 设置创建的ObjectFactory实例到configuration配置对象的objectFactory属性
        configuration.setObjectFactory(factory);
      }
    }

#### 5.1.5：objectWrapperFactory ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        ...snip...
        // <202107111618>
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        ...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107111618>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#objectWrapperFactoryElement
    private void objectWrapperFactoryElement(XNode context) throws Exception { 
      if (context != null) { 
      	// 获取type属性值
        String type = context.getStringAttribute("type");
        // 反射创建实例
        ObjectWrapperFactory factory = (ObjectWrapperFactory) resolveClass(type).newInstance();
        // 设置到objectWrapperFactory属性中
        configuration.setObjectWrapperFactory(factory);
      }
    }

#### 5.1.6：settings ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        ...snip...
        // <202107111621>
        settingsElement(root.evalNode("settings"));
        ...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107111621>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#settingsElement
    private void settingsElement(XNode context) throws Exception { 
      if (context != null) { 
        // 获取所有的setting，如下配置：
        /* <settings> <setting name="mapUnderscoreToCamelCase" value="true"/> </settings> 结果就是:mapUnderscoreToCamelCase -> true */
        Properties props = context.getChildrenAsProperties();
        // 确保在Configuration类中都有对应setter，即是Configuration中的属性
        MetaClass metaConfig = MetaClass.forClass(Configuration.class);
        // 依次判断是Configuration的属性，不是则直接异常
        for (Object key : props.keySet()) { 
          if (!metaConfig.hasSetter(String.valueOf(key))) { 
            throw new BuilderException("The setting " + key + " is not known. Make sure you spelled it correctly (case sensitive).");
          }
        }
        configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
        // 全局开启mapper配置文件中配置的缓存，默认为true，如果这里配置false，则mapper中配置的缓存也不会生效
        configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
        // 指定延迟加载对象所用到的代理工具，CGLIB，JAVASSIST，>3.3默认为JAVASSIST
        configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
    	// 延迟加载开关，默认为false，但是在mapper中可以通过设置fetchType来覆盖该值
        configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
    	// 是否直接加载设置了延迟加载的属性，如果为true，则加载，默认为true
        configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), true));
    	// 是否允许单个语句返回多结果集，默认为true
        configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
        configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
        // 是否允许自动生成主键
        configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
        configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
        // 数据库等待超时时间，默认为null
        configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
        // 是否开启程序类->数据库列的驼峰映射规则，默认为false，个人建议不要修改，使用as完成同样效果
        configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
        configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
        configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
        configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
        // 指定对对象的哪些方法触发一次延迟加载
        configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
        configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
        configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
        // 当结果集为null时，是否调用对应setter方法
        configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
        // 日志名称的前缀，比如设置<setting name="logPrefix" value="dongshidaddy--^^--"/>
        // 日志可能为：2021-07-11 16--51---55,105 [dongshidaddy--^^--yudaosourcecode.mybatis.mapper.TestTypehandlerMapper.queryTestTypehandlerById]-[DEBUG] ==> Preparing: select * from test_typehandler where id=? 
        configuration.setLogPrefix(props.getProperty("logPrefix"));
        // 指定日志系统的具体实现，没有指定则自动查找SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING
        // <202107131651>
        configuration.setLogImpl(resolveClass(props.getProperty("logImpl")));
        configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
      }
    }

`<202107131651>`处关于java的日志可以参考[这篇文章][Link 2]。

#### 5.1.7：environment ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        ...snip...
        // <202107111656>
        environmentsElement(root.evalNode("environments")); 
        ...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107111656>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#environmentsElement
    private void environmentsElement(XNode context) throws Exception { 
      if (context != null) { 
        // 如果environment为null，则使用配置的default属性的值
        if (environment == null) { 
          // 如：
          /* <environments default="test"> <environment id="test"> ... <environment/> <environment id="dev"> ... <environment/> <environments/> */
    	  // 此时结果值就是default
          environment = context.getStringAttribute("default");
        }
        for (XNode child : context.getChildren()) { 
          // 获取当前节点的id
          String id = child.getStringAttribute("id");
          // 如果是指定启用的环境配置
          // <202107121037>
          if (isSpecifiedEnvironment(id)) { 
            // 获取trasactionManger的值，并创建实例
            // <202107121040>
            TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
            // 获取dataSource，数据源的值并创建实例，可能配置如下：
            /* <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://127.0.0.1:3366/ssmdemo" /> <property name="username" value="root" /> <property name="password" value="root" /> </dataSource> */
            // <202107121100>
            DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
            // 通过数据源工厂对象，获取数据源
            DataSource dataSource = dsFactory.getDataSource();
            // 创建Environment.Builder对象
            Environment.Builder environmentBuilder = new Environment.Builder(id)
                .transactionFactory(txFactory)
                .dataSource(dataSource);
            /* org.apache.ibatis.mapping.Environment.Builder#build public Environment build() { return new Environment(this.id, this.transactionFactory, this.dataSource); } */
    		// 构造器模式创建Environment对象
            configuration.setEnvironment(environmentBuilder.build());
          }
        }
      }
    }

`<202107121037>`是判断当前环境是否启用，源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#isSpecifiedEnvironment
    private boolean isSpecifiedEnvironment(String id) { 
      // 没有指定启用的environment，异常
      if (environment == null) { 
        throw new BuilderException("No environment specified.");
      } else if (id == null) {  // 当前待判断的环境id信息为空，异常
        throw new BuilderException("Environment requires an id attribute.");
      } else if (environment.equals(id)) {  // 如果待判断异常id和指定启用的环境相等，则符合
        return true;
      }
      // 执行这里，说明不符合，直接false
      return false;
    }

`<202107121040>`是根据配置的事务管理器，创建事务工厂对象，源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#transactionManagerElement
    private TransactionFactory transactionManagerElement(XNode context) throws Exception { 
    if (context != null) { 
        // 获取type的值，如：
        /* <transactionManager type="JDBC" /> 为设置JDBC类型的事务管理器，我们一般固定使用该值 */
        String type = context.getStringAttribute("type");
        // 获取<property/>子节点的值
        Properties props = context.getChildrenAsProperties();
        // 根据类型别名获取具体的类，并反射创建实例
        // <202107121047>
        TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
        // 设置用户通过<property/>标签设置的属性到事务工厂对象的properties属性中
        factory.setProperties(props);
        // 返回事务工厂
        return factory;
      }
      throw new BuilderException("Environment declaration requires a TransactionFactory.");
    }

`<202107121047>`处`resolveClass(type)`源码如下：

org.apache.ibatis.builder.BaseBuilder#resolveClass
    protected Class<?> resolveClass(String alias) { 
      // 为null，直接返回null
      if (alias == null) return null;
      try { 
        /* org.apache.ibatis.builder.BaseBuilder#resolveAlias protected Class<?> resolveAlias(String alias) { // 从别名注册器中获取真实类名 // jdbc -> {Class@1524} "class org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory" return typeAliasRegistry.resolveAlias(alias); } */
        return resolveAlias(alias);
      } catch (Exception e) { 
        throw new BuilderException("Error resolving class. Cause: " + e, e);
      }
    }

`<202107121100>`处是获取dataSource属性并创建数据源工厂对象，源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#dataSourceElement
    private DataSourceFactory dataSourceElement(XNode context) throws Exception { 
      if (context != null) { 
        // 获取type的值，如
        /* <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://127.0.0.1:3366/ssmdemo" /> <property name="username" value="root" /> <property name="password" value="root" /> </dataSource> */
    	// 结果就是POOLED
        String type = context.getStringAttribute("type");
        // 获取通过<property/>标签配置的数据库驱动，地址，账号等信息
        Properties props = context.getChildrenAsProperties();
        // 通过别名解析具体的class类型，并反射创建数据源工厂实例
        DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
        // 设置数据库相关属性到数据源工厂的properties属性中
        factory.setProperties(props);
        // 返回数据源工厂对象
        return factory;
      }
      throw new BuilderException("Environment declaration requires a DataSourceFactory.");
    }

#### 5.1.8：databaseIdProvider ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        ...snip...
        // <202107141818>
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        ...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107141818>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#databaseIdProviderElement
    private void databaseIdProviderElement(XNode context) throws Exception { 
      DatabaseIdProvider databaseIdProvider = null;
      if (context != null) { 
        // 获取type的值
        /* <databaseIdProvider type="DB_VENDOR"> <property name="Oracle" value="oracle"/> <property name="MySQL" value="mysql"/> </databaseIdProvider> */
    	// 给DB_VENDOR
        String type = context.getStringAttribute("type");
        // 该代码是为了兼容性，之前可能会配置为VENDOR
        if ("VENDOR".equals(type)) type = "DB_VENDOR";
        // 获取property配置的属性值
        Properties properties = context.getChildrenAsProperties();
        // 通过type别名解析对应的class，这里是org.apache.ibatis.mapping.VendorDatabaseIdProvider
        databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
        // 设置属性值
        databaseIdProvider.setProperties(properties);
      }
      // 获取配置中的environment
      Environment environment = configuration.getEnvironment();
      // 如果是即有环境environment也有databaseIdProvider
      if (environment != null && databaseIdProvider != null) { 
      	// 根据数据源对象，获取该数据源对象对应的厂商id
        String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
        // 将当前配置的数据源对应的厂商id设置到配置对象中
        configuration.setDatabaseId(databaseId);
      }
    }

#### 5.1.9：typeHandlers ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try{ 
        ...snip...
        // <202107151529>
        typeHandlerElement(root.evalNode("typeHandlers"));
    	...snip...
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107151529>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#typeHandlerElement
    private void typeHandlerElement(XNode parent) throws Exception { 
      if(parent != null) { 
        // 可能配置：
        /* <typeHandlers> <typeHandler handler="yudaosourcecode.mybatis.typehandler.EnumAndIntTypeHandler" javaType="yudaosourcecode.mybatis.MyEnum"/> </typeHandlers> */
        for (XNode child : parent.getChildren()) { 
          // 如果是<package>子标签
          if ("package".equals(child.getName())) { 
            // 获取name属性配置的值
            String typeHandlerPackage = child.getStringAttribute("name");
            // <202107151534>
            // 根据包名自动注册
            typeHandlerRegistry.register(typeHandlerPackage);
          } else { 
            // 获取java类型，这里的java类型可以是通过typeAlias设置的别名
            // 也可以是类的完整限定名
            String javaTypeName = child.getStringAttribute("javaType");
            // 获取jdbc类型，可取的值是org.apache.ibatis.type.JdbcType的字面量,
            // 如果是不是其字面量，解析jdbc类型会异常
            String jdbcTypeName = child.getStringAttribute("jdbcType");
            // 获取类型处理器
            String handlerTypeName = child.getStringAttribute("handler");
            // 解析java类型为具体的class类型
            Class<?> javaTypeClass = resolveClass(javaTypeName);
            // 解析数据库类型为JdbcType枚举类型
            JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
            // 解析类型处理器class
            Class<?> typeHandlerClass = resolveClass(handlerTypeName);
            // 如果是java类型不为null
            if (javaTypeClass != null) { 
              // 没有设置数据库类型和设置了数据库类型的情况，分别处理
              if (jdbcType == null) { 
                typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
              } else { 
                typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
              }
            } else {  // Java类型为null的情况
              typeHandlerRegistry.register(typeHandlerClass);
            }
          }
        }
      }
    }

`<202107151534>`处是根据包名自动注册java类型到数据类型的映射的处理器，源码如下：

org.apache.ibatis.type.TypeHandlerRegistry#register(java.lang.String)
    public void register(String packageName) { 
      ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
      // 从packageName包下查询为TypeHandler类型的class
      resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
      // 获取所有类型为TypeHandler的class
      Set<Class<? extends Class<?>>> handlerSet = resolverUtil.getClasses();
      // 循环所有的class，注册
      for (Class<?> type : handlerSet) { 
    	// !type.isAnonymousClass()：非匿名类
    	// !type.isInterface()：非接口
    	// !Modifier.isAbstract(type.getModifiers())：非抽象类
        if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) { 
          // <202107151543>
          register(type);
        }
      }
    }

`<202107151543>`处源码如下：

org.apache.ibatis.type.TypeHandlerRegistry#register(java.lang.Class<?>)
    public void register(Class<?> typeHandlerClass) { 
    	boolean mappedTypeFound = false;
    	// 获取MappedTypes注解信息
    	MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
    	// 如果使用了org.apache.ibatis.type.MappedTypes注解
    	if (mappedTypes != null) { 
    	  // 获取配置的class[]的数组
    	  for (Class<?> javaTypeClass : mappedTypes.value()) { 
    	  	// javaTypeClass:java类型
    	  	// typeHandlerClass：类型处理器class
    	  	// 注册某种java类型使用的类型处理器
    	  	// <202107151545>
    	    register(javaTypeClass, typeHandlerClass);
    	    // 设置发现了映射类型
    	    mappedTypeFound = true;
    	  }
    	}
    	// 没有发现映射类型的情况,即没有java类型的情况
    	if (!mappedTypeFound) { 
    	  register(getInstance(null, typeHandlerClass));
    	}
    }

`<202107151545>`处源码如下：

org.apache.ibatis.type.TypeHandlerRegistry#register(java.lang.Class<?>, java.lang.Class<?>)
    public void register(Class<?> javaTypeClass, Class<?> typeHandlerClass) { 
      // getInstance(javaTypeClass, typeHandlerClass)源码如下：
      /* org.apache.ibatis.type.TypeHandlerRegistry#getInstance public <T> TypeHandler<T> getInstance(Class<?> javaTypeClass, Class<?> typeHandlerClass) { // 如果是有指定的java类型 if (javaTypeClass != null) { // 尝试通过带有Class参数的构造函数创建类型处理器实例 try { Constructor<?> c = typeHandlerClass.getConstructor(Class.class); return (TypeHandler<T>) c.newInstance(javaTypeClass); } catch (NoSuchMethodException ignored) { // 如果没有对应的构造函数的异常，则忽略，后续尝试使用默认构造函数创建 // ignored } catch (Exception e) { // 如果是有对应的构造函数，但是因为某些原因调用失败，则直接异常 throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e); } } try { // 使用默认构造函数创建实例 Constructor<?> c = typeHandlerClass.getConstructor(); return (TypeHandler<T>) c.newInstance(); } catch (Exception e) { throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e); } } */
      // register源码如下：
      /* org.apache.ibatis.type.TypeHandlerRegistry#register(java.lang.reflect.Type, org.apache.ibatis.type.TypeHandler<? extends T>) private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) { // 尝试从类型处理器上获取用于指定数据库类型的MappedJdbcTypes注解 MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class); // 如果有MappedJdbcTypes注解信息 if (mappedJdbcTypes != null) { // 循环处理，完成最终的注册，即Java类型为javaType，数据库类型为handledJdbcType // ，使用类型处理器typeHandler for (JdbcType handledJdbcType : mappedJdbcTypes.value()) { // 注册，注册结构为： // private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new HashMap<Type, Map<JdbcType, TypeHandler<?>>>(); register(javaType, handledJdbcType, typeHandler); } // 如果是包含数据库类型为null的情况，则也注册数据库类型为null的情况 if (mappedJdbcTypes.includeNullJdbcType()) { // 注册，注册结构为： // private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new HashMap<Type, Map<JdbcType, TypeHandler<?>>>(); register(javaType, null, typeHandler); } } else { // 没有设置MappedJdbcTypes注解，则按照java类型为javaType，数据库类型为null // ，类型处理器为typeHandler来进行注册 // 注册，注册结构为： // private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new HashMap<Type, Map<JdbcType, TypeHandler<?>>>(); register(javaType, null, typeHandler); } } */
      register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
    }

#### 5.1.10：mappers ####

源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
    private void parseConfiguration(XNode root) { 
      try { 
        ...snip...
        // <202107151634>
        mapperElement(root.evalNode("mappers"));
      } catch (Exception e) { 
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }

`<202107151634>`处源码如下：

org.apache.ibatis.builder.xml.XMLConfigBuilder#mapperElement
    private void mapperElement(XNode parent) throws Exception { 
      if(parent != null) { 
        for (XNode child : parent.getChildren()) { 
          // 有package，如配置：
          /* <mappers> <package name="yudaosourcecode.mybatis.mapper"/> </mappers> */
          if ("package".equals(child.getName())) { 
            // 获取name的值。即包名
            String mapperPackage = child.getStringAttribute("name");
            // <202107151728>
            configuration.addMappers(mapperPackage);
          } else { 
            // 获取resource，如<mapper resource="mybatis/mapper/TestTypehandlerMapper.xml"/>
            String resource = child.getStringAttribute("resource");
            // 获取url
            String url = child.getStringAttribute("url");
            // 获取class
            String mapperClass = child.getStringAttribute("class");
            // 优先处理resource，此时为类路径资源
            if (resource != null && url == null && mapperClass == null) { 
              ErrorContext.instance().resource(resource);
              // 获取资源
              InputStream inputStream = Resources.getResourceAsStream(resource);
              // 创建XMLMapperBuilder
              // <202107151749>
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
              // 执行解析，解析完毕后，就知道mapper xml对应的接口类是哪个了
              mapperParser.parse();
            } else if (resource == null && url != null && mapperClass == null) {  // 处理url情况
              ErrorContext.instance().resource(url);
              // 根据url获取资源
              InputStream inputStream = Resources.getUrlAsStream(url);
              // 创建XMLMapperBuilder
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
              // 执行解析
              mapperParser.parse();
            } else if (resource == null && url == null && mapperClass != null) {  // 直接指定了class
         	  // 获取映射的mapper接口的class
              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.");
            }
          }
        }
      }
    }

`<202107151728>`处源码如下：

org.apache.ibatis.session.Configuration#addMappers(java.lang.String)
    public void addMappers(String packageName) { 
      // <202107151729>
      mapperRegistry.addMappers(packageName);
    }

`<202107151729>`处源码如下：

org.apache.ibatis.binding.MapperRegistry#addMappers(java.lang.String)
    public void addMappers(String packageName) { 
      // <202107151730>
      addMappers(packageName, Object.class);
    }

`<202107151730>`处源码如下：

org.apache.ibatis.binding.MapperRegistry#addMappers(java.lang.String, java.lang.Class<?>)
    public void addMappers(String packageName, Class<?> superType) { 
      ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
      // 获取类型为superType：class java.lang.Object的类
      resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
      // 获取类型为class java.lang.Object的class的集合
      Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
      // 循环添加映射
      for (Class<?> mapperClass : mapperSet) { 
      	// <202107157132>
        addMapper(mapperClass);
      }
    }

`<202107157132>`处源码如下：

org.apache.ibatis.binding.MapperRegistry#addMapper
    public <T> void addMapper(Class<T> type) { 
      // 是接口才处理
      if (type.isInterface()) { 
        // 如果该类型已经注册了映射mapper，则抛出异常
        /* public <T> boolean hasMapper(Class<T> type) { // private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>(); return knownMappers.containsKey(type); } */
        if (hasMapper(type)) { 
          throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
        }
        boolean loadCompleted = false;
        try { 
          // 添加到已知映射的集合中
          knownMappers.put(type, new MapperProxyFactory<T>(type));
          MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
          parser.parse();
          loadCompleted = true;
        } finally { 
          if (!loadCompleted) { 
            knownMappers.remove(type);
          }
        }
      }
    }

`<202107151749>`处关于XMLMapperBuilder，可以参考[这篇文章][Link 3]。

[Link 1]: https://blog.csdn.net/wang0907/article/details/118482256
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]: /images/20221005/ac22b3706a7749499c4f29e9da75136b.png
[20210706161507544.png]: /images/20221005/d1c8ed23cc204b68a8b79c7a7a9bac46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]: /images/20221005/4a2451c4f2c14268a59d6c8e2f93e744.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 2]: /images/20221005/efbfc6fe4b974d45b06d80ffcd5e94ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 3]: /images/20221005/21ed4a918427442ca5c1db5223ea52a6.png
[Link 2]: https://blog.csdn.net/wang0907/article/details/118675549
[Link 3]: https://blog.csdn.net/wang0907/article/details/118765131