MyBatis源码实现之Configuration加载（上）

曾经终败给现在 2022-04-17 05:06 228阅读 0赞

## 一、mybatis-config.xml转为Document对象 ##

**配置文件的入口**：

private static final String NAME_SPACE = "UserMapper.";
        private static SqlSessionFactory ssf;
        private static Reader reader;
    
        static {
            try {
            	// 作用：相当读取配置文件，并将其转换成流的形式返回。
                reader = Resources.getResourceAsReader("mybatis-config.xml");
                ssf = new SqlSessionFactoryBuilder().build(reader);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

Resources.getResourceAsReader(“mybatis-config.xml”)的代码实现如下：

public static Reader getResourceAsReader(String resource) throws IOException {
        Reader reader;
        if (charset == null) {
          reader = new InputStreamReader(getResourceAsStream(resource));
        } else {
          reader = new InputStreamReader(getResourceAsStream(resource), charset);
        }
        return reader;
      }

SqlSessionFactory是通过SqlSessionFactoryBuilder工厂类的build方法创建的， 不是通过构造方法直接new出来的。  
此外，我们还可以知道，**SqlSessionFactory提供了字节流和字符流以及直接的org.apache.ibatis.session.Configuration配置类的三种方式来读取配置文件信息。但是无论是字符流还是字节流，然后将Configuration设置到SqlSessionFactory（默认的实现类是org.apache.ibatis.session.defaults.DefaultSqlSessionFactory）中的configuraion字段并且返回。所以其本身也是很简单的，解析xml配置文件的操作都委托给了XMLConfigBuilder类**。

public class SqlSessionFactoryBuilder {
      // ···省略其他无关代码
      public SqlSessionFactory build(Reader reader) {
        return build(reader, null, null);
      }
    
       // 最终调用的是此方法
       public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
          XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
          return build(parser.parse());
        } catch (Exception e) {
          throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {
          ErrorContext.instance().reset();
          try {
            reader.close();
          } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
          }
        }
      }
    
      // ···省略其他无关代码
    }

XMLConfigBuilder类的主要代码如下：  
**XMLConfigBuilder以及解析Mapper.xml文件的XMLMapperBuilder都继承自BaseBuilder。他们对xml文件的加载和解析都交给了XPathParser，从而最终使用JDK自带的xml解析器而非dom4j、jdom第三方jar包，底层使用xPath进行节点解析（不了解xPath的可以去学习下）。new XPathParser(reader, true, props, new XMLMapperEntityResolver()) 四个参数的含义分别是：配置文件流、是否进行DTD校验、属性配置、xml实体节点解析器。EntityResolver比较好理解，跟Spring的XML标签解析器一样，有默认的解析器，也有自定义的比如tx，dubbo等，主要使用了策略模式，在这里mybatis硬编码为了XMLMapperEntityResolver**

public class XMLConfigBuilder extends BaseBuilder {
    
      private boolean parsed;
      private final XPathParser parser;
      private String environment;
      private final ReflectorFactory localReflectorFactory = new 	   DefaultReflectorFactory(); 
    
      //1.先走这里
      public XMLConfigBuilder(Reader reader) {
        this(reader, null, null);
      }
      // 2.进入这里，创建XPathParser器
      public XMLConfigBuilder(Reader reader, String environment, Properties props) {
        this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
      }
    
      public XMLConfigBuilder(InputStream inputStream) {
        this(inputStream, null, null);
      }
    
      public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
        this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
      }
    
      // 3.最终都会调用此方法，再次之前会进入XPathParser类中进行一系列初始化操作，见下。
      private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        super(new Configuration());
        ErrorContext.instance().resource("SQL Mapper Configuration");
        this.configuration.setVariables(props);
        this.parsed = false;
        this.environment = environment;
        this.parser = parser;
      }
    
      public Configuration parse() {
        if (parsed) {
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
      }
    
      // 省略其他无关代码
    }

XPathParser类代码如下：  
**补充一下：EntityResolver的作用：EntityResolver的实现类XMLEntityResolver类中引用了本地的DTD文件，和本类在同一个package下，其中的ibatis-3-config.dtd应该主要是用于兼容用途。  
其次就是XPathParser做了以下几件事：1.将是否验证dtd,节点解析器进行设置，并且初始化xPath,便于xml文件解析和加载。2.可知，commonConstructor并没有做什么。回过头到createDocument上，其使用了org.xml.sax.InputSource作为参数。代码实现如下：**

public class XPathParser {
    
      private final Document document;
      private boolean validation;
      private EntityResolver entityResolver;
      private Properties variables;
      private XPath xpath;
    
      public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
      	// 1.将是否验证dtd,节点解析器进行设置，并且初始化xPath,便于xml文件解析和加载
        commonConstructor(validation, variables, entityResolver);
        // 2.可知，commonConstructor并没有做什么。回过头到createDocument上，其使用了org.xml.sax.InputSource作为参数，createDocument的关键代码如下：
        this.document = createDocument(new InputSource(inputStream));
      }
    
    // 创建document文档
    private Document createDocument(InputSource inputSource) {
        // important: this must only be called AFTER common constructor
        try {
          DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
          factory.setValidating(validation);
    	 // 设置有本工厂创建的解析器文件是否支持xml命名空间
          factory.setNamespaceAware(false);
          factory.setIgnoringComments(true);
          // 是否忽略元素配置中的空格
          factory.setIgnoringElementContentWhitespace(false);
          // 设置是否将CDATA节点转换为Text节点
          factory.setCoalescing(false);
          // 设置是否展开实体节点，关系到sql片段的相关配置
          factory.setExpandEntityReferences(true);
    
          DocumentBuilder builder = factory.newDocumentBuilder();
          // 设置解析mybatis-config.xml文档节点的解析器，也就是上面的XmlMapperEntityResolver
          builder.setEntityResolver(entityResolver);
          builder.setErrorHandler(new ErrorHandler() {
            @Override
            public void error(SAXParseException exception) throws SAXException {
              throw exception;
            }
    
            @Override
            public void fatalError(SAXParseException exception) throws SAXException {
              throw exception;
            }
    
            @Override
            public void warning(SAXParseException exception) throws SAXException {
            }
          });
          return builder.parse(inputSource);
        } catch (Exception e) {
          throw new BuilderException("Error creating document instance.  Cause: " + e, e);
        }
      }
      //主要进行一些配置 
      private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
        this.validation = validation;
        this.entityResolver = entityResolver;
        this.variables = variables;
        XPathFactory factory = XPathFactory.newInstance();
        this.xpath = factory.newXPath();
      }
    
    
    	// ···省略其他无关代码···
    }

**主要是根据mybatis自身需要创建一个=文档解析器，调用parse方法（inputstream int）.将解析后的xml以document对象的形式返回。**如下：

