搜索

MyBatis启动之XMLConfigBuilder解析配置文件（二）

源码共读

共 18210字，需浏览 37分钟

 ·

2021-02-02 04:02

Python实战社群

Java实战社群

长按识别下方二维码，按需求添加

扫码关注添加客服

进Python社群▲

扫码关注添加客服

进Java社群▲


作者丨ytao

来源丨ytao

前言

XMLConfigBuilder 是 BaseBuilder（解析中会涉及到讲解）的其中一个子类，它的作用是把MyBatis的XML及相关配置解析出来，然后保存到 Configuration中。本文就解析过程按照执行顺序进行分析，掌握常用配置的解析原理。

使用

调用 XMLConfigBuilder进行解析，要进行两步操作，上篇文章中【MyBatis之启动分析（一）】有提到。

实例化 XMLConfigBuilder对象。

  1. privateXMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  2. // 调用父类的构造方法
  3. super(newConfiguration());
  4. ErrorContext.instance().resource("SQL Mapper Configuration");
  5. this.configuration.setVariables(props);
  6. this.parsed = false;
  7. this.environment = environment;
  8. this.parser = parser;
  9. }

实例化 Configuration

通过 newConfiguration()的方式实例化：typeAliasRegistry是一个类型别名注册器，实现原理就是维护一份 HashMap，别名作为 key，类的全限定名作为 value。这里将框架中使用的类注册到类型别名注册器中。TypeAliasRegistry.registerAlias代码如下：

  1. publicvoid registerAlias(String alias, Class value) {
  2. if(alias == null) {
  3. thrownewTypeException("The parameter alias cannot be null");
  4. }
  5. // issue #748
  6. //  在验证是否存在key和保存kv前，统一将key转换成小写
  7. String key = alias.toLowerCase(Locale.ENGLISH);
  8. if(TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null&& !TYPE_ALIASES.get(key).equals(value)) {
  9. // 当注册的类型已存在时，抛出异常
  10. thrownewTypeException("The alias '"+ alias + "' is already mapped to the value '"+ TYPE_ALIASES.get(key).getName() + "'.");
  11. }
  12. // TYPE_ALIASES 为定义的一个HashMap
  13.     TYPE_ALIASES.put(key, value);
  14. }

在实例化 Configuration类过程中，在该类里除了实例化了 TypeAliasRegistry还实例化了另外一个下面用到的的类：

  1. // 类型处理器注册器
  2. protectedfinalTypeAliasRegistry typeAliasRegistry = newTypeAliasRegistry();

TypeHandlerRegistry和 TypeAliasRegistry实例化逻辑相似，里面注册了一些常用类型和处理器，代码易懂。TypeHandlerRegistry的属性

  1. // jdbc类型和TypeHandler的映射关系，key必须是JdbcType的枚举类型，读取结果集数据时，将jdbc类型转换成java类型
  2. privatefinalMap<JdbcType, TypeHandler> JDBC_TYPE_HANDLER_MAP = newEnumMap<JdbcType, TypeHandler>(JdbcType.class);
  3. // Java类型与JdbcType类型的键值对，存在一对多的映射关系
  4. privatefinalMap<Type, Map<JdbcType, TypeHandler>> TYPE_HANDLER_MAP = newConcurrentHashMap<Type, Map<JdbcType, TypeHandler>>();
  5. // 没有相应的类型处理器时，使用的处理器
  6. privatefinalTypeHandler<Object> UNKNOWN_TYPE_HANDLER = newUnknownTypeHandler(this);
  7. // 类型处理器类类型和类型处理器的映射关系
  8. privatefinalMap<Class, TypeHandler> ALL_TYPE_HANDLERS_MAP = newHashMap<Class, TypeHandler>();
  9. // 空处理器的值，用来做校验
  10. privatestaticfinalMap<JdbcType, TypeHandler> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();
  11. // 默认枚举类型处理器
  12. privateClassextendsTypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;

