Mybatis技术内幕：基础支持层——资源加载

MyBatis基础支持层位于 Mybatis 整体架构的最底层，支撑着 Mybatis 的核心处理层，是整个框架的基石。基础支持层中封装了多个较为通用的、独立的模块，不仅仅为 Mybatis 提供基础支撑，也可以在合适的场景中直接复用。

整体架构

这篇文章介绍MyBatis的资源加载模块

类加载器

Java虚拟机中的类加载器(ClassLoader)负责加载来自文件系统、网络或其他来源的类文件。Java虚拟机中的类加载器默认使用的是双亲委派模式，如图所示，其中有三种默认使用的类加载器，分别是 Bootstrap ClassLoader、Extension ClassLoader 和 System ClassLoader (也被称为 ApplicationClassLoader)，每种类加载器都己经确定从哪个位置加载类文件。

BootstrapClassLoader负责加载 JDK自带的rt.jar包中的类文件，它是所有类加载器的父加载器，Bootstrap ClassLoader没有任何父类加载器。Extension ClassLoader负责加载 Java的扩展类库，也就是从 jre/lib/ext目录下或者java.ext.dirs系统属性指定的目录下加载类。

SystemClassLoader负责从 classpath环境变量中加载类文件，classpath环境变量通常由-classpath或 -cp命令行选项来定义，或是由 JAR中 Manifest文件的 classpath属性指定。System ClassLoader是ExtensionClassLoader的子加载器。

根据双亲委派模式，在加载类文件时，子加载器首先会将加载请求委托给它的父加载器。

父加载器会检测自己是否已经加载过该类，如果己加载则加载过程结束;如果未加载则请求继续向上传递，直到BootstrapClassLoader。

如果在请求向上委托的过程中，始终未检测到该类己加载，则从 BootstrapClassLoader开始尝试从其对应路径中加载该类文件，如果加载失败则由子加载器继续尝试加载，直至发起加载请求的子加载器位为止。

双亲委派模式可以保证两点:

一是子加载器可以使用父加载器己加载的类，而父加载器无法使用子加载器已加载的类 ;

二是父加载器已加载过的类无法被子加载器再次加载。

这样就可以保证 JVM的安全性和稳定性。

ClassLoaderWrapper

上上一小节中了解了类加载器的常见使用方式。在 MyBatis的 IO 包中封装了 ClassLoader以及读取资源文件的相关 API。

在 IO包中提供的 ClassLoaderWrapper是一个 ClassLoader的包装器，其中包含了多个ClassLoader对象。

通过调整多个类加载器的使用顺序，ClassLoaderWrapper可以确保返回给系统使用的是正确的类加载器。

使用 ClassLoaderWrapper就如同使用一个 ClassLoader对象， ClassLoaderWrapper会按照指定的顺序依次检测其中封装的ClassLoader对象，并从中选取第一个可用的ClassLoader完成相关功能。

ClassLoaderWrapper的主要功能可以分为三类，分别是 getResourceAsURL()方法 、 classForName()方法、getResourceAsStream()方法，这三个方法都有多个重载，这三类方法最终都会调用参数为 String和ClassLoader[]的重载。

getResourceAsURL()代码如下，其他的类似：

public URL getResourceAsURL(String resource, ClassLoader classLoader) {
  return getResourceAsURL(resource, getClassLoaders(classLoader));
}

// 返回ClassLoader[], 该方法指明类加载器的使用顺序
ClassLoader[] getClassLoaders(ClassLoader classLoader) {
  return new ClassLoader[]{
    classLoader,
    defaultClassLoader,
    Thread.currentThread().getContextClassLoader(),
    getClass().getClassLoader(),
    systemClassLoader};
}

URL getResourceAsURL(String resource, ClassLoader[] classLoader) {

  URL url;

  for (ClassLoader cl : classLoader) {

    if (null != cl) {

      // look for the resource as passed in...
      url = cl.getResource(resource);

      // ...but some class loaders want this leading "/", so we'll add it
      // and try again if we didn't find the resource
      if (null == url) {
        url = cl.getResource("/" + resource);
      }

      // "It's always in the last place I look for it!"
      // ... because only an idiot would keep looking for it after finding it, so stop looking already.
      if (null != url) {
        return url;
      }

    }

  }

  // didn't find it anywhere.
  return null;

}