public class XMLConfigBuilder extends BaseBuilder {
    	private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
    	    super(new Configuration());
    	    ErrorContext.instance().resource("SQL Mapper Configuration");
    	    this.configuration.setVariables(props);
    	    this.parsed = false;
    	    this.environment = environment;
    	    this.parser = parser;
      }
    }

**可以看出：主要调用了父类BaseBuilder的构造方法（作用：进行类型别名处理器注册、类型处理器注册）**

public abstract class BaseBuilder {
      protected final Configuration configuration;
      protected final TypeAliasRegistry typeAliasRegistry;
      protected final TypeHandlerRegistry typeHandlerRegistry;
    
      public BaseBuilder(Configuration configuration) {
        // 出入的新new出来的Configuration对象，Configuration类的初始化的做了一些事情，后面讲具体是什么事。
        this.configuration = configuration;
        // 别名处理器
        this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
        // 类型处理器
        this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
      }
    }

**之后，设置environment及props等核心配置信息，（Configuration类是MyBatis的核心配置类，十分重要）。XmlConfigBuilder创建完毕之后，代码会回到SqlSessionFactoryBuilder类build(Reader reader, String environment, Properties properties)方法中，然后调用parser.parse()方法。至此，第一阶段：加载xml配置文件并转为Document对象完毕，而所有的配置过程都在parse()这个方法中（也是对Configuration类的配置）。**

## 二、Document对象转为Configuration对象 ##

**之前的步骤将mybatis-config.xml转为了Document对象，下一步就是将Document转换为MyBatis中的Configuration类对象。其主要步骤在XMLConfigBuilder类中的parseConfiguration(XNode root)方法进行。**如下：

public class SqlSessionFactoryBuilder {
    
      public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
          XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
          return build(parser.parse());
        } catch (Exception e) {
          throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {
          ErrorContext.instance().reset();
          try {
            reader.close();
          } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
          }
        }
      }
    }

XMLConfigBuilder类：  
**通过parseConfiguration(parser.evalNode("/configuration"))得知，xml文件中的configuration中的内容已经全部加载到XNode中了，后续的相关配置数据的获取都是通过这个XNode来获取的。**

public class XMLConfigBuilder extends BaseBuilder {
      private boolean parsed;
      private final XPathParser parser;
      private String environment;
      private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
    
      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);
          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);
        }
      }
    
    }

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

### 2.1 MyBatis dtd和Configuration类 ###

先来看看MyBatis dtd的约束文件：  
位置在：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTcyMzU0NA_size_16_color_FFFFFF_t_70]

<?xml version="1.0" encoding="UTF-8" ?>
    
    <!ELEMENT configuration (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, reflectorFactory?, plugins?, environments?, databaseIdProvider?, mappers?)>
    
    <!ELEMENT databaseIdProvider (property*)>
    <!ATTLIST databaseIdProvider
    type CDATA #REQUIRED
    >
    
    <!ELEMENT properties (property*)>
    <!ATTLIST properties
    resource CDATA #IMPLIED
    url CDATA #IMPLIED
    >
    
    <!ELEMENT property EMPTY>
    <!ATTLIST property
    name CDATA #REQUIRED
    value CDATA #REQUIRED
    >
    
    <!ELEMENT settings (setting+)>
    
    <!ELEMENT setting EMPTY>
    <!ATTLIST setting
    name CDATA #REQUIRED
    value CDATA #REQUIRED
    >
    
    <!ELEMENT typeAliases (typeAlias*,package*)>
    
    <!ELEMENT typeAlias EMPTY>
    <!ATTLIST typeAlias
    type CDATA #REQUIRED
    alias CDATA #IMPLIED
    >
    
    <!ELEMENT typeHandlers (typeHandler*,package*)>
    
    <!ELEMENT typeHandler EMPTY>
    <!ATTLIST typeHandler
    javaType CDATA #IMPLIED
    jdbcType CDATA #IMPLIED
    handler CDATA #REQUIRED
    >
    
    <!ELEMENT objectFactory (property*)>
    <!ATTLIST objectFactory
    type CDATA #REQUIRED
    >
    
    <!ELEMENT objectWrapperFactory EMPTY>
    <!ATTLIST objectWrapperFactory
    type CDATA #REQUIRED
    >
    
    <!ELEMENT reflectorFactory EMPTY>
    <!ATTLIST reflectorFactory
    type CDATA #REQUIRED
    >
    
    <!ELEMENT plugins (plugin+)>
    
    <!ELEMENT plugin (property*)>
    <!ATTLIST plugin
    interceptor CDATA #REQUIRED
    >
    
    <!ELEMENT environments (environment+)>
    <!ATTLIST environments
    default CDATA #REQUIRED
    >
    
    <!ELEMENT environment (transactionManager,dataSource)>
    <!ATTLIST environment
    id CDATA #REQUIRED
    >
    
    <!ELEMENT transactionManager (property*)>
    <!ATTLIST transactionManager
    type CDATA #REQUIRED
    >
    
    <!ELEMENT dataSource (property*)>
    <!ATTLIST dataSource
    type CDATA #REQUIRED
    >
    
    <!ELEMENT mappers (mapper*,package*)>
    
    <!ELEMENT mapper EMPTY>
    <!ATTLIST mapper
    resource CDATA #IMPLIED
    url CDATA #IMPLIED
    class CDATA #IMPLIED
    >
    
    <!ELEMENT package EMPTY>
    <!ATTLIST package
    name CDATA #REQUIRED
    >

**从dtd文件可以看出：mybatis-config.xml文件中最多有11个配置项，分别是properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mapper?,但是所有的配置都是可选的，这意味着mybatis-config配置文件本身可以什么都不包含。因为所有的配置最后保存到org.apache.ibatis.session.Configuration中，所以在详细查看每块配置的解析前，我们来看下Configuration的内部完整结构：**

public class Configuration {
    
      protected Environment environment;
      // 允许在嵌套语句中使用分页（RowBounds),如果允许使用则设置成false。默认为false.
      protected boolean safeRowBoundsEnabled;
      // 允许在嵌套语句中使用分页。如果允许设置为false.
      protected boolean safeResultHandlerEnabled = true;
      // 是否开启自动驼峰命名规则（camel case)映射。如user_name   ---> userName，默认false
      protected boolean mapUnderscoreToCamelCase;
      // 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性则按需加载。默认是false.
      protected boolean aggressiveLazyLoading;
      // 是否允许单一语句返回多结果集（需要兼容驱动）
      protected boolean multipleResultSetsEnabled = true;
      // 允许JDBC自动生成主键，需要驱动兼容。这就是insert时获取mysql自增或oralce sequence的开关。开发中，一般希望插入后获取主键，所以设置成true.
      