TypeHandlerRegistry构造函数：

  1. publicTypeHandlerRegistry() {
  2. register(Boolean.class, newBooleanTypeHandler());
  3. register(boolean.class, newBooleanTypeHandler());
  4. register(JdbcType.BOOLEAN, newBooleanTypeHandler());
  5. register(JdbcType.BIT, newBooleanTypeHandler());

  7. register(Byte.class, newByteTypeHandler());
  8. register(byte.class, newByteTypeHandler());
  9. register(JdbcType.TINYINT, newByteTypeHandler());

  11. register(Short.class, newShortTypeHandler());
  12. register(short.class, newShortTypeHandler());
  13. register(JdbcType.SMALLINT, newShortTypeHandler());

  15. register(Integer.class, newIntegerTypeHandler());
  16. register(int.class, newIntegerTypeHandler());
  17. register(JdbcType.INTEGER, newIntegerTypeHandler());

  19. register(Long.class, newLongTypeHandler());
  20. register(long.class, newLongTypeHandler());

  22. register(Float.class, newFloatTypeHandler());
  23. register(float.class, newFloatTypeHandler());
  24. register(JdbcType.FLOAT, newFloatTypeHandler());

  26. register(Double.class, newDoubleTypeHandler());
  27. register(double.class, newDoubleTypeHandler());
  28. register(JdbcType.DOUBLE, newDoubleTypeHandler());

  30. register(Reader.class, newClobReaderTypeHandler());
  31. register(String.class, newStringTypeHandler());
  32. register(String.class, JdbcType.CHAR, newStringTypeHandler());
  33. register(String.class, JdbcType.CLOB, newClobTypeHandler());
  34. register(String.class, JdbcType.VARCHAR, newStringTypeHandler());
  35. register(String.class, JdbcType.LONGVARCHAR, newClobTypeHandler());
  36. register(String.class, JdbcType.NVARCHAR, newNStringTypeHandler());
  37. register(String.class, JdbcType.NCHAR, newNStringTypeHandler());
  38. register(String.class, JdbcType.NCLOB, newNClobTypeHandler());
  39. register(JdbcType.CHAR, newStringTypeHandler());
  40. register(JdbcType.VARCHAR, newStringTypeHandler());
  41. register(JdbcType.CLOB, newClobTypeHandler());
  42. register(JdbcType.LONGVARCHAR, newClobTypeHandler());
  43. register(JdbcType.NVARCHAR, newNStringTypeHandler());
  44. register(JdbcType.NCHAR, newNStringTypeHandler());
  45. register(JdbcType.NCLOB, newNClobTypeHandler());

  47. register(Object.class, JdbcType.ARRAY, newArrayTypeHandler());
  48. register(JdbcType.ARRAY, newArrayTypeHandler());

  50. register(BigInteger.class, newBigIntegerTypeHandler());
  51. register(JdbcType.BIGINT, newLongTypeHandler());

  53. register(BigDecimal.class, newBigDecimalTypeHandler());
  54. register(JdbcType.REAL, newBigDecimalTypeHandler());
  55. register(JdbcType.DECIMAL, newBigDecimalTypeHandler());
  56. register(JdbcType.NUMERIC, newBigDecimalTypeHandler());

  58. register(InputStream.class, newBlobInputStreamTypeHandler());
  59. register(Byte[].class, newByteObjectArrayTypeHandler());
  60. register(Byte[].class, JdbcType.BLOB, newBlobByteObjectArrayTypeHandler());
  61. register(Byte[].class, JdbcType.LONGVARBINARY, newBlobByteObjectArrayTypeHandler());
  62. register(byte[].class, newByteArrayTypeHandler());
  63. register(byte[].class, JdbcType.BLOB, newBlobTypeHandler());
  64. register(byte[].class, JdbcType.LONGVARBINARY, newBlobTypeHandler());
  65. register(JdbcType.LONGVARBINARY, newBlobTypeHandler());
  66. register(JdbcType.BLOB, newBlobTypeHandler());

  68. register(Object.class, UNKNOWN_TYPE_HANDLER);
  69. register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
  70. register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);

  72. register(Date.class, newDateTypeHandler());
  73. register(Date.class, JdbcType.DATE, newDateOnlyTypeHandler());
  74. register(Date.class, JdbcType.TIME, newTimeOnlyTypeHandler());
  75. register(JdbcType.TIMESTAMP, newDateTypeHandler());
  76. register(JdbcType.DATE, newDateOnlyTypeHandler());
  77. register(JdbcType.TIME, newTimeOnlyTypeHandler());

  79. register(java.sql.Date.class, newSqlDateTypeHandler());
  80. register(java.sql.Time.class, newSqlTimeTypeHandler());
  81. register(java.sql.Timestamp.class, newSqlTimestampTypeHandler());

  83. // mybatis-typehandlers-jsr310
  84. // 是否包含日期，时间相关的Api，通过判断是否加载java.time.Clock作为依据
  85. if(Jdk.dateAndTimeApiExists) {
  86. this.register(Instant.class, InstantTypeHandler.class);
  87. this.register(LocalDateTime.class, LocalDateTimeTypeHandler.class);
  88. this.register(LocalDate.class, LocalDateTypeHandler.class);
  89. this.register(LocalTime.class, LocalTimeTypeHandler.class);
  90. this.register(OffsetDateTime.class, OffsetDateTimeTypeHandler.class);
  91. this.register(OffsetTime.class, OffsetTimeTypeHandler.class);
  92. this.register(ZonedDateTime.class, ZonedDateTimeTypeHandler.class);
  93. this.register(Month.class, MonthTypeHandler.class);
  94. this.register(Year.class, YearTypeHandler.class);
  95. this.register(YearMonth.class, YearMonthTypeHandler.class);
  96. this.register(JapaneseDate.class, JapaneseDateTypeHandler.class);
  97. }

  99. // issue #273
  100. register(Character.class, newCharacterTypeHandler());
  101. register(char.class, newCharacterTypeHandler());
  102. }

里面调用了两个 register()重载方法， type+handler 参的 TypeHandlerRegistry.register(ClassjavaType,TypeHandlertypeHandler)和 type+jdbc type+handler 参的 TypeHandlerRegistry.register(Classtype,JdbcTypejdbcType,TypeHandlerhandler)

  1. // java type + handler
  2. public voidregister(Class javaType, TypeHandlerextends T> typeHandler) {
  3. register((Type) javaType, typeHandler);
  4. }

  6. private voidregister(Type javaType, TypeHandlerextends T> typeHandler) {
  7. MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
  8. if(mappedJdbcTypes != null) {
  9. for(JdbcType handledJdbcType : mappedJdbcTypes.value()) {
  10. register(javaType, handledJdbcType, typeHandler);
  11. }
  12. if(mappedJdbcTypes.includeNullJdbcType()) {
  13. register(javaType, null, typeHandler);
  14. }
  15. } else{
  16. register(javaType, null, typeHandler);
  17. }
  18. }

  20. // java type + jdbc type + handler
  21. public voidregister(Class type, JdbcType jdbcType, TypeHandlerextends T> handler) {
  22. register((Type) type, jdbcType, handler);
  23. }

  25. // type + handler 和 type + jdbc type + handler 最终都调用此方法
  26. privatevoidregister(Type javaType, JdbcType jdbcType, TypeHandler handler) {
  27. if(javaType != null) {
  28. // 当 javaType 不为空时， 获取 java 类型的的映射
  29. Map<JdbcType, TypeHandler> map = TYPE_HANDLER_MAP.get(javaType);
  30. if(map == null|| map == NULL_TYPE_HANDLER_MAP) {
  31. // 若映射为空，新建一个映射关系
  32.             map = newHashMap<JdbcType, TypeHandler>();
  33. // 保存至类型处理器映射关系中
  34.             TYPE_HANDLER_MAP.put(javaType, map);
  35. }
  36. // 保存jdbcType和处理器关系，完成 java类型，jdbc类型，处理器三者之间的注册
  37.           map.put(jdbcType, handler);
  38. }
  39. // 保存处理器信息中
  40.         ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
  41. }  

  43.     // MappedJdbcTypes 注解
  44. @Documented
  45. @Retention(RetentionPolicy.RUNTIME)
  46. @Target(ElementType.TYPE)
  47. public@interfaceMappedJdbcTypes{
  48. JdbcType[] value();
  49. boolean includeNullJdbcType() defaultfalse;
  50. }

  • type+handler方法：先获取处理器的 MappedJdbcTypes注解（自定义处理器注解），若注解的 value值不为空时，由于该值为 JdbcType[]类型，所以 for循环 javaType+jdbcType+TypeHandler注册，若 includeNullJdbcType（ jdbcType是否包含 null）为 true，默认值为 false,注册到相应映射中。若注解的 value为 null，直接调用注册操作，里面不会注册 type+jdbc type+handler关系。

  • type+jdbc type+handler方法：该方法将java类强制转换为 java.lang.reflect.Type类型，然后调用最终注册的方法。