Resources是一个提供了多个静态方法的工具类，其中封装了一个 ClassLoaderWrapper类型的静态字段，Resources提供的这些静态工具都是通过调用该 ClassLoaderWrapper对象的相应方法实现的。

ResolverUtil

ResolverUtil可以根据指定的条件查找指定包下的类，其中使用的条件由Test接口表示。

ResolverUtil中使用classLoader字段 (ClassLoader类型)记录了当前使用的类加载器，默认情况下，使用的是当前线程上下文绑定的ClassLoader，我们可以通过 setClassLoader()方法修改使用类加载器。

MyBatis提供了两个常用的Test接口实现，分别是IsA和AnnotatedWith,如图所示。 IsA用于检测类是否继承了指定的类或接口，AnnotatedWith用于检测类是否添加了指定的注解。开发人员也可以自己实现 Test接口，实现指定条件的检测。

Test接口中定义了 matches()方法，它用于检测指定类是否符合条件:

public interface Test {
  /**
     * Will be called repeatedly with candidate classes. Must return True if a class
     * is to be included in the results, false otherwise.
     */
  boolean matches(Class<?> type);
}

IsA和 AnnotatedWith的具体实现如下

public static class IsA implements Test {
  private Class<?> parent;

  /** Constructs an IsA test using the supplied Class as the parent class/interface. */
  public IsA(Class<?> parentType) {
    this.parent = parentType;
  }

  /** Returns true if type is assignable to the parent type supplied in the constructor. */
  @Override
  public boolean matches(Class<?> type) {
    return type != null && parent.isAssignableFrom(type);
  }

  @Override
  public String toString() {
    return "is assignable to " + parent.getSimpleName();
  }
}

public static class AnnotatedWith implements Test {
  private Class<? extends Annotation> annotation;

  /** Constructs an AnnotatedWith test for the specified annotation type. */
  public AnnotatedWith(Class<? extends Annotation> annotation) {
    this.annotation = annotation;
  }

  /** Returns true if the type is annotated with the class provided to the constructor. */
  @Override
  public boolean matches(Class<?> type) {
    return type != null && type.isAnnotationPresent(annotation);
  }

  @Override
  public String toString() {
    return "annotated with @" + annotation.getSimpleName();
  }
}

默认情况下，使用Thread.currentThread().getContextClassLoader()这个类加载器加载符合条件的类，我们可以在调用find()方法之前，调用 setClassLoader(ClassLoader)设置需要使用的 ClassLoader，这个 ClassLoader可以从 ClassLoaderWrapper中获取合适的类加载器。

ResolverUtil的使用案例：

ResolverUtil<ActionBean> resolver = new ResolverUtil<ActionBean>();
// 在pkg1和pkg2这个包下查找实现了ActionBean这个接口的类
resolver.findImplementation(ActionBean.class,  pkg1, pkg2);
// 在pkg1包下查找符合CustomerTest条件的类
resolver.find(new CustomTest(), pkg1);
// 在pkg2包下查找符合CustomerTest条件的类
resolver.find(new CustomTest(), pkg2);
// 获取上面三次查找的结果
Collection<ActionBean> beans = resolver.getClasses();

ResolverUtil.findImplementations()方法和ResolverUtil.findAnnotated()方法都是依赖RescolverUtil.find()方法实现的，findImplementations()方法会创建IsA对象作为检测条件，findAnnotated()方法会创建AnnotatedWith对象作为检测条件。

public ResolverUtil<T> find(Test test, String packageName) {
  String path = getPackagePath(packageName);

  try {
    List<String> children = VFS.getInstance().list(path);
    for (String child : children) {
      if (child.endsWith(".class")) {
        addIfMatching(test, child);
      }
    }
  } catch (IOException ioe) {
    log.error("Could not read package: " + packageName, ioe);
  }

  return this;
}

protected void addIfMatching(Test test, String fqn) {
  try {
    // fqn是类所在完全限定名，即包括其所在包的包名
    String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
    ClassLoader loader = getClassLoader();
    if (log.isDebugEnabled()) {
      log.debug("...");
    }

    Class<?> type = loader.loadClass(externalName);
    if (test.matches(type)) {
      matches.add((Class<T>) type);
    }
  } catch (Throwable t) {
    log.warn("...");
  }
}