      protected boolean useGeneratedKeys；
      // 使用列标签代替列名，开发中一半进行配置。
      protected boolean useColumnLabel = true;
      // 是否开启缓存
      protected boolean cacheEnabled = true;
      // 指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的
      protected boolean callSettersOnNulls;
      // 允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的工程必须采用Java 8编译，并且加上-parameters选项。（从3.4.1开始）
      protected boolean useActualParamName = true;
      // 当返回行的所有列都是空时，MyBatis默认返回null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集 (i.e. collectioin and association)。（从3.4.2开始） 注：这里应该拆分为两个参数比较合适, 一个用于结果集，一个用于单记录。通常来说，我们会希望结果集不是null，单记录仍然是null
      protected boolean returnInstanceForEmptyRow;
    
      // 指定 MyBatis 增加到日志名称的前缀。
      protected String logPrefix;
      // 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。一般建议指定为slf4j或log4j
      protected Class <? extends Log> logImpl;
      // 指定VFS的实现, VFS是mybatis提供的用于访问AS内资源的一个简便接口
      protected Class <? extends VFS> vfsImpl;
      // MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据
      protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
      // 当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER
      protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
      // 指定对象的哪个方法触发一次延迟加载
      protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] { "equals", "clone", "hashCode", "toString" }));
      // 设置超时时间，它决定驱动等待数据库响应的秒数。默认不超时
      protected Integer defaultStatementTimeout;
      // 为驱动的结果集设置默认获取数量
      protected Integer defaultFetchSize;
      // SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新
      protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
      // 指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）
      protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
      // 指定发现自动映射目标未知列（或者未知属性类型）的行为。这个值应该设置为WARNING比较合适
      protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;
    
      // settings下的properties属性
      protected Properties variables = new Properties();
      //  默认的反射器工厂,用于操作属性、构造器方便
      protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
      // 对象工厂, 所有的类resultMap类都需要依赖于对象工厂来实例化
      protected ObjectFactory objectFactory = new DefaultObjectFactory();
      // 对象包装器工厂,主要用来在创建非原生对象,比如增加了某些监控或者特殊属性的代理类
      protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
    
      // 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态
      protected boolean lazyLoadingEnabled = false;
      // 指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。MyBatis 3.3+使用JAVASSIST
      protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL
    
      // MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。
      protected String databaseId;
      /**
       * Configuration factory class.
       * Used to create Configuration for loading deserialized unread properties.
       *
       * @see <a href='https://code.google.com/p/mybatis/issues/detail?id=300'>Issue 300 (google code)</a>
       */
      protected Class<?> configurationFactory;
    
      protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
      // mybatis插件列表
      protected final InterceptorChain interceptorChain = new InterceptorChain();
      // 类型注册器, 用于在执行sql语句的出入参映射以及mybatis-config文件里的各种配置比如<transactionManager type="JDBC"/><dataSource type="POOLED">时使用简写, 后面会详细解释
      protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
      protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
      protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
    
      protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");
      protected final Map<String, Cache> caches = new StrictMap<Cache>("Caches collection");
      protected final Map<String, ResultMap> resultMaps = new StrictMap<ResultMap>("Result Maps collection");
      protected final Map<String, ParameterMap> parameterMaps = new StrictMap<ParameterMap>("Parameter Maps collection");
      protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<KeyGenerator>("Key Generators collection");
    
      protected final Set<String> loadedResources = new HashSet<String>();
      protected final Map<String, XNode> sqlFragments = new StrictMap<XNode>("XML fragments parsed from previous mappers");
    
      protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<XMLStatementBuilder>();
      protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<CacheRefResolver>();
      protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<ResultMapResolver>();
      protected final Collection<MethodResolver> incompleteMethods = new LinkedList<MethodResolver>();
    
      /*
       * A map holds cache-ref relationship. The key is the namespace that
       * references a cache bound to another namespace and the value is the
       * namespace which the actual cache is bound to.
       */
      protected final Map<String, String> cacheRefMap = new HashMap<String, String>();
    
      public Configuration(Environment environment) {
        this();
        this.environment = environment;
      }
    
      public Configuration() {
        // 内置别名注册
        typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
        typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
    
        typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
        typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
        typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
    
        typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
        typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
        typeAliasRegistry.registerAlias("LRU", LruCache.class);
        typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
        typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
    
        typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
    
        typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
        typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
    
        typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
        typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
        typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
        typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
        typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
        typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
        typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
    
        typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
        typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
    
        languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
        languageRegistry.register(RawLanguageDriver.class);
      }
    
      // 省略部分无关代码
      /** @deprecated Use {@link #getDefaultScriptingLanguageInstance()} */
      @Deprecated
      public LanguageDriver getDefaultScriptingLanuageInstance() {
        return getDefaultScriptingLanguageInstance();
      }
    
      public MetaObject newMetaObject(Object object) {
        return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
      }
    
      public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
        parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
        return parameterHandler;
      }
    
      public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
          ResultHandler resultHandler, BoundSql boundSql) {
        ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
        resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
        return resultSetHandler;
      }
    
      public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
        return statementHandler;
      }
    
      public Executor newExecutor(Transaction transaction) {
        return newExecutor(transaction, defaultExecutorType);
      }
    
      public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        executorType = executorType == null ? defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        Executor executor;
        if (ExecutorType.BATCH == executorType) {
          executor = new BatchExecutor(this, transaction);
        } else if (ExecutorType.REUSE == executorType) {
          executor = new ReuseExecutor(this, transaction);
        } else {
          executor = new SimpleExecutor(this, transaction);
        }
        if (cacheEnabled) {
          executor = new CachingExecutor(executor);
        }
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }
    
      public void addKeyGenerator(String id, KeyGenerator keyGenerator) {
        keyGenerators.put(id, keyGenerator);
      }
    
      public Collection<String> getKeyGeneratorNames() {
        return keyGenerators.keySet();
      }
    
      public Collection<KeyGenerator> getKeyGenerators() {
        return keyGenerators.values();
      }
    
      public KeyGenerator getKeyGenerator(String id) {
        return keyGenerators.get(id);
      }
    
      public boolean hasKeyGenerator(String id) {
        return keyGenerators.containsKey(id);
      }
    
      public void addCache(Cache cache) {
        caches.put(cache.getId(), cache);
      }
    
      public Collection<String> getCacheNames() {
        return caches.keySet();
      }
    
      public Collection<Cache> getCaches() {
        return caches.values();
      }
    
      public Cache getCache(String id) {
        return caches.get(id);
      }
    
      public boolean hasCache(String id) {
        return caches.containsKey(id);
      }
    
      public void addResultMap(ResultMap rm) {
        resultMaps.put(rm.getId(), rm);
        checkLocallyForDiscriminatedNestedResultMaps(rm);
        checkGloballyForDiscriminatedNestedResultMaps(rm);
      }
    
      public Collection<String> getResultMapNames() {
        return resultMaps.keySet();
      }
    
      public Collection<ResultMap> getResultMaps() {
        return resultMaps.values();
      }
    
      public ResultMap getResultMap(String id) {
        return resultMaps.get(id);
      }
    
      public boolean hasResultMap(String id) {
        return resultMaps.containsKey(id);
      }
    
      public void addParameterMap(ParameterMap pm) {
        parameterMaps.put(pm.getId(), pm);
      }
    
      public Collection<String> getParameterMapNames() {
        return parameterMaps.keySet();
      }
    
      public Collection<ParameterMap> getParameterMaps() {
        return parameterMaps.values();
      }
    
      public ParameterMap getParameterMap(String id) {
        return parameterMaps.get(id);
      }
    
      public boolean hasParameterMap(String id) {
        return parameterMaps.containsKey(id);
      }
    
      public void addMappedStatement(MappedStatement ms) {
        mappedStatements.put(ms.getId(), ms);
      }
    
      public Collection<String> getMappedStatementNames() {
        buildAllStatements();
        return mappedStatements.keySet();
      }
    
      public Collection<MappedStatement> getMappedStatements() {
        buildAllStatements();
        return mappedStatements.values();
      }
    
      public Collection<XMLStatementBuilder> getIncompleteStatements() {
        return incompleteStatements;
      }
    
      public void addIncompleteStatement(XMLStatementBuilder incompleteStatement) {
        incompleteStatements.add(incompleteStatement);
      }
    
      public Collection<CacheRefResolver> getIncompleteCacheRefs() {
        return incompleteCacheRefs;
      }
    
      public void addIncompleteCacheRef(CacheRefResolver incompleteCacheRef) {
        incompleteCacheRefs.add(incompleteCacheRef);
      }
    
      public Collection<ResultMapResolver> getIncompleteResultMaps() {
        return incompleteResultMaps;
      }
    
      public void addIncompleteResultMap(ResultMapResolver resultMapResolver) {
        incompleteResultMaps.add(resultMapResolver);
      }
    
      public void addIncompleteMethod(MethodResolver builder) {
        incompleteMethods.add(builder);
      }
    
      public Collection<MethodResolver> getIncompleteMethods() {
        return incompleteMethods;
      }
    
      public MappedStatement getMappedStatement(String id) {
        return this.getMappedStatement(id, true);
      }
    
      public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
        if (validateIncompleteStatements) {
          buildAllStatements();
        }
        return mappedStatements.get(id);
      }
    
      public Map<String, XNode> getSqlFragments() {
        return sqlFragments;
      }
    
      public void addInterceptor(Interceptor interceptor) {
        interceptorChain.addInterceptor(interceptor);
      }
    
      public void addMappers(String packageName, Class<?> superType) {
        mapperRegistry.addMappers(packageName, superType);
      }
    
      public void addMappers(String packageName) {
        mapperRegistry.addMappers(packageName);
      }
    
      public <T> void addMapper(Class<T> type) {
        mapperRegistry.addMapper(type);
      }
    
      public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        return mapperRegistry.getMapper(type, sqlSession);
      }
    
      public boolean hasMapper(Class<?> type) {
        return mapperRegistry.hasMapper(type);
      }
    
      public boolean hasStatement(String statementName) {
        return hasStatement(statementName, true);
      }
    
      public boolean hasStatement(String statementName, boolean validateIncompleteStatements) {
        if (validateIncompleteStatements) {
          buildAllStatements();
        }
        return mappedStatements.containsKey(statementName);
      }
    
      public void addCacheRef(String namespace, String referencedNamespace) {
        cacheRefMap.put(namespace, referencedNamespace);
      }
    
      /*
       * Parses all the unprocessed statement nodes in the cache. It is recommended
       * to call this method once all the mappers are added as it provides fail-fast
       * statement validation.
       */
      protected void buildAllStatements() {
        if (!incompleteResultMaps.isEmpty()) {
          synchronized (incompleteResultMaps) {
            // This always throws a BuilderException.
            incompleteResultMaps.iterator().next().resolve();
          }
        }
        if (!incompleteCacheRefs.isEmpty()) {
          synchronized (incompleteCacheRefs) {
            // This always throws a BuilderException.
            incompleteCacheRefs.iterator().next().resolveCacheRef();
          }
        }
        if (!incompleteStatements.isEmpty()) {
          synchronized (incompleteStatements) {
            // This always throws a BuilderException.
            incompleteStatements.iterator().next().parseStatementNode();
          }
        }
        if (!incompleteMethods.isEmpty()) {
          synchronized (incompleteMethods) {
            // This always throws a BuilderException.
            incompleteMethods.iterator().next().resolve();
          }
        }
      }
    
      /*
       * Extracts namespace from fully qualified statement id.
       *
       * @param statementId
       * @return namespace or null when id does not contain period.
       */
      protected String extractNamespace(String statementId) {
        int lastPeriod = statementId.lastIndexOf('.');
        return lastPeriod > 0 ? statementId.substring(0, lastPeriod) : null;
      }
    
      // Slow but a one time cost. A better solution is welcome.
      protected void checkGloballyForDiscriminatedNestedResultMaps(ResultMap rm) {
        if (rm.hasNestedResultMaps()) {
          for (Map.Entry<String, ResultMap> entry : resultMaps.entrySet()) {
            Object value = entry.getValue();
            if (value instanceof ResultMap) {
              ResultMap entryResultMap = (ResultMap) value;
              if (!entryResultMap.hasNestedResultMaps() && entryResultMap.getDiscriminator() != null) {
                Collection<String> discriminatedResultMapNames = entryResultMap.getDiscriminator().getDiscriminatorMap().values();
                if (discriminatedResultMapNames.contains(rm.getId())) {
                  entryResultMap.forceNestedResultMaps();
                }
              }
            }
          }
        }
      }
    
      // Slow but a one time cost. A better solution is welcome.
      protected void checkLocallyForDiscriminatedNestedResultMaps(ResultMap rm) {
        if (!rm.hasNestedResultMaps() && rm.getDiscriminator() != null) {
          for (Map.Entry<String, String> entry : rm.getDiscriminator().getDiscriminatorMap().entrySet()) {
            String discriminatedResultMapName = entry.getValue();
            if (hasResultMap(discriminatedResultMapName)) {
              ResultMap discriminatedResultMap = resultMaps.get(discriminatedResultMapName);
              if (discriminatedResultMap.hasNestedResultMaps()) {
                rm.forceNestedResultMaps();
                break;
              }
            }
          }
        }
      }
    
      protected static class StrictMap<V> extends HashMap<String, V> {
    
        private static final long serialVersionUID = -4950446264854982944L;
        private final String name;
    
        public StrictMap(String name, int initialCapacity, float loadFactor) {
          super(initialCapacity, loadFactor);
          this.name = name;
        }
    
        public StrictMap(String name, int initialCapacity) {
          super(initialCapacity);
          this.name = name;
        }
    
        public StrictMap(String name) {
          super();
          this.name = name;
        }
    
        public StrictMap(String name, Map<String, ? extends V> m) {
          super(m);
          this.name = name;
        }
    
        @SuppressWarnings("unchecked")
        public V put(String key, V value) {
          if (containsKey(key)) {
            throw new IllegalArgumentException(name + " already contains value for " + key);
          }
          if (key.contains(".")) {
            final String shortKey = getShortName(key);
            if (super.get(shortKey) == null) {
              super.put(shortKey, value);
            } else {
              super.put(shortKey, (V) new Ambiguity(shortKey));
            }
          }
          return super.put(key, value);
        }
    
        public V get(Object key) {
          V value = super.get(key);
          if (value == null) {
            throw new IllegalArgumentException(name + " does not contain value for " + key);
          }
          if (value instanceof Ambiguity) {
            throw new IllegalArgumentException(((Ambiguity) value).getSubject() + " is ambiguous in " + name
                + " (try using the full name including the namespace, or rename one of the entries)");
          }
          return value;
        }
    
        private String getShortName(String key) {
          final String[] keyParts = key.split("\\.");
          return keyParts[keyParts.length - 1];
        }
    
        protected static class Ambiguity {
          final private String subject;
    
          public Ambiguity(String subject) {
            this.subject = subject;
          }
    
          public String getSubject() {
            return subject;
          }
        }
      }
    
    }