调用父类 BaseBuilder的构造方法

BaseBuilder定义有三个属性

  1. protectedfinalConfiguration configuration;
  2. // 类型别名注册器
  3. protectedfinalTypeAliasRegistry typeAliasRegistry;
  4. // 类型处理器注册器
  5. protectedfinalTypeHandlerRegistry typeHandlerRegistry;

BaseBuilder构造方法

  1. publicBaseBuilder(Configuration configuration) {
  2. this.configuration = configuration;
  3. this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
  4. this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
  5. }

这里属性，就是上面讲解到的。

调用 XMLConfigBuilder.parse() 作为解析入口。

parse()实现配置文件是否解析过

  1. publicConfiguration parse() {
  2. // 若parsed为true，配置文件解析过
  3. if(parsed) {
  4. thrownewBuilderException("Each XMLConfigBuilder can only be used once.");
  5. }
  6. // 标志已解析过
  7.         parsed = true;
  8. // 从根节点 configuration 开始解析
  9.         parseConfiguration(parser.evalNode("/configuration"));
  10. return configuration;
  11. }

解析 /configuration里的配置

  1. privatevoid parseConfiguration(XNode root) {
  2. try{
  3. //issue #117 read properties first
  4.           propertiesElement(root.evalNode("properties"));
  5. Properties settings = settingsAsProperties(root.evalNode("settings"));
  6.           loadCustomVfs(settings);
  7.           typeAliasesElement(root.evalNode("typeAliases"));
  8.           pluginElement(root.evalNode("plugins"));
  9.           objectFactoryElement(root.evalNode("objectFactory"));
  10.           objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
  11.           reflectorFactoryElement(root.evalNode("reflectorFactory"));
  12.           settingsElement(settings);
  13. // read it after objectFactory and objectWrapperFactory issue #631
  14.           environmentsElement(root.evalNode("environments"));
  15.           databaseIdProviderElement(root.evalNode("databaseIdProvider"));
  16.           typeHandlerElement(root.evalNode("typeHandlers"));
  17.           mapperElement(root.evalNode("mappers"));
  18. } catch(Exception e) {
  19. thrownewBuilderException("Error parsing SQL Mapper Configuration. Cause: "+ e, e);
  20. }
  21. }

从上面源码中，不难看出这里是解析 /configuration中的各个子节点。

properties 节点解析

properties配置方式
  3. "username" value="${jdbc.username}"/>

  7. "xxxConfig.properties">

  11. "file:///D:/xxxConfig.properties">
propertiesElement()方法
  1. privatevoid propertiesElement(XNode context) throwsException{
  2. if(context != null) {
  3. // 获取 propertie 节点，并保存 Properties 中
  4. Properties defaults = context.getChildrenAsProperties();
  5. // 获取 resource 的值
  6. String resource = context.getStringAttribute("resource");
  7. // 获取 url 的值
  8. String url = context.getStringAttribute("url");
  9. if(resource != null&& url != null) {
  10. thrownewBuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
  11. }
  12. if(resource != null) {
  13.             defaults.putAll(Resources.getResourceAsProperties(resource));
  14. } elseif(url != null) {
  15.             defaults.putAll(Resources.getUrlAsProperties(url));
  16. }
  17. Properties vars = configuration.getVariables();
  18. if(vars != null) {
  19.             defaults.putAll(vars);
  20. }
  21. // 将解析的值保存到 XPathParser 中
  22.           parser.setVariables(defaults);
  23. // 将解析的值保存到 Configuration 中
  24.           configuration.setVariables(defaults);
  25. }
  26. }

从上面源码中， resource和 url的配置形式不允许同时存在，否则抛出 BuilderException异常。先解析 propertie的配置值，再解析 resource或 url的值。当 propertie存在与 resource或 url相同的 key时， propertie的配置会被覆盖，应为 Properties实现的原理就是继承的 Hashtable类来实现的。

settings 节点解析

settings配置方式
  2. "cacheEnabled" value="true"/>
  3. ......

设置中各项的意图、默认值(引用来源：w3cschool)

