mybatis源码剖析之配置文件解析

我们在使用 MyBatis 框架时，通常会进行一定的设置，使其能更好的满足我们的需求。对于一个框架来说，提供较为丰富的配置文件，也是其灵活性的体 现。本文将会介绍 MyBatis 配置文件中的大部分节点解析过程。

我们在使用 MyBatis 时，第一步要做的事情一般是根据配置文件构建 SqlSessionFactory 对象。相关代码大致如下:

 SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
 SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));

在上面代码中，我们首先会使用 MyBatis 提供的工具类 Resources 加载配置文件，得到 一个输入流。然后再通过 SqlSessionFactoryBuilder 对象的 build 方法构建 SqlSessionFactory 对象。这里的 build 方法是我们分析配置文件解析过程的入口方法。下面我们来看一下这个：

public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
  }

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

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

从上面的代码中，我们大致可以猜出 MyBatis 配置文件是通过 XMLConfigBuilder 进行解析的。不过目前这里还没有非常明确的解析逻辑，所以我们继续往下看。这次来看一下 XMLConfigBuilder 的 parse 方法，如下: 

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

到这里大家可以看到一些端倪了，注意一个 xpath 表达式—— /configuration。这个表达式代表的是 MyBatis 配置文件的 <configuration> 节点，这里通过 xpath 选中这个节点，并传递给 parseConfiguration 方法。我们继续跟下去。 

private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      //解析properties结点
      propertiesElement(root.evalNode("properties"));
      //解析 settings 配置，并将其转换为 Properties 对象
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      //加载vfs
      loadCustomVfs(settings);
      //解析typeAliases结点
      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);
    }
  }

解析properties结点：

<properties resource="jdbc.properties"/>

private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
      //获取子节点，并转换为properties对象
      Properties defaults = context.getChildrenAsProperties();
      //获取resource和url的属性值
      String resource = context.getStringAttribute("resource");
      String url = context.getStringAttribute("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.setVariables(defaults);
      //放到configuration里
      configuration.setVariables(defaults);
    }
  }

public Properties getChildrenAsProperties() {
    Properties properties = new Properties();
    for (XNode child : getChildren()) {
      String name = child.getStringAttribute("name");
      String value = child.getStringAttribute("value");
      if (name != null && value != null) {
        properties.setProperty(name, value);
      }
    }
    return properties;
  }

public List<XNode> getChildren() {
    List<XNode> children = new ArrayList<XNode>();
    NodeList nodeList = node.getChildNodes();
    if (nodeList != null) {
      for (int i = 0, n = nodeList.getLength(); i < n; i++) {
        Node node = nodeList.item(i);
        if (node.getNodeType() == Node.ELEMENT_NODE) {
          children.add(new XNode(xpathParser, node, variables));
        }
      }
    }
    return children;
  }

上面就是<properties>节点解析过程，不是很复杂。主要包含三个步骤，一是解析 <properties>节点的子节点，并将解析结果设置到 Properties 对象中。二是从文件系统或通过 网络读取属性配置，这取决于<properties>节点的 resource 和 url 是否为空。第二步对应的代码比较简单，这里就不分析了。最后一步则是将包含属性信息的 Properties 对象设置到 XPathParser 和 Configuration 中。

需要注意的是，propertiesElement 方法是先解析<properties>节点的子节点内容，然后再从文件系统或者网络读取属性配置，并将所有的属性及属性值都放入到 defaults 属性对象中。这会导致同名属性覆盖的问题，也就是从文件系统，或者网络上读取到的属性和属性值会覆盖掉<properties>子节点中同名的属性和及值。

解析settings结点：

private Properties settingsAsProperties(XNode context) {
    if (context == null) {
      return new 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;
  }

1. 解析 settings 子节点的内容，并将解析结果转成 Properties 对象

2. 为Configuration 创建元信息对象

3. 通过 MetaClass 检测 Configuration 中是否存在某个属性的 setter 方法，

   不存在则抛异常

4. 若通过 MetaClass 的检测，则返回 Properties 对象，方法逻辑结束

 MetaClass对象创建过程：

元信息类 MetaClass的构造方法为私有类型，所以不能直接创建，必须使用其提供的 forClass 方法进行创建。它的创建逻辑如下:

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

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

上面代码出现了两个新的类 ReflectorFactory 和 Reflector，MetaClass 通过引入这些新类帮助它完成功能。下面我们看一下 hasSetter 方法的源码就知道是怎么回事了。

public boolean hasSetter(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      if (reflector.hasSetter(prop.getName())) {
        MetaClass metaProp = metaClassForProperty(prop.getName());
        return metaProp.hasSetter(prop.getChildren());
      } else {
        return false;
      }
    } else {
      return reflector.hasSetter(prop.getName());
    }
  }

从上面的代码中，我们可以看出 MetaClass 中的 hasSetter 方法最终调用了 Reflector 的 hasSetter 方法。

DefaultReflectorFactory

DefaultReflectorFactory 用于创建 Reflector，同时兼有缓存的功能，它的源码如下:

public class DefaultReflectorFactory implements ReflectorFactory {
  private boolean classCacheEnabled = true;
  private final ConcurrentMap<Class<?>, Reflector> reflectorMap = new ConcurrentHashMap<Class<?>, Reflector>();