**mybatis中所有环境配置、resultMap集合、sql语句集合、插件列表、缓存、加载的xml列表、类型别名、类型处理器等全部都维护在Configuration中。Configuration中包含了一个内部静态类StrictMap，它继承于HashMap，对HashMap的装饰在于增加了put时防重复的处理，get时取不到值时候的异常处理，这样核心应用层就不需要额外关心各种对象异常处理,简化应用层逻辑。  
从设计上来说，我们可以说Configuration并不是一个thin类(也就是仅包含了属性以及getter/setter)，而是一个rich类，它对部分逻辑进行了封装便于用户直接使用,而不是让用户各自散落处理，比如addResultMap方法和getMappedStatement方法等等  
mybatis每个配置属性含义可参考:[官方：配置文件][Link 1]  
可以看出官方文档的配置项其实Configuration类的字段。  
从Configuration构造器和protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();可以看出，所有我们在mybatis-config和mapper文件中使用的类似int/string/JDBC/POOLED等字面常量最终解析为具体的java类型都是在typeAliasRegistry构造器和Configuration构造器执行期间初始化的。  
接下里我们将分块进行分析：**

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

### 2.2 propertiesElement解析 ###

**XMLConfigBuilder类中的解析代码**：

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

**mybatis-config.xml文件中的配置**：