设置参数描述有效值默认值
cacheEnabled该配置影响的所有映射器中配置的缓存的全局开关。true,falsetrue
lazyLoadingEnabled延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。true,falsefalse
aggressiveLazyLoading当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，每种属性将会按需加载。true,false
multipleResultSetsEnabled是否允许单一语句返回多结果集（需要兼容驱动）。true,falsetrue
useColumnLabel使用列标签代替列名。不同的驱动在这方面会有不同的表现， 具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。true,falsetrue
useGeneratedKeys允许 JDBC 支持自动生成主键，需要驱动兼容。如果设置为 true 则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如 Derby）。true,falseFalse
autoMappingBehavior指定 MyBatis 应如何自动映射列到字段或属性。NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。FULL 会自动映射任意复杂的结果集（无论是否嵌套）。NONE, PARTIAL, FULLPARTIAL
defaultExecutorType配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）；BATCH 执行器将重用语句并执行批量更新。SIMPLE REUSE BATCHSIMPLE
defaultStatementTimeout设置超时时间，它决定驱动等待数据库响应的秒数。Any positive integerNot Set (null)
safeRowBoundsEnabled允许在嵌套语句中使用分页（RowBounds）。true,falseFalse
mapUnderscoreToCamelCase是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。true, falseFalse
localCacheScopeMyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。SESSION,STATEMENTSESSION
jdbcTypeForNull当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。JdbcType enumeration. Most common are: NULL, VARCHAR and OTHEROTHER
lazyLoadTriggerMethods指定哪个对象的方法触发一次延迟加载。A method name list separated by commasequals,clone,hashCode,toString
defaultScriptingLanguage指定动态 SQL 生成的默认语言。A type alias or fully qualified class name.org.apache.ibatis.scripting.xmltags.XMLDynamicLanguageDriver
callSettersOnNulls指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。注意基本类型（int、boolean等）是不能设置成 null 的。true,falsefalse
logPrefix指定 MyBatis 增加到日志名称的前缀。Any StringNot set
logImpl指定 MyBatis 所用日志的具体实现，未指定时将自动查找。SLF4J, LOG4J, LOG4J2, JDKLOGGING, COMMONSLOGGING, STDOUTLOGGING, NOLOGGINGNot set
proxyFactory指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。CGLIB JAVASSISTCGLIB
settingsAsProperties()方法
  1. privateProperties settingsAsProperties(XNode context) {
  2. if(context == null) {
  3. returnnewProperties();
  4. }
  5. // 获取setting节点的name和value，并保存至Properties返回
  6. Properties props = context.getChildrenAsProperties();
  7. // Check that all settings are known to the configuration class
  8. // 创建Configuration的MetaClass
  9. MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
  10. // 校验Configuration中是否有setting设置的name值
  11. for(Object key : props.keySet()) {
  12. if(!metaConfig.hasSetter(String.valueOf(key))) {
  13. thrownewBuilderException("The setting "+ key + " is not known.  Make sure you spelled it correctly (case sensitive).");
  14. }
  15. }
  16. return props;
  17. }

这里获取到 setting的值，并返回 Properties对象。然后做配置的 name是否合法。org.apache.ibatis.reflection.MetaClass类是保存着一个利用反射获取到的类信息， metaConfig.hasSetter(String.valueOf(key))是判断 metaConfig对象中是否包含 key属性。

vfsImpl()方法
  1. privatevoid loadCustomVfs(Properties props) throwsClassNotFoundException{
  2. String value = props.getProperty("vfsImpl");
  3. if(value != null) {
  4. String[] clazzes = value.split(",");
  5. for(String clazz : clazzes) {
  6. if(!clazz.isEmpty()) {
  7. @SuppressWarnings("unchecked")
  8. Classextends VFS> vfsImpl = (Classextends VFS>)Resources.classForName(clazz);
  9.               configuration.setVfsImpl(vfsImpl);
  10. }
  11. }
  12. }
  13. }

该方法是解析虚拟文件系统配置，用来加载自定义虚拟文件系统的资源。类保存在 Configuration.vfsImpl中。

settingsElement()方法

这个方法的作用就是将解析的 settings设置到 configuration中

  1. privatevoid settingsElement(Properties props) throwsException{
  2.         configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
  3.         configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
  4.         configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
  5.         configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
  6.         configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
  7.         configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
  8.         configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
  9.         configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
  10.         configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
  11.         configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
  12.         configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
  13.         configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
  14.         configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
  15.         configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
  16.         configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
  17.         configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
  18.         configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
  19.         configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
  20.         configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
  21. @SuppressWarnings("unchecked")
  22. ClassextendsTypeHandler> typeHandler = (ClassextendsTypeHandler>)resolveClass(props.getProperty("defaultEnumTypeHandler"));
  23.         configuration.setDefaultEnumTypeHandler(typeHandler);
  24.         configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
  25.         configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
  26.         configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
  27.         configuration.setLogPrefix(props.getProperty("logPrefix"));
  28. @SuppressWarnings("unchecked")
  29. ClassextendsLog> logImpl = (ClassextendsLog>)resolveClass(props.getProperty("logImpl"));
  30.         configuration.setLogImpl(logImpl);
  31.         configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
  32. }

typeAliases 节点解析

typeAliases配置方式
  2. <package name="com.ytao.main.model"/>
  3. // 或
  4. "com.ytao.main.model.Student" alias="student"/>
  5. "com.ytao.main.model.Person"/>

该节点是配置类和别名的关系

  1. package节点是配置整个包下的类

  2. typeAlias节点是指定配置单个类， type为必填值且为类全限定名， alias为选填。配置后，是该类时，可直接使用别名。

typeAliasesElement()方法
  1. privatevoid typeAliasesElement(XNode parent) {
  2. if(parent != null) {
  3. for(XNode child : parent.getChildren()) {
  4. if("package".equals(child.getName())) {
  5. // 以 package 方式配置
  6. String typeAliasPackage = child.getStringAttribute("name");
  7.               configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
  8. } else{
  9. // 以 alias 方式配置
  10. String alias = child.getStringAttribute("alias");
  11. String type = child.getStringAttribute("type");
  12. try{
  13. Class clazz = Resources.classForName(type);
  14. if(alias == null) {
  15.                   typeAliasRegistry.registerAlias(clazz);
  16. } else{
  17.                   typeAliasRegistry.registerAlias(alias, clazz);
  18. }
  19. } catch(ClassNotFoundException e) {
  20. thrownewBuilderException("Error registering typeAlias for '"+ alias + "'. Cause: "+ e, e);
  21. }
  22. }
  23. }
  24. }
  25. }
使用 package 配置

当扫描 package时，获取到包名后 TypeAliasRegistry.registerAliases(typeAliasPackage)

  1. publicvoid registerAliases(String packageName){
  2.         registerAliases(packageName, Object.class);
  3. }

  5. publicvoid registerAliases(String packageName, Class superType){
  6. ResolverUtil<Class> resolverUtil = newResolverUtil<Class>();
  7. // 获取 package 下所有已 .class 结尾的文件
  8.         resolverUtil.find(newResolverUtil.IsA(superType), packageName);
  9. // 获取扫描出来的类
  10. Set<ClassextendsClass>> typeSet = resolverUtil.getClasses();
  11. for(Class type : typeSet){
  12. // Ignore inner classes and interfaces (including package-info.java)
  13. // Skip also inner classes. See issue #6
  14. // 过滤类
  15. if(!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
  16.             registerAlias(type);
  17. }
  18. }
  19. }