  @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 {
      return new Reflector(type);
    }
  }

}

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>();
// 解析目标类的默认构造方法，并赋值给 defaultConstructor 变量 
public Reflector(Class<?> clazz) { 
type = clazz;
addDefaultConstructor(clazz);
// 解析 getter 方法，并将解析结果放入 getMethods 中 
addGetMethods(clazz);
// 解析 setter 方法，并将解析结果放入 setMethods 中 
addSetMethods(clazz);
// 解析属性字段，并将解析结果添加到 setMethods 或 getMethods 中 
addFields(clazz);
// 从 getMethods 映射中获取可读属性名数组 
readablePropertyNames = getMethods.keySet()
.toArray(new String[getMethods.keySet().size()]); 
// 从 setMethods 映射中获取可写属性名数组 
writeablePropertyNames = setMethods.keySet()
.toArray(new String[setMethods.keySet().size()]);
// 将所有属性名的大写形式作为键，属性名作为值，
// 存入到 caseInsensitivePropertyMap 中
for (String propName : readablePropertyNames) {
caseInsensitivePropertyMap .put(propName.toUpperCase(Locale.ENGLISH), propName);
}
for (String propName : writeablePropertyNames) {
caseInsensitivePropertyMap.put(propName .toUpperCase(Locale.ENGLISH), propName);
} 
}

getter 方法解析的逻辑被封装在了 addGetMethods 方法中，这个方法除了会解析形如 getXXX 的方法，同时也会解析 isXXX 方法。该方法的源码分析如下:

private void addGetMethods(Class<?> cls) {
    Map<String, List<Method>> conflictingGetters = new HashMap<String, List<Method>>();
    Method[] methods = getClassMethods(cls);
    for (Method method : methods) {
      // getter 方法不应该有参数，若存在参数，则忽略当前方法
      if (method.getParameterTypes().length > 0) {
        continue;
      }
      String name = method.getName();
       // 过滤出以 get 或 is 开头的方法
      if ((name.startsWith("get") && name.length() > 3)
          || (name.startsWith("is") && name.length() > 2)) {
        // 将 getXXX 或 isXXX 等方法名转成相应的属性，比如 getName -> name
        name = PropertyNamer.methodToProperty(name);
  /*
   * 将冲突的方法添加到 conflictingGetters 中。考虑这样一种情况: *
   * getTitle 和 isTitle 两个方法经过 methodToProperty 处理，
   * 均得到 name = title，这会导致冲突。 *
   * 对于冲突的方法，这里先统一起存起来，后续再解决冲突 
   */
        addMethodConflict(conflictingGetters, name, method);
      }
    }
    //解决冲突
    resolveGetterConflicts(conflictingGetters);
  }

 addMethodConflict(conflictingGetters, name, method）方法源码：

 private void addMethodConflict(Map<String, List<Method>> conflictingMethods, String name, Method method) {
    List<Method> list = conflictingMethods.get(name);
    if (list == null) {
      list = new ArrayList<Method>();
      conflictingMethods.put(name, list);
    }
    list.add(method);
  }

解决冲突： 

private void resolveGetterConflicts(Map<String, List<Method>> conflictingGetters) {
    for (Entry<String, List<Method>> entry : conflictingGetters.entrySet()) {
      Method winner = null;
      String propName = entry.getKey();
      for (Method candidate : entry.getValue()) {
        if (winner == null) {
          winner = candidate;
          continue;
        }
        Class<?> winnerType = winner.getReturnType();
        Class<?> candidateType = candidate.getReturnType();
          
      /*
       * 两个方法的返回值类型一致，若两个方法返回值类型均为 boolean，
       * 则选取 isXXX 方法为 winner。否则无法决定哪个方法更为合适
       * 只能抛出异常
       */
        if (candidateType.equals(winnerType)) {
          if (!boolean.class.equals(candidateType)) {
            throw new ReflectionException(
                "Illegal overloaded getter method with ambiguous type for property "
                    + propName + " in class " + winner.getDeclaringClass()
                    + ". This breaks the JavaBeans specification and can cause unpredictable results.");
          } else if (candidate.getName().startsWith("is")) {
            winner = candidate;
          }
        } else if (candidateType.isAssignableFrom(winnerType)) {
          // OK getter type is descendant
        } 
          /*
           * candidateType 是 winnerType 的子类，此时认为 candidate 方法
           * 更为合适，故将winner 更新为 candidate
           */
         else if (winnerType.isAssignableFrom(candidateType)) {
          winner = candidate;
        } else {
          throw new ReflectionException(
              "Illegal overloaded getter method with ambiguous type for property "
                  + propName + " in class " + winner.getDeclaringClass()
                  + ". This breaks the JavaBeans specification and can cause unpredictable results.");
        }
      }
      // 将筛选出的方法添加到 getMethods 中，并将方法返回值添加到 getTypes 中
      addGetMethod(propName, winner);
    }
  }

private void addGetMethod(String name, Method method) { 
if (isValidPropertyName(name)) {
getMethods.put(name, new MethodInvoker(method)); 
// 解析返回值类型
Type returnType = TypeParameterResolver.resolveReturnType(method, type);
// 将返回值类型由 Type 转为 Class，并将转换后的结果缓存到 setTypes 中 
getTypes.put(name, typeToClass(returnType));
}