**代码如下**

private void propertiesElement(XNode context) throws Exception {
        if (context != null) {
          // 加载properties结点为default
          Properties defaults = context.getChildrenAsProperties();
          String resource = context.getStringAttribute("resource");
          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.");
          }
          // 合并properties
          if (resource != null) {
            defaults.putAll(Resources.getResourceAsProperties(resource));
          } else if (url != null) {
            defaults.putAll(Resources.getUrlAsProperties(url));
          }
          Properties vars = configuration.getVariables();
          if (vars != null) {
            defaults.putAll(vars);
          }
          // 设置到parser和configuration中去
          parser.setVariables(defaults);
          configuration.setVariables(defaults);
        }
      }

**解析代码如下**：  
思路：**先解析mybatis-config.xml配置文件中的properties资源并解析成Properties对象，然后再从resouce或url中加载配置资源也解析为Properties类对象，最后将两者的内容合并到defaults中。最后设置到XPathParser类和Configuration类的variables字段中，这样就可以在整个配置文件使用这些东西。**

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

### 2.3 settingsAsProperties设置 ###

**mybatis-config.xml文件中的配置**：

**代码如下**：

private Properties settingsAsProperties(XNode context) {
        if (context == null) {
          return new Properties();
        }
        // 1.加载setting标签下的对象为Properties对象
        Properties props = context.getChildrenAsProperties();
        // Check that all settings are known to the configuration class
        MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
        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).");
          }
        }
        return props;
      }

settingsElement(settings)实现：

private void settingsElement(Properties props) throws Exception {
        configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
        configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
        configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
        configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
        configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
        configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
        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")));
        configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
        configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
        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")));
        @SuppressWarnings("unchecked")
        Class<? extends TypeHandler> typeHandler = (Class<? extends TypeHandler>)resolveClass(props.getProperty("defaultEnumTypeHandler"));
        configuration.setDefaultEnumTypeHandler(typeHandler);
        configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
        configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
        configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
        configuration.setLogPrefix(props.getProperty("logPrefix"));
        @SuppressWarnings("unchecked")
        Class<? extends Log> logImpl = (Class<? extends Log>)resolveClass(props.getProperty("logImpl"));
        configuration.setLogImpl(logImpl);
        configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
      }

**思路：**  
**一、先把settings结点解析成Properties对象；然后加载MetaClass类对props中的key的合法性进行校验（可以不能乱写，必须是框架支持的定义过的）；最后如果全部校验通过，就会返回合法的settings对象，否则有一个不通过就会抛出异常。**  
**二、其后在调用settingsElement(settings)方法，把解析到的配置文件信息注入Configuration类的属性中去。**

**关于MetaClass作用补充**：

public static MetaClass forClass(Class<?> type, ReflectorFactory reflectorFactory) {
        // new 出来
        return new MetaClass(type, reflectorFactory);
      }

MetaClass 类构造器：

public class MetaClass {
    
      private final ReflectorFactory reflectorFactory;
      private final Reflector reflector;
    
      // 调用的构造器 
      private MetaClass(Class<?> type, ReflectorFactory reflectorFactory) {
        this.reflectorFactory = reflectorFactory;
        this.reflector = reflectorFactory.findForClass(type);
      }
    }

默认的DefaultReflectorFactory类：