扫描到指定 package下所有以 .class结尾文件的类，并保存至Set集合中，然后遍历集合，过滤掉没有名称，接口，和底层特定类。最后 TypeAliasRegistry.registerAlias(Classtype)注册到别名注册器中。

  1. publicvoid registerAlias(Class type) {
  2. // 使用类的 simpleName 作为别名，也就是默认的别名命名规则
  3. String alias = type.getSimpleName();
  4. Alias aliasAnnotation = type.getAnnotation(Alias.class);
  5. if(aliasAnnotation != null) {
  6.           alias = aliasAnnotation.value();
  7. } 
  8. // 上面分析的最终注册的方法
  9.         registerAlias(alias, type);
  10. }

通过类注册到注册器中时，如果该注册类有使用 @Alias（ org.apache.ibatis.type.Alias）注解，那么XML配置中配置的别名会被注解配置覆盖。

使用 typeAlias 配置

如果 typeAlias的 alias有设置值，使用自定名称方式注册，否则使用默认方式注册，即类的simpleName作为别名。

plugins 节点解析

plugins配置方式
  2. // 配置自定义插件，可指定在某个点进行拦截
  3. "com.ytao.main.plugin.DemoInterceptor">
  4. // 当前插件属性
  5. "name" value="100"/>

自定义插件需要实现 org.apache.ibatis.plugin.Interceptor接口,同时在注解上指定拦截的方法。

pluginElement()方法
  1. privatevoid pluginElement(XNode parent) throwsException{
  2. if(parent != null) {
  3. for(XNode child : parent.getChildren()) {
  4. // 获取自定插件的类名
  5. String interceptor = child.getStringAttribute("interceptor");
  6. // 获取插件属性
  7. Properties properties = child.getChildrenAsProperties();
  8. // 实例化 Interceptor
  9. Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
  10. // 设置插件属性到插件中
  11.             interceptorInstance.setProperties(properties);
  12. // 将插件保存在 configuration 中
  13.             configuration.addInterceptor(interceptorInstance);
  14. }
  15. }
  16. }

这里取 节点的 interceptor可以使用别名设置。从源码中 resolveClass方法

  1. //
  2. protectedClass resolveClass(String alias) {
  3. if(alias == null) {
  4. returnnull;
  5. }
  6. try{
  7. return resolveAlias(alias);
  8. } catch(Exception e) {
  9. thrownewBuilderException("Error resolving class. Cause: "+ e, e);
  10. }
  11. }

  13. //
  14. protectedClass resolveAlias(String alias) {
  15. return typeAliasRegistry.resolveAlias(alias);
  16. }

  18. //
  19. public Class resolveAlias(String string) {
  20. try{
  21. if(string == null) {
  22. returnnull;
  23. }
  24. // issue #748
  25. // 将传入的 类 名称统一转换
  26. String key = string.toLowerCase(Locale.ENGLISH);
  27. Class value;
  28. // 验证别名中是否有当前传入的key
  29. if(TYPE_ALIASES.containsKey(key)) {
  30.             value = (Class) TYPE_ALIASES.get(key);
  31. } else{
  32.             value = (Class) Resources.classForName(string);
  33. }
  34. return value;
  35. } catch(ClassNotFoundException e) {
  36. thrownewTypeException("Could not resolve type alias '"+ string + "'.  Cause: "+ e, e);
  37. }
  38. }

以上源码为别名解析过程，其他别名的解析也是调用此方法，先去保存的别名中去找，是否有别名，如果没有就通过 Resources.classForName生成实例。

objectFactory，objectWrapperFactory，reflectorFactory 节点解析

以上都是对实现类都是对MyBatis进行扩展。解析方法也类似，最后都是保存在 configuration。

  1. // objectFactory 解析
  2. privatevoid objectFactoryElement(XNode context) throwsException{
  3. if(context != null) {
  4. String type = context.getStringAttribute("type");
  5. Properties properties = context.getChildrenAsProperties();
  6. ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
  7.           factory.setProperties(properties);
  8.           configuration.setObjectFactory(factory);
  9. }
  10. }

  12. // objectWrapperFactory 解析
  13. privatevoid objectWrapperFactoryElement(XNode context) throwsException{
  14. if(context != null) {
  15. String type = context.getStringAttribute("type");
  16. ObjectWrapperFactory factory = (ObjectWrapperFactory) resolveClass(type).newInstance();
  17.           configuration.setObjectWrapperFactory(factory);
  18. }
  19. }

  21. // reflectorFactory 解析
  22. privatevoid reflectorFactoryElement(XNode context) throwsException{
  23. if(context != null) {
  24. String type = context.getStringAttribute("type");
  25. ReflectorFactory factory = (ReflectorFactory) resolveClass(type).newInstance();
  26.            configuration.setReflectorFactory(factory);
  27. }
  28. }

以上为解析 objectFactory，objectWrapperFactory，reflectorFactory源码，经过前面的分析后，这里比较容易看懂。

environments 节点解析

environments配置方式
  1. default="development">
  2. "development">
  4. "JDBC">
  5. "prop" value="100"/>
  8. "UNPOOLED">
  10. "driver" value="com.mysql.jdbc.Driver"/>
  12. "url" value="${jdbc.url}"/>
  14. "username" value="${jdbc.username}"/>
  16. "password" value="${jdbc.password}"/>
  20. ......

该节点可设置多个环境，针对不同的环境单独配置。environments的属性 default是默认环境，该值对应一个 environment的属性 id的值。

  • transactionManager为事务管理，属性 type为事务管理类型，上面的介绍的 newConfiguration()有定义类型有：JDBC 和 MANAGED事务管理类型。

  • dataSource是数据源， type为数据源类型，与 transactionManager同理，可知内建的数据源类型有：JNDI，POOLED，UNPOOLED数据源类型。

environmentsElement()方法
  1. privatevoid environmentsElement(XNode context) throwsException{
  2. if(context != null) {
  3. if(environment == null) {
  4.             environment = context.getStringAttribute("default");
  5. }
  6. for(XNode child : context.getChildren()) {
  7. String id = child.getStringAttribute("id");
  8. // 验证 id
  9. if(isSpecifiedEnvironment(id)) {
  10. // 解析 transactionManager， 并实例化 TransactionFactory
  11. TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
  12. // 解析 dataSource，并实例化 DataSourceFactory
  13. DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
  14. // 获取 dataSource
  15. DataSource dataSource = dsFactory.getDataSource();
  16. Environment.Builder environmentBuilder = newEnvironment.Builder(id)
  17. .transactionFactory(txFactory)
  18. .dataSource(dataSource);
  19.               configuration.setEnvironment(environmentBuilder.build());
  20. }
  21. }
  22. }
  23. }

  25. privateboolean isSpecifiedEnvironment(String id) {
  26. if(environment == null) {
  27. thrownewBuilderException("No environment specified.");
  28. } elseif(id == null) {
  29. thrownewBuilderException("Environment requires an id attribute.");
  30. } elseif(environment.equals(id)) {
  31. returntrue;
  32. }
  33. returnfalse;
  34. }

若没有配置 environment环境或环境没有给 id属性，则会抛出异常，若当前 id是要使用的就返回 true，否则返回 false。TransactionFactory实例化过程比较简单，与创建 DataSourceFactory类似。

数据源的获取

获取数据源，首先得创建 DataSourceFactory,上面使用 DataSourceFactorydsFactory=dataSourceElement(child.evalNode("dataSource"))创建

  1. privateDataSourceFactory dataSourceElement(XNode context) throwsException{
  2. if(context != null) {
  3. String type = context.getStringAttribute("type");
  4. Properties props = context.getChildrenAsProperties();
  5. DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
  6.           factory.setProperties(props);
  7. return factory;
  8. }
  9. thrownewBuilderException("Environment declaration requires a DataSourceFactory.");
  10. }

这里就是获取到数据源得 type后，利用上面所讲到得 resolveClass()方法获取到 DataSourceFactory。以 UNPOOLED为例，对应的 DataSourceFactory实现类为 UnpooledDataSourceFactory。实例化过程中就给该类的属性 dataSource数据源赋值了

  1. /**
  2.      * UnpooledDataSourceFactory 类
  3.      */
  4. protectedDataSource dataSource;

  6. publicUnpooledDataSourceFactory() {
  7. this.dataSource = newUnpooledDataSource();
  8. }

  10. @Override
  11. publicDataSource getDataSource() {
  12. return dataSource;
  13. }

UnpooledDataSource类里面有静态代码块所以数据源被加载

  1. /**
  2.      * UnpooledDataSource 类
  3.      */
  4. static{
  5. Enumeration<Driver> drivers = DriverManager.getDrivers();
  6. while(drivers.hasMoreElements()) {
  7. Driver driver = drivers.nextElement();
  8.           registeredDrivers.put(driver.getClass().getName(), driver);
  9. }
  10. }

databaseIdProvider 节点解析

databaseIdProvider配置方式
  1. "DB_VENDOR">
  2. "SQL Server" value="sqlserver"/>
  3. "DB2" value="db2"/>
  4. "Oracle" value="oracle"/>
  5. "MySQL" value="mysql"/>

基于映射语句中的 databaseId属性，可以根据不同数据库厂商执行不同的sql。

databaseIdProviderElement()方法
  1. privatevoid databaseIdProviderElement(XNode context) throwsException{
  2. DatabaseIdProvider databaseIdProvider = null;
  3. if(context != null) {
  4. String type = context.getStringAttribute("type");
  5. // 保持向后兼容
  6. if("VENDOR".equals(type)) {
  7.           type = "DB_VENDOR";
  8. }
  9. Properties properties = context.getChildrenAsProperties();
  10.       databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
  11.       databaseIdProvider.setProperties(properties);
  12. }
  13. Environment environment = configuration.getEnvironment();
  14. if(environment != null&& databaseIdProvider != null) {
  15. String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
  16.       configuration.setDatabaseId(databaseId);
  17. }
  18. }

根据匹配的数据库厂商类型匹配数据源 databaseIdProvider.getDatabaseId(environment.getDataSource())

  1. @Override
  2. publicString getDatabaseId(DataSource dataSource) {
  3. if(dataSource == null) {
  4. thrownewNullPointerException("dataSource cannot be null");
  5. }
  6. try{
  7. return getDatabaseName(dataSource);
  8. } catch(Exception e) {
  9.       log.error("Could not get a databaseId from dataSource", e);
  10. }
  11. returnnull;
  12. }

  14. privateString getDatabaseName(DataSource dataSource) throwsSQLException{
  15. // 根据数据源获取数据库产品名称
  16. String productName = getDatabaseProductName(dataSource);
  17. if(this.properties != null) {
  18. for(Map.Entry<Object, Object> property : properties.entrySet()) {
  19. // 判断是否包含，选择使用的数据库产品
  20. if(productName.contains((String) property.getKey())) {
  21. return(String) property.getValue();
  22. }
  23. }
  24. // no match, return null
  25. returnnull;
  26. }
  27. return productName;
  28. }

  30. privateString getDatabaseProductName(DataSource dataSource) throwsSQLException{
  31. Connection con = null;
  32. try{
  33. // 数据库连接
  34.       con = dataSource.getConnection();
  35. // 获取连接元数据
  36. DatabaseMetaData metaData = con.getMetaData();
  37. // 获取数据库产品名称
  38. return metaData.getDatabaseProductName();
  39. } finally{
  40. if(con != null) {
  41. try{
  42.           con.close();
  43. } catch(SQLException e) {
  44. // ignored
  45. }
  46. }
  47. }
  48. }