public class DefaultReflectorFactory implements ReflectorFactory {
      @Override
      public Reflector findForClass(Class<?> type) {
        if (classCacheEnabled) {
                // synchronized (type) removed see issue #461
          Reflector cached = reflectorMap.get(type);
          if (cached == null) {
            cached = new Reflector(type);
            reflectorMap.put(type, cached);
          }
          return cached;
        } else {
          // 最终会new Reflector(class)，实际注入的参数是Configuration类type
          return new Reflector(type);
        }
      }
    }

Reflector类及构造器：  
作用：把configuration类相关的类元信息进行解析装载到reflector中去。

public class Reflector {
    
      private final Class<?> type;
      private final String[] readablePropertyNames;
      private final String[] writeablePropertyNames;
      private final Map<String, Invoker> setMethods = new HashMap<String, Invoker>();
      private final Map<String, Invoker> getMethods = new HashMap<String, Invoker>();
      private final Map<String, Class<?>> setTypes = new HashMap<String, Class<?>>();
      private final Map<String, Class<?>> getTypes = new HashMap<String, Class<?>>();
      private Constructor<?> defaultConstructor;
    
      private Map<String, String> caseInsensitivePropertyMap = new HashMap<String, String>();
    
      public Reflector(Class<?> clazz) {
        type = clazz;
        addDefaultConstructor(clazz);
        addGetMethods(clazz);
        addSetMethods(clazz);
        addFields(clazz);
        readablePropertyNames = getMethods.keySet().toArray(new String[getMethods.keySet().size()]);
        writeablePropertyNames = setMethods.keySet().toArray(new String[setMethods.keySet().size()]);
        for (String propName : readablePropertyNames) {
          caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }
        for (String propName : writeablePropertyNames) {
          caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }
      }

到此可以看出：**最后通过 !metaConfig.hasSetter(String.valueOf(key)代码看出：通过判断configuration类中是否有settings文件中的配置key的setter方法，才算校验通过。**

### 2.4 加载自定义VFS：loadCustomVfs(settings) ###

**思路：**  
VFS主要用来加载容器内的各种资源，比如jar或者class文件。mybatis提供了2个实现 JBoss6VFS 和 DefaultVFS，并提供了用户扩展点，用于自定义VFS实现，加载顺序是自定义VFS实现 > 默认VFS实现 取第一个加载成功的，默认情况下会先加载JBoss6VFS，如果classpath下找不到jboss的vfs实现才会加载默认VFS实现，启动打印的日志如下：

org.apache.ibatis.io.VFS.getClass(VFS.java:111) Class not found: org.jboss.vfs.VFS
    　　org.apache.ibatis.io.JBoss6VFS.setInvalid(JBoss6VFS.java:142) JBoss 6 VFS API is not available in this environment.
    　　org.apache.ibatis.io.VFS.getClass(VFS.java:111) Class not found: org.jboss.vfs.VirtualFile
    　　org.apache.ibatis.io.VFS$VFSHolder.createVFS(VFS.java:63) VFS implementation org.apache.ibatis.io.JBoss6VFS is not valid in this environment.
    　　org.apache.ibatis.io.VFS$VFSHolder.createVFS(VFS.java:77) Using VFS adapter org.apache.ibatis.io.DefaultVFS
    
    　　jboss vfs的maven仓库坐标为：
    
        <dependency>
            <groupId>org.jboss</groupId>
            <artifactId>jboss-vfs</artifactId>
            <version>3.2.12.Final</version>
        </dependency>
    　　找到jboss vfs实现后，输出的日志如下：
    　　org.apache.ibatis.io.VFS$VFSHolder.createVFS(VFS.java:77) Using VFS adapter org.apache.ibatis.io.JBoss6VFS

**具体代码实现如下：**

private void loadCustomVfs(Properties props) throws ClassNotFoundException {
        String value = props.getProperty("vfsImpl");
        if (value != null) {
          String[] clazzes = value.split(",");
          for (String clazz : clazzes) {
            if (!clazz.isEmpty()) {
              @SuppressWarnings("unchecked")
              Class<? extends VFS> vfsImpl = (Class<? extends VFS>)Resources.classForName(clazz);
              configuration.setVfsImpl(vfsImpl);
            }
          }
        }
      }

### 2.5 类型别名解析：typeAliasesElement(root.evalNode(“typeAliases”)) ###

**mybatis-config.xml中的如下配置：**

**代码如下：**

private void typeAliasesElement(XNode parent) {
        if (parent != null) {
          for (XNode child : parent.getChildren()) {
             // 1-1.package标签配置方式
            if ("package".equals(child.getName())) {
              String typeAliasPackage = child.getStringAttribute("name");
              // 1-2.调用TypeAliasRegistry类的方法进行类的别名注册
              configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
            } else {
              // 2-1typeAlias标签配置形式
              String alias = child.getStringAttribute("alias");
              String type = child.getStringAttribute("type");
              try {
                Class<?> clazz = Resources.classForName(type);
                if (alias == null) {
                  // 2-2.如果没有配置别名，默认取类名作为别名
                  typeAliasRegistry.registerAlias(clazz);
                } else {
                  // 2-3 如果配置了别名和对应的class,直接注册别名即可
                  typeAliasRegistry.registerAlias(alias, clazz);
                }
              } catch (ClassNotFoundException e) {
                throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
              }
            }
          }
        }
      }

public class TypeAliasRegistry {
    
      public void registerAliases(String packageName){
        // 1-3.调用本类的其他方法
        registerAliases(packageName, Object.class);
      }
    
      // 1-4.扫描包下的class文件，将符合条件的类进行别名注册，否则不予注册
      public void registerAliases(String packageName, Class<?> superType){
        ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
        resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
        Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
        for(Class<?> type : typeSet){
          // Ignore inner classes and interfaces (including package-info.java)
          // Skip also inner classes. See issue #6
          if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
            registerAlias(type);
          }
        }
      }
      // 1-5. 别名注册
      public void registerAlias(Class<?> type) {
        String alias = type.getSimpleName();
        Alias aliasAnnotation = type.getAnnotation(Alias.class);
        if (aliasAnnotation != null) {
          alias = aliasAnnotation.value();
        } 
        // --->真正的方法
        registerAlias(alias, type);
      }
    
      // 1-6.真正的别名注册（也就是往map中添加一个元素）
      public void registerAlias(String alias, Class<?> value) {
        if (alias == null) {
          throw new TypeException("The parameter alias cannot be null");
        }
        // issue #748
        String key = alias.toLowerCase(Locale.ENGLISH);
        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() + "'.");
        }
        TYPE_ALIASES.put(key, value);
      }
    }

**思路：**  
**我们知道typeAliases标签下有两种标签，所以其在解析的时候也是分为两种情况的：package和typeAlias。**  
***第一种如果是包的形式的话：下方标注的 “1-？”是执行的程序。***  
**首先会把配置的包路径名作为参数，调用TypeAliasRegistry类的registerAliases（）方法。**  
**其次在registerAliases(String packageName, Class superType)方法中会根据packageName名称拿到其下的.class文件，并加载到matches集合中去。**  
**再次，遍历mathes中类元素结合，这些类不能是匿名类、接口、内部类才会进行注册；符合条件后调用registerAlias(type)方法，注册别名（本质就是Configuration中的TYPE\_ALIASES字段就是一个HashMap添加元素）。**

***第二种如果是typeAlias的形式的话：下方标注的 “2-？”是执行的程序。***  
**首先取到alias和type。**  
**其次根据是否配置别名（没有配置，默认取小写类名），然后调用registerAlias（）方法进行级完成注册。**

**补充：**  
除了上述的这个地方之外，还有两处也进行了系统默认的类名注册。

*  Configuration类的构造器中：

public Configuration() {
        typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
        typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
    
        typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
        typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
        typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
    
        typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
        typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
        typeAliasRegistry.registerAlias("LRU", LruCache.class);
        typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
        typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
    
        typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
    
        typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
        typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
    
        typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
        typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
        typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
        typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
        typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
        typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
        typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
    
        typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
        typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
    
        languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
        languageRegistry.register(RawLanguageDriver.class);
      }

*  TypeAliasRegistry类的构造器中：

public TypeAliasRegistry() {
        registerAlias("string", String.class);
    
        registerAlias("byte", Byte.class);
        registerAlias("long", Long.class);
        registerAlias("short", Short.class);
        registerAlias("int", Integer.class);
        registerAlias("integer", Integer.class);
        registerAlias("double", Double.class);
        registerAlias("float", Float.class);
        registerAlias("boolean", Boolean.class);
    
        registerAlias("byte[]", Byte[].class);
        registerAlias("long[]", Long[].class);
        registerAlias("short[]", Short[].class);
        registerAlias("int[]", Integer[].class);
        registerAlias("integer[]", Integer[].class);
        registerAlias("double[]", Double[].class);
        registerAlias("float[]", Float[].class);
        registerAlias("boolean[]", Boolean[].class);
    
        registerAlias("_byte", byte.class);
        registerAlias("_long", long.class);
        registerAlias("_short", short.class);
        registerAlias("_int", int.class);
        registerAlias("_integer", int.class);
        registerAlias("_double", double.class);
        registerAlias("_float", float.class);
        registerAlias("_boolean", boolean.class);
    
        registerAlias("_byte[]", byte[].class);
        registerAlias("_long[]", long[].class);
        registerAlias("_short[]", short[].class);
        registerAlias("_int[]", int[].class);
        registerAlias("_integer[]", int[].class);
        registerAlias("_double[]", double[].class);
        registerAlias("_float[]", float[].class);
        registerAlias("_boolean[]", boolean[].class);
    
        registerAlias("date", Date.class);
        registerAlias("decimal", BigDecimal.class);
        registerAlias("bigdecimal", BigDecimal.class);
        registerAlias("biginteger", BigInteger.class);
        registerAlias("object", Object.class);
    
        registerAlias("date[]", Date[].class);
        registerAlias("decimal[]", BigDecimal[].class);
        registerAlias("bigdecimal[]", BigDecimal[].class);
        registerAlias("biginteger[]", BigInteger[].class);
        registerAlias("object[]", Object[].class);
    
        registerAlias("map", Map.class);
        registerAlias("hashmap", HashMap.class);
        registerAlias("list", List.class);
        registerAlias("arraylist", ArrayList.class);
        registerAlias("collection", Collection.class);
        registerAlias("iterator", Iterator.class);
    
        registerAlias("ResultSet", ResultSet.class);
      }

**对于上述这些类的别名，我们可以直接使用。**

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

### 2.6 加载插件:pluginElement(root.evalNode(“plugins”)) ###

几乎所有优秀的框架都会预留插件体系以便扩展，mybatis调用pluginElement(root.evalNode(“plugins”));加载mybatis插件，最常用的插件应该算是分页插件PageHelper了，再比如druid连接池提供的各种监控、拦截、预发检查功能，在使用其它连接池比如dbcp的时候，在不修改连接池源码的情况下，就可以借助mybatis的插件体系实现。加载插件的实现如下:

private void pluginElement(XNode parent) throws Exception {
        if (parent != null) {
          for (XNode child : parent.getChildren()) {
            String interceptor = child.getStringAttribute("interceptor");
            Properties properties = child.getChildrenAsProperties();
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
            interceptorInstance.setProperties(properties);
            configuration.addInterceptor(interceptorInstance);
          }
        }
      }

插件在具体实现的时候，采用的是拦截器模式，要注册为mybatis插件，必须实现org.apache.ibatis.plugin.Interceptor接口，每个插件可以有自己的属性。interceptor属性值既可以完整的类名，也可以是别名，只要别名在typealias中存在即可，如果启动时无法解析，会抛出ClassNotFound异常。实例化插件后，将设置插件的属性赋值给插件实现类的属性字段。后面会专门有一篇文章介绍。

### 2.7 加载对象工厂、创建对象包装器工厂、加载反射工厂 ###

这些都属于比较高级的部分，平时基本用不到。后面会专门介绍这些。

### 2.8 加载环境配置environmentsElement ###

**mybatis-config.xml文件中配置如下：**

**实现代码如下：**

private void environmentsElement(XNode context) throws Exception {
        if (context != null) {
          if (environment == null) {
            environment = context.getStringAttribute("default");
          }
          for (XNode child : context.getChildren()) {
            String id = child.getStringAttribute("id");
            // 查找匹配的env环境
            if (isSpecifiedEnvironment(id)) {
              // 事务管理器的配置
              TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
              // 数据源的配置
              DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
              DataSource dataSource = dsFactory.getDataSource();
              Environment.Builder environmentBuilder = new Environment.Builder(id)
                  .transactionFactory(txFactory)
                  .dataSource(dataSource);
              configuration.setEnvironment(environmentBuilder.build());
            }
          }
        }
      }

事务管理器配置的代码实现：

private TransactionFactory transactionManagerElement(XNode context) throws Exception {
        if (context != null) {
          String type = context.getStringAttribute("type");
          Properties props = context.getChildrenAsProperties();
          // 根据之前配置别名进行加载实例
          TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
          factory.setProperties(props);
          return factory;
        }
        throw new BuilderException("Environment declaration requires a TransactionFactory.");
      }

数据源进行配置（DataSource）代码如下：

private DataSourceFactory dataSourceElement(XNode context) throws Exception {
        if (context != null) {
          String type = context.getStringAttribute("type");
          Properties props = context.getChildrenAsProperties();
          DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
          factory.setProperties(props);
          return factory;
        }
        throw new BuilderException("Environment declaration requires a DataSourceFactory.");
      }