这里需要注意的是配置：比如使用 mysql,我踩过这里的坑，这里Name为 MySQL,我把 y写成大写，结果匹配不上。另外这里写个 My也能匹配上，应为是使用的 String.contains方法，只要包含就会符合，这里代码应该不够严谨。

typeHandlers 节点解析

typeHandlers配置方式
  2. <package name="com.ytao.main.handler"/>
  3. // 或
  4. "java.util.Date"  jdbcType="TIMESTAMP" handler="com.ytao.main.handler.DemoDateHandler"/>

扫描整个包或者指定类型之间的映射， javaType, jdbcType非必需， handler必填项

typeHandlerElement()方法
  1. privatevoid typeHandlerElement(XNode parent) throwsException{
  2. if(parent != null) {
  3. for(XNode child : parent.getChildren()) {
  4. if("package".equals(child.getName())) {
  5. // 获取包名
  6. String typeHandlerPackage = child.getStringAttribute("name");
  7. // 注册包下所有的类型处理器
  8.           typeHandlerRegistry.register(typeHandlerPackage);
  9. } else{
  10. String javaTypeName = child.getStringAttribute("javaType");
  11. String jdbcTypeName = child.getStringAttribute("jdbcType");
  12. String handlerTypeName = child.getStringAttribute("handler");
  13. Class javaTypeClass = resolveClass(javaTypeName);
  14. JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
  15. Class typeHandlerClass = resolveClass(handlerTypeName);
  16. if(javaTypeClass != null) {
  17. if(jdbcType == null) {
  18.               typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
  19. } else{
  20.               typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
  21. }
  22. } else{
  23.             typeHandlerRegistry.register(typeHandlerClass);
  24. }
  25. }
  26. }
  27. }
  28. }

源码分析会根据包下所有处理器或者指定处理器进行解析，最后会根据上面分析到的 type+handler和 type+jdbc type+handler不同情况注册。另外这里还有个 TypeHandlerRegistry.register(ClasstypeHandlerClass)注册类

  1. publicvoidregister(Class typeHandlerClass) {
  2. // 标志是否从 MappedTypes 注解中获取 javaType 注册
  3. boolean mappedTypeFound = false;
  4. // 获取 MappedTypes 的值
  5. MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
  6. if(mappedTypes != null) {
  7. for(Class javaTypeClass : mappedTypes.value()) {
  8. // 已 type + handler 的方式注册
  9. register(javaTypeClass, typeHandlerClass);
  10. // 标志已通过注解注册类型
  11.         mappedTypeFound = true;
  12. }
  13. }
  14. if(!mappedTypeFound) {
  15. // 通过 TypeHandler 注册
  16. register(getInstance(null, typeHandlerClass));
  17. }
  18. }

  20. // 实例化
  21. public TypeHandler getInstance(Class javaTypeClass, Class typeHandlerClass) {
  22. if(javaTypeClass != null) {
  23. try{
  24. // 获取有参构造函数
  25. Constructor c = typeHandlerClass.getConstructor(Class.class);
  26. // 实例化对象
  27. return(TypeHandler) c.newInstance(javaTypeClass);
  28. } catch(NoSuchMethodException ignored) {
  29. // ignored
  30. } catch(Exception e) {
  31. thrownewTypeException("Failed invoking constructor for handler "+ typeHandlerClass, e);
  32. }
  33. }
  34. try{
  35. // 获取无参构造函数
  36. Constructor c = typeHandlerClass.getConstructor();
  37. return(TypeHandler) c.newInstance();
  38. } catch(Exception e) {
  39. thrownewTypeException("Unable to find a usable constructor for "+ typeHandlerClass, e);
  40. }
  41. }  

  43. // 注册实例
  44. public voidregister(TypeHandler typeHandler) {
  45. boolean mappedTypeFound = false;
  46. MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
  47. if(mappedTypes != null) {
  48. for(Class handledType : mappedTypes.value()) {
  49. register(handledType, typeHandler);
  50.         mappedTypeFound = true;
  51. }
  52. }
  53. // @since 3.1.0 - try to auto-discover the mapped type
  54. if(!mappedTypeFound && typeHandler instanceofTypeReference) {
  55. try{
  56. TypeReference typeReference = (TypeReference) typeHandler;
  57. register(typeReference.getRawType(), typeHandler);
  58.         mappedTypeFound = true;
  59. } catch(Throwable t) {
  60. // maybe users define the TypeReference with a different type and are not assignable, so just ignore it
  61. }
  62. }
  63. if(!mappedTypeFound) {
  64. register((Class) null, typeHandler);
  65. }
  66. }

以上的 register方法中，了解 type+jdbc type+handler后，其他的 register重载方法比较容易理解，其他的都是基于它上面的封装。

mappers 节点解析

mappers配置方式
  2. <package name="com.ytao.main.mapper"/>
  3. // 或
  4. "mapper/studentMapper.xml"/>
  5. // 或
  6. "file:///D:/mybatis-3-mybatis-3.4.6/src/main/resources/mapper/studentMapper.xml"/>
  7. // 或
  8. class="com.ytao.main.mapper.StudentMapper"/>

可通过以上四种形式配置 mappers节点, 和 为互斥节点。

mapperElement()方法