**思路：**  
**环境是MyBatis配置文件中最重要的部分之一，类似spring和maven的profile文件。同时给开发和生产环境配置不同的env环境，并根据不同的环境加载不同的配置，但是无论如果mybatis只能加载其中的一个配置。默认会使用default的环境。事务管理器和数据源类型在这里有JDBC和POOLED。前者主要用于简单JDBC模式，后者主要用于容器管理事务，一般使用JDBC事务管理方式。mybatis内置提供JNDI、POOLED、UNPOOLED三种数据源工厂，一般情况下使用POOLED数据源。  
1.先是进行事务管理器配置（TransactionFactory ）。主要流程是根据配置的type类型，到类型别名中取到相应的class并进行实例化，即完成TransactionFactory的创建。需要说明的是：MyBatis中TransactionFactory的默认的类型有2种（JdbcTransactionFactory和ManagedTransactionFactory），并且这种类型在别名加载时就已经初始化进去了。  
2.然后是对数据源进行配置（DataSource）。根据配置的连接池类型加载对应的dataSourceFactory工厂，然后获取相应的dataSource。然后调用Environment.Builder把factory和dataSource配置到Configuration中的env字段中去。**

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

### 2.9 解析＜databaseldProvider＞节点 ###

**形如如下配置**

**对应实现代码如下:**

databaseIdProviderElement(root.evalNode("databaseIdProvider"));

private void databaseIdProviderElement(XNode context) throws Exception {
        DatabaseIdProvider databaseIdProvider = null;
        if (context != null) {
          String type = context.getStringAttribute("type");
          // awful patch to keep backward compatibility
          if ("VENDOR".equals(type)) {
              type = "DB_VENDOR";
          }
          Properties properties = context.getChildrenAsProperties();
          databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
          databaseIdProvider.setProperties(properties);
        }
        Environment environment = configuration.getEnvironment();
        if (environment != null && databaseIdProvider != null) {
          String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
          configuration.setDatabaseId(databaseId);
        }
      }

**思路**：  
**根据配置的DB\_VENDOR找到DatabaseIdProvider的DatabaseIdProvider的实现类（VendorDatabaseIdProvider），与此同时将property标签的集合进行注入工作。其次在根据已加载DataSource连接信息，调用VendorDatabaseIdProvider.getDatabaseId()获取数据库连接类型。**

**DatabaseIdProvider的补充**

*  结构图  
    ![在这里插入图片描述][2018112823015046.png]
 *  源码

**补充：DatabaseIdProvider接口**

public interface DatabaseIdProvider {
      // 存储用户自定义的数据库配置
      void setProperties(Properties p);
      // 根据数据连接获得数据库产品的id标识
      String getDatabaseId(DataSource dataSource) throws SQLException;
    }

VendorDatabaseIdProvider实现类

public class VendorDatabaseIdProvider implements DatabaseIdProvider {
      
      private static final Log log = LogFactory.getLog(VendorDatabaseIdProvider.class);
    
      private Properties properties;
    
      @Override
      public String getDatabaseId(DataSource dataSource) {
        if (dataSource == null) {
          throw new NullPointerException("dataSource cannot be null");
        }
        try {
          return getDatabaseName(dataSource);
        } catch (Exception e) {
          log.error("Could not get a databaseId from dataSource", e);
        }
        return null;
      }
    
      @Override
      public void setProperties(Properties p) {
        this.properties = p;
      }
    
      private String getDatabaseName(DataSource dataSource) throws SQLException {
        // 解析DataSource连接的数据库产品名称
        String productName = getDatabaseProductName(dataSource);
        if (this.properties != null) {
          // 根据databaseIdProvider标签下的子节点配置的数据库产品和databaseId之间的关系，确定最终的使用的databaseId
          for (Map.Entry<Object, Object> property : properties.entrySet()) {
            if (productName.contains((String) property.getKey())) {
              return (String) property.getValue();
            }
          }
          // no match, return null
          // 找不到合适的database Id ，则返回null
          return null;
        }
        return productName;
      }
    
      private String getDatabaseProductName(DataSource dataSource) throws SQLException {
        Connection con = null;
        try {
          con = dataSource.getConnection();
          DatabaseMetaData metaData = con.getMetaData();
          return metaData.getDatabaseProductName();
        } finally {
          if (con != null) {
            try {
              con.close();
            } catch (SQLException e) {
              // ignored
            }
          }
        }
      }
      
    }

DefaultDatabaseIdProvider 实现类（已过时，在这里不分析）

@Deprecated
    public class DefaultDatabaseIdProvider extends VendorDatabaseIdProvider {
    }

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

### 2.10 加载mapper文件mapperElement ###

**形如如下的配置**

<mappers>
            <mapper resource="UserMapper.xml"/>
        </mappers>
    
        
        <mappers>
            <mapper class="com.gyoomi.mapper.UserMapper"></mapper>
        </mappers>
     
       
        <mappers>
            <mapper url="file://"></mapper>
        </mappers>
     
       
       <mappers>
            <package name="com.gyoomi"/>
        </mappers>

**对应代码如下**

private void mapperElement(XNode parent) throws Exception {
        if (parent != null) {
          for (XNode child : parent.getChildren()) { // 处理mappers结点
            if ("package".equals(child.getName())) { // 处理package结点得配置
              String mapperPackage = child.getStringAttribute("name");
              configuration.addMappers(mapperPackage);
            } else {
              // resource、url、class三者之间互斥
              String resource = child.getStringAttribute("resource");
              String url = child.getStringAttribute("url");
              String mapperClass = child.getStringAttribute("class");
              if (resource != null && url == null && mapperClass == null) {
                // 如果mapper节点指定了resouce或url。则创建XmlMapperBuilder对象，进行解析文件
                ErrorContext.instance().resource(resource);
                InputStream inputStream = Resources.getResourceAsStream(resource);
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url != null && mapperClass == null) {
               // 如果mapper节点指定了resouce或url。则创建XmlMapperBuilder对象，进行解析文件
                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) {
                // 如果mapper指定了class，则直接加载类，向MapperRegister中进行注册
                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.");
              }
            }
          }
        }
      }

**思路**  
分别package和mapper结点两种情况进行处理，最终都是调用MapperRegister中进行注册。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTcyMzU0NA_size_16_color_FFFFFF_t_70]: /images/20220417/593943c9729444fdb7bcc7077a57015e.png
[Link 1]: http://www.mybatis.org/mybatis-3/zh/configuration.html
[2018112823015046.png]: /images/20220417/75da6519ef7a4fecb389c7e855a01357.png