该方法是负责解析 节点

  1. privatevoid mapperElement(XNode parent) throwsException{
  2. if(parent != null) {
  3. for(XNode child : parent.getChildren()) {
  4. // 如果配置 package 节点，则扫描
  5. if("package".equals(child.getName())) {
  6. String mapperPackage = child.getStringAttribute("name");
  7. // 解析包下类Mapper接口，并注册到configuration的mapperRegistry中
  8.           configuration.addMappers(mapperPackage);
  9. } else{
  10. // 获取mapper节点的resource,url,class属性
  11. String resource = child.getStringAttribute("resource");
  12. String url = child.getStringAttribute("url");
  13. String mapperClass = child.getStringAttribute("class");
  14. // 根据resource解析，并且url，class值必须为空，也就不能配置值。url，class同理，其它两个属性也不能配置值
  15. if(resource != null&& url == null&& mapperClass == null) {
  16. ErrorContext.instance().resource(resource);
  17. // 通过resource获取流
  18. InputStream inputStream = Resources.getResourceAsStream(resource);
  19. // 创建XMLMapperBuilder对象
  20. XMLMapperBuilder mapperParser = newXMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
  21. // 解析映射配置文件
  22.             mapperParser.parse();
  23. } elseif(resource == null&& url != null&& mapperClass == null) {
  24. ErrorContext.instance().resource(url);
  25. // 通过url获取流
  26. InputStream inputStream = Resources.getUrlAsStream(url);
  27. // 和resource解析方式一样，创建XMLMapperBuilder对象，然后解析映射配置文件
  28. XMLMapperBuilder mapperParser = newXMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
  29.             mapperParser.parse();
  30. } elseif(resource == null&& url == null&& mapperClass != null) {
  31. // 加载class属性的接口
  32. Class mapperInterface = Resources.classForName(mapperClass);
  33. // 将接口注册到configuration的mapperRegistry中
  34.             configuration.addMapper(mapperInterface);
  35. } else{
  36. thrownewBuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
  37. }
  38. }
  39. }
  40. }
  41. }

的包扫描到的类，然后单个单个注册到configuration的mapperRegistry中，这里和 使用 class属性是一样逻辑。解析 package方式

  1. // Configuration 中定义了
  2. protectedfinalMapperRegistry mapperRegistry = newMapperRegistry(this);

  4. /**
  5.    * 步骤一
  6.    * 该函数于 Configuration 中
  7.    */
  8. publicvoid addMappers(String packageName) {
  9. // mapperRegistry定义在Configuration中的一个属性
  10.     mapperRegistry.addMappers(packageName);
  11. }

  13. /**
  14.    * 步骤二
  15.    * 该函数于 MapperRegistry 中
  16.    */
  17. publicvoid addMappers(String packageName) {
  18.     addMappers(packageName, Object.class);
  19. }

  21. /**
  22.    * 步骤三
  23.    * 该函数于 MapperRegistry 中
  24.    */
  25. publicvoid addMappers(String packageName, Class superType) {
  26. // 通过 ResolverUtil 获取包下的类
  27. ResolverUtil<Class> resolverUtil = newResolverUtil<Class>();
  28.     resolverUtil.find(newResolverUtil.IsA(superType), packageName);
  29. Set<ClassextendsClass>> mapperSet = resolverUtil.getClasses();
  30. for(Class mapperClass : mapperSet) {
  31. // 遍历获取到的类，注册到 MapperRegistry
  32.       addMapper(mapperClass);
  33. }
  34. }   

  36. /**
  37.    * 步骤四
  38.    * 该函数于 MapperRegistry 中
  39.    */
  40. public void addMapper(Class type) {
  41. // mapper 类为 interface 接口
  42. if(type.isInterface()) {
  43. // 判断当前class是否已经注册过
  44. if(hasMapper(type)) {
  45. thrownewBindingException("Type "+ type + " is already known to the MapperRegistry.");
  46. }
  47. // 校验是否加载完成
  48. boolean loadCompleted = false;
  49. try{
  50. // 保存 mapper 接口和 MapperProxyFactory 之间的映射
  51.         knownMappers.put(type, newMapperProxyFactory(type));
  52. // It's important that the type is added before the parser is run
  53. // otherwise the binding may automatically be attempted by the
  54. // mapper parser. If the type is already known, it won't try.
  55. // 解析xml和注解
  56. MapperAnnotationBuilder parser = newMapperAnnotationBuilder(config, type);
  57.         parser.parse();
  58. // 标志加载完成
  59.         loadCompleted = true;
  60. } finally{
  61. if(!loadCompleted) {
  62.           knownMappers.remove(type);
  63. }
  64. }
  65. }
  66. }

解析 mapper的 class属性

  1. // 该函数于 Configuration 中
  2. public void addMapper(Class type) {
  3.     mapperRegistry.addMapper(type);
  4. }

  6. // ... 这里调用上面的【步骤四】

这两中方式是直接注册接口到 mapperRegistry,另外两种是解析 xml的方式就是获取映射文件的 namespace，再注册进来, XMLMapperBuilder是负责解析映射配置文件的类，今后会单独详细分析这个类，这里不展开讲。

这里对XMLConfigBuilder解析配置文件到此分析完，本文对配置文件解析的流程大致了解流程和原理。相信遇到配置问题异常，大致能排查到根本原因

程序员专栏
 扫码关注填加客服 
长按识别下方二维码进群

近期精彩内容推荐：  

 再见，戴威！再见，小黄车！

 别瞎学了，这几门语言要被淘汰了！

 再见 Win10！下一代操作系统来了。。

 墙裂建议收藏，100道Python练手题目




在看点这里好文分享给更多人↓↓

浏览 9
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
Mybatis源码之映射器解析
java宝典
0
myconfconf 配置文件解析库
myconf是一个可以方便读取key-value配置的C/C++库。1 规则如下 1)、配置为 ke
myconfconf 配置文件解析库
myconf是一个可以方便读取key-value配置的C/C++库。1规则如下 1)、配置为key:value格式 2)、可以支持读取int(正负数),unsigendint,char*,支持默认缺省
C++ ConfiguratorC++配置文件解析
Configurator是一个用来解析各种配置文件的C++库，支持嵌套的section，可定义默认值等各种高级配置功能。
nginx-java-parser解析nginx配置文件
解析 nginx 配置文件，并将 nginx 配置文件格式化成对象，方便 java 程序管理 ngi
nginx-java-parser解析nginx配置文件
解析nginx配置文件，并将nginx配置文件格式化成对象，方便java程序管理nginx配置。解析配置文件并非使用正则匹配，而是使用语法分析树处理解决的。特性：使用ANTLR4解析功能将配置文件转换
C++ ConfiguratorC++配置文件解析
Configurator 是一个用来解析各种配置文件的 C++ 库，支持嵌套的 section ，可
Mybatis数据源结构解析
java宝典
0
Springboot启动原理解析
Java引导者
0
Python之读取配置文件
Python爬虫与算法
0
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报