ady/code-learning

Fork 0

io2020 018831037a init: 初始化提交--源码学习笔记

2025-07-21 01:06:10 +08:00

38 KiB

Raw Permalink Blame History

精尽 MyBatis 源码分析 —— IO 模块

1. 概述

本文，我们来分享 MyBatis 的 IO 模块，对应 io 包。如下图所示：![io 包](11-mybatis-IO 模块.assets/01.png)io 包

在《精尽 MyBatis 源码解析 —— 项目结构一览》中，简单介绍了这个模块如下：

资源加载模块，主要是对类加载器进行封装，确定类加载器的使用顺序，并提供了加载类文件以及其他资源文件的功能。

本文涉及的类如下图所示：![类图](11-mybatis-IO 模块.assets/02.png)类图

2. ClassLoaderWrapper

org.apache.ibatis.io.ClassLoaderWrapper ，ClassLoader 包装器。可使用多个 ClassLoader 加载对应的资源，直到有一成功后返回资源。

2.1 构造方法

// ClassLoaderWrapper.java

/**
 * 默认 ClassLoader 对象
 */
ClassLoader defaultClassLoader;
/**
 * 系统 ClassLoader 对象
 */
ClassLoader systemClassLoader;

ClassLoaderWrapper() {
    try {
        systemClassLoader = ClassLoader.getSystemClassLoader();
    } catch (SecurityException ignored) {
        // AccessControlException on Google App Engine
    }
}

defaultClassLoader 属性，默认 ClassLoader 对象。目前不存在初始化该属性的构造方法。可通过 ClassLoaderWrapper.defaultClassLoader = xxx 的方式，进行设置。
systemClassLoader 属性，系统 ClassLoader 对象。在构造方法中，已经初始化。

2.2 getClassLoaders

#getClassLoaders(ClassLoader classLoader) 方法，获得 ClassLoader 数组。代码如下：

// ClassLoaderWrapper.java

ClassLoader[] getClassLoaders(ClassLoader classLoader) {
    return new ClassLoader[]{
            classLoader,
            defaultClassLoader,
            Thread.currentThread().getContextClassLoader(),
            getClass().getClassLoader(),
            systemClassLoader};
}

2.3 getResourceAsURL

#getResourceAsURL(String resource, ...) 方法，获得指定资源的 URL 。代码如下：

// ClassLoaderWrapper.java

/**
 * Get a resource as a URL using the current class path
 *
 * @param resource - the resource to locate
 * @return the resource or null
 */
public URL getResourceAsURL(String resource) {
    return getResourceAsURL(resource, getClassLoaders(null));
}
 
/**
 * Get a resource from the classpath, starting with a specific class loader
 *
 * @param resource    - the resource to find
 * @param classLoader - the first classloader to try
 * @return the stream or null
 */
public URL getResourceAsURL(String resource, ClassLoader classLoader) {
    return getResourceAsURL(resource, getClassLoaders(classLoader));
}

先调用 #getClassLoaders(ClassLoader classLoader) 方法，获得 ClassLoader 数组。

再调用 #getResourceAsURL(String resource, ClassLoader[] classLoader) 方法，获得指定资源的 InputStream 。代码如下：

// ClassLoaderWrapper.java

/**
 * Get a resource as a URL using the current class path
 *
 * @param resource    - the resource to locate
 * @param classLoader - the class loaders to examine
 * @return the resource or null
 */
URL getResourceAsURL(String resource, ClassLoader[] classLoader) {
    URL url;
    // 遍历 ClassLoader 数组
    for (ClassLoader cl : classLoader) {
        if (null != cl) {
            // 获得 URL ，不带 /
            // look for the resource as passed in...
            url = cl.getResource(resource);
            // 获得 URL ，带 /
            // ...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;
}

2.4 getResourceAsStream

#getResourceAsStream(String resource, ...) 方法，获得指定资源的 InputStream 对象。代码如下：

// ClassLoaderWrapper.java

/**
 * Get a resource from the classpath
 *
 * @param resource - the resource to find
 * @return the stream or null
 */
public InputStream getResourceAsStream(String resource) {
    return getResourceAsStream(resource, getClassLoaders(null));
}

/**
 * Get a resource from the classpath, starting with a specific class loader
 *
 * @param resource    - the resource to find
 * @param classLoader - the first class loader to try
 * @return the stream or null
 */
public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
    return getResourceAsStream(resource, getClassLoaders(classLoader));
}

先调用 #getClassLoaders(ClassLoader classLoader) 方法，获得 ClassLoader 数组。

再调用 #getResourceAsStream(String resource, ClassLoader[] classLoader) 方法，获得指定资源的 InputStream 。代码如下：

// ClassLoaderWrapper.java

InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
    // 遍历 ClassLoader 数组
    for (ClassLoader cl : classLoader) {
        if (null != cl) {
            // 获得 InputStream ，不带 /
            // try to find the resource as passed
            InputStream returnValue = cl.getResourceAsStream(resource);
            // now, some class loaders want this leading "/", so we'll add it and try again if we didn't find the resource
            // 获得 InputStream ，带 /
            if (null == returnValue) {
                returnValue = cl.getResourceAsStream("/" + resource);
            }

            // 成功获得到，返回
            if (null != returnValue) {
                return returnValue;
            }
        }
    }
    return null;
}

可使用多个 ClassLoader 加载对应的资源，直到有一成功后返回资源。

2.5 classForName

#classForName(String name, ...) 方法，获得指定类名对应的类。代码如下：

// ClassLoaderWrapper.java

/**
 * Find a class on the classpath (or die trying)
 *
 * @param name - the class to look for
 * @return - the class
 * @throws ClassNotFoundException Duh.
 */
public Class<?> classForName(String name) throws ClassNotFoundException {
    return classForName(name, getClassLoaders(null));
}

/**
 * Find a class on the classpath, starting with a specific classloader (or die trying)
 *
 * @param name        - the class to look for
 * @param classLoader - the first classloader to try
 * @return - the class
 * @throws ClassNotFoundException Duh.
 */
public Class<?> classForName(String name, ClassLoader classLoader) throws ClassNotFoundException {
    return classForName(name, getClassLoaders(classLoader));
}

先调用 #getClassLoaders(ClassLoader classLoader) 方法，获得 ClassLoader 数组。

再调用 #classForName(String name, ClassLoader[] classLoader) 方法，获得指定类名对应的类。代码如下：

// ClassLoaderWrapper.java

Class<?> classForName(String name, ClassLoader[] classLoader) throws ClassNotFoundException {
    // 遍历 ClassLoader 数组
    for (ClassLoader cl : classLoader) {
        if (null != cl) {
            try {
                // 获得类
                Class<?> c = Class.forName(name, true, cl);

                // 成功获得到，返回
                if (null != c) {
                    return c;
                }
            } catch (ClassNotFoundException e) {
                // we'll ignore this until all classloaders fail to locate the class
            }
        }
    }
    // 获得不到，抛出 ClassNotFoundException 异常
    throw new ClassNotFoundException("Cannot find class: " + name);
}

可使用多个 ClassLoader 加载对应的类，直到有一成功后返回类。

3. Resources

org.apache.ibatis.io.Resources ，Resource 工具类。

3.1 构造方法

// Resources.java

/**
 * ClassLoaderWrapper 对象
 */
private static ClassLoaderWrapper classLoaderWrapper = new ClassLoaderWrapper();

/**
 * 字符集
 */
private static Charset charset;

Resources() {
}

public static void setDefaultClassLoader(ClassLoader defaultClassLoader) {defaultClassLoader
    classLoaderWrapper.defaultClassLoader = defaultClassLoader; // 修改 ClassLoaderWrapper.
}

public static void setCharset(Charset charset) {
    Resources.charset = charset;
}

3.2 getResource

基于 classLoaderWrapper 属性的封装。

3.2.1 getResourceURL

#getResourceURL(String resource) 静态方法，获得指定资源的 URL 。代码如下：

// Resources.java

public static URL getResourceURL(String resource) throws IOException {
    // issue #625
    return getResourceURL(null, resource);
}

public static URL getResourceURL(ClassLoader loader, String resource) throws IOException {
    URL url = classLoaderWrapper.getResourceAsURL(resource, loader);
    if (url == null) {
        throw new IOException("Could not find resource " + resource);
    }
    return url;
}

3.2.2 getResourceAsStream

#getResourceAsStream(String resource) 静态方法，获得指定资源的 InputStream 。代码如下：

// Resources.java

public static InputStream getResourceAsStream(String resource) throws IOException {
    return getResourceAsStream(null, resource);
}

public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
    InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
    if (in == null) {
        throw new IOException("Could not find resource " + resource);
    }
    return in;
}

3.2.3 getResourceAsReader

#getResourceAsReader(String resource) 静态方法，获得指定资源的 Reader 。代码如下：

// Resources.java

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

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

3.2.4 getResourceAsFile

#getResourceAsFile(String resource) 静态方法，获得指定资源的 File 。代码如下：

// Resources.java

public static File getResourceAsFile(String resource) throws IOException {
    return new File(getResourceURL(resource).getFile());
}

public static File getResourceAsFile(ClassLoader loader, String resource) throws IOException {
    return new File(getResourceURL(loader, resource).getFile());
}

基于 classLoaderWrapper 属性的封装。

3.2.5 getResourceAsProperties

#getResourceAsProperties(ClassLoader loader) 静态方法，获得指定资源的 Properties 。代码如下：

// Resources.java

public static Properties getResourceAsProperties(String resource) throws IOException {
    Properties props = new Properties();
    // 读取
    try (InputStream in = getResourceAsStream(resource)) {
        props.load(in);
    }
    return props;
}

public static Properties getResourceAsProperties(ClassLoader loader, String resource) throws IOException {
    Properties props = new Properties();
    // 读取
    try (InputStream in = getResourceAsStream(loader, resource)) {
        props.load(in);
    }
    return props;
}

3.3 getUrl

3.3.1 getUrlAsStream

#getUrlAsStream(String urlString) 静态方法，获得指定 URL 。代码如下：

// Resources.java

public static InputStream getUrlAsStream(String urlString) throws IOException {
    URL url = new URL(urlString);
    // 打开 URLConnection
    URLConnection conn = url.openConnection();
    return conn.getInputStream();
}

3.3.2 getUrlAsReader

#getUrlAsReader(String urlString) 静态方法，指定 URL 的 Reader 。代码如下：

// Resources.java

public static Reader getUrlAsReader(String urlString) throws IOException {
    Reader reader;
    if (charset == null) {
        reader = new InputStreamReader(getUrlAsStream(urlString));
    } else {
        reader = new InputStreamReader(getUrlAsStream(urlString), charset);
    }
    return reader;
}

3.3.3 getUrlAsProperties

#getUrlAsReader(String urlString) 静态方法，指定 URL 的 Properties 。代码如下：

// Resources.java

public static Properties getUrlAsProperties(String urlString) throws IOException {
    Properties props = new Properties();
    try (InputStream in = getUrlAsStream(urlString)) {
        props.load(in);
    }
    return props;
}

3.4 classForName

#classForName(String className) 静态方法，获得指定类名对应的类。代码如下：

// Resources.java

public static Class<?> classForName(String className) throws ClassNotFoundException {
    return classLoaderWrapper.classForName(className);
}

4. ResolverUtil

org.apache.ibatis.io.ResolverUtil ，解析器工具类，用于获得指定目录符合条件的类们。

4.1 Test

Test ，匹配判断接口。代码如下：

// ResolverUtil.java 内部类

/**
 * A simple interface that specifies how to test classes to determine if they
 * are to be included in the results produced by the ResolverUtil.
 */
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);

}

4.1.1 IsA

IsA ，实现 Test 接口，判断是否为指定类。代码如下：

// ResolverUtil.java 内部类

/**
 * A Test that checks to see if each class is assignable to the provided class. Note
 * that this test will match the parent type itself if it is presented for matching.
 */
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);
    }

}

4.1.2 AnnotatedWith

AnnotatedWith ，判断是否有指定注解。代码如下：

// ResolverUtil.java 内部类

/**
 * A Test that checks to see if each class is annotated with a specific annotation. If it
 * is, then the test returns true, otherwise false.
 */
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);
    }

}

4.2 构造方法

// ResolverUtil.java

/** The set of matches being accumulated. */
private Set<Class<? extends T>> matches = new HashSet<>(); // 符合条件的类的集合

private ClassLoader classloader;

public Set<Class<? extends T>> getClasses() {
    return matches;
}

public ClassLoader getClassLoader() {
    return classloader == null ? Thread.currentThread().getContextClassLoader() : classloader;
}
public void setClassLoader(ClassLoader classloader) {
    this.classloader = classloader;
}

4.3 find

#find(Test test, String packageName) 方法，获得指定包下，符合条件的类。代码如下：

// ResolverUtil.java

public ResolverUtil<T> find(Test test, String packageName) {
    // <1> 获得包的路径
    String path = getPackagePath(packageName);

    try {
        // <2> 获得路径下的所有文件
        List<String> children = VFS.getInstance().list(path);
        // <3> 遍历
        for (String child : children) {
            // 是 Java Class
            if (child.endsWith(".class")) {
                // 如果匹配，则添加到结果集
                addIfMatching(test, child);
            }
        }
    } catch (IOException ioe) {
        log.error("Could not read package: " + packageName, ioe);
    }

    return this;
}

<1> 处，调用 #getPackagePath(String packageName) 方法，获得包的路径。代码如下：

// ResolverUtil.java

protected String getPackagePath(String packageName) {
    return packageName == null ? null : packageName.replace('.', '/');
}

<2> 处，获得路径下的所有文件。详细解析，见「5. VFS」。

<3> 处，遍历 Java Class 文件，调用 #addIfMatching(Test test, String fqn) 方法，如果匹配，则添加到结果集。代码如下：

// ResolverUtil.java

protected void addIfMatching(Test test, String fqn) {
    try {
        // 获得全类名
        String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
        ClassLoader loader = getClassLoader();
        if (log.isDebugEnabled()) {
            log.debug("Checking to see if class " + externalName + " matches criteria [" + test + "]");
        }

        // 加载类
        Class<?> type = loader.loadClass(externalName);

        // 判断是否匹配
        if (test.matches(type)) {
            matches.add((Class<T>) type);
        }
    } catch (Throwable t) {
        log.warn("Could not examine class '" + fqn + "'" + " due to a " +
                t.getClass().getName() + " with message: " + t.getMessage());
    }
}

* 使用对应的 `test` 的进行匹配。

4.3.1 findImplementations

#findImplementations(Class<?> parent, String... packageNames) 方法，判断指定目录下们，符合指定类的类们。代码如下：

// ResolverUtil.java

public ResolverUtil<T> findImplementations(Class<?> parent, String... packageNames) {
    if (packageNames == null) {
        return this;
    }

    Test test = new IsA(parent);
    for (String pkg : packageNames) {
        find(test, pkg);
    }

    return this;
}

4.3.2 findAnnotated

#findAnnotated(Class<? extends Annotation> annotation, String... packageNames) 方法，判断指定目录下们，符合指定注解的类们。代码如下：

// ResolverUtil.java

public ResolverUtil<T> findAnnotated(Class<? extends Annotation> annotation, String... packageNames) {
    if (packageNames == null) {
        return this;
    }

    Test test = new AnnotatedWith(annotation);
    for (String pkg : packageNames) {
        find(test, pkg);
    }

    return this;
}

5. VFS

org.apache.ibatis.io.VFS ，虚拟文件系统( Virtual File System )抽象类，用来查找指定路径下的的文件们。

5.1 静态属性

// VFS.java

/** The built-in implementations. */
public static final Class<?>[] IMPLEMENTATIONS = {JBoss6VFS.class, DefaultVFS.class}; // 内置的 VFS 实现类的数组

/** The list to which implementations are added by {@link #addImplClass(Class)}. */
public static final List<Class<? extends VFS>> USER_IMPLEMENTATIONS = new ArrayList<>(); // 自定义的 VFS 实现类的数组

public static void addImplClass(Class<? extends VFS> clazz) {
    if (clazz != null) {
        USER_IMPLEMENTATIONS.add(clazz);
    }
}

IMPLEMENTATIONS 静态属性，内置的 VFS 实现类的数组。目前 VFS 有 JBoss6VFS 和 DefaultVFS 两个实现类。
USER_IMPLEMENTATIONS 静态属性，自定义的 VFS 实现类的数组。可通过 #addImplClass(Class<? extends VFS> clazz) 方法，进行添加。

5.2 getInstance

#getInstance() 方法，获得 VFS 单例。代码如下：

// VFS.java

public static VFS getInstance() {
    return VFSHolder.INSTANCE;
}

private static class VFSHolder {

    static final VFS INSTANCE = createVFS();

    @SuppressWarnings("unchecked")
    static VFS createVFS() {
        // Try the user implementations first, then the built-ins
        List<Class<? extends VFS>> impls = new ArrayList<>();
        impls.addAll(USER_IMPLEMENTATIONS);
        impls.addAll(Arrays.asList((Class<? extends VFS>[]) IMPLEMENTATIONS));

        // Try each implementation class until a valid one is found
        // 创建 VFS 对象，选择最后一个符合的
        VFS vfs = null;
        for (int i = 0; vfs == null || !vfs.isValid(); i++) {
            Class<? extends VFS> impl = impls.get(i);
            try {
                vfs = impl.newInstance();
                if (vfs == null || !vfs.isValid()) {
                    if (log.isDebugEnabled()) {
                        log.debug("VFS implementation " + impl.getName() +
                                " is not valid in this environment.");
                    }
                }
            } catch (InstantiationException | IllegalAccessException e) {
                log.error("Failed to instantiate " + impl, e);
                return null;
            }
        }

        if (log.isDebugEnabled()) {
            log.debug("Using VFS adapter " + vfs.getClass().getName());
        }

        return vfs;
    }
}

单例有多种实现方式，该类采用的是“懒汉式，线程安全”，感兴趣的胖友，可以看看《单例模式的七种写法》。
INSTANCE 属性，最后通过 #createVFS() 静态方法来创建，虽然 USER_IMPLEMENTATIONS 和 IMPLEMENTATIONS 有多种 VFS 的实现类，但是最终选择的是，最后一个符合的创建的 VFS 对象。

5.3 反射相关方法

因为 VFS 自己有反射调用方法的需求，所以自己实现了三个方法。代码如下：

// VFS.java

protected static Class<?> getClass(String className) {
    try {
        return Thread.currentThread().getContextClassLoader().loadClass(className);
    } catch (ClassNotFoundException e) {
        if (log.isDebugEnabled()) {
            log.debug("Class not found: " + className);
        }
        return null;
    }
}

protected static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
    if (clazz == null) {
        return null;
    }
    try {
        return clazz.getMethod(methodName, parameterTypes);
    } catch (SecurityException e) {
        log.error("Security exception looking for method " + clazz.getName() + "." + methodName + ".  Cause: " + e);
        return null;
    } catch (NoSuchMethodException e) {
        log.error("Method not found " + clazz.getName() + "." + methodName + "." + methodName + ".  Cause: " + e);
        return null;
    }
}

protected static <T> T invoke(Method method, Object object, Object... parameters)
        throws IOException, RuntimeException {
    try {
        return (T) method.invoke(object, parameters);
    } catch (IllegalArgumentException | IllegalAccessException e) {
        throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
        if (e.getTargetException() instanceof IOException) {
            throw (IOException) e.getTargetException();
        } else {
            throw new RuntimeException(e);
        }
    }
}

5.4 isValid

#isValid() 抽象方法，判断是否为合法的 VFS 。代码如下：

// VFS.java

/** Return true if the {@link VFS} implementation is valid for the current environment. */
public abstract boolean isValid();

该方法由子类实现。

5.5 list

#list(String path) 方法，获得指定路径下的所有资源。代码如下：

// VFS.java

public List<String> list(String path) throws IOException {
    List<String> names = new ArrayList<>();
    for (URL url : getResources(path)) {
        names.addAll(list(url, path));
    }
    return names;
}

先调用 #getResources(String path) 静态方法，获得指定路径下的 URL 数组。代码如下：

// VFS.java

protected static List<URL> getResources(String path) throws IOException {
    return Collections.list(Thread.currentThread().getContextClassLoader().getResources(path));
}

后遍历 URL 数组，调用 #list(URL url, String forPath) 方法，递归的列出所有的资源们。代码如下：

// VFS.java

/**
 * Recursively list the full resource path of all the resources that are children of the
 * resource identified by a URL.
 *
 * @param url The URL that identifies the resource to list.
 * @param forPath The path to the resource that is identified by the URL. Generally, this is the
 *            value passed to {@link #getResources(String)} to get the resource URL.
 * @return A list containing the names of the child resources.
 * @throws IOException If I/O errors occur
 */
protected abstract List<String> list(URL url, String forPath) throws IOException;

该方法由子类进行实现。

5.5 DefaultVFS

org.apache.ibatis.io.DefaultVFS ，继承 VFS 抽象类，默认的 VFS 实现类。

5.5.1 isValid

// DefaultVFS.java

@Override
public boolean isValid() {
    return true;
}

都返回 true ，因为默认支持。

5.5.2 list

#list(URL url, String path) 方法，递归的列出所有的资源们。代码如下：

// DefaultVFS.java

@Override
public List<String> list(URL url, String path) throws IOException {
    InputStream is = null;
    try {
        List<String> resources = new ArrayList<>();

        // First, try to find the URL of a JAR file containing the requested resource. If a JAR
        // file is found, then we'll list child resources by reading the JAR.
        // 如果 url 指向的是 Jar Resource ，则返回该 Jar Resource ，否则返回 null
        URL jarUrl = findJarForResource(url);
        if (jarUrl != null) {
            is = jarUrl.openStream();
            if (log.isDebugEnabled()) {
                log.debug("Listing " + url);
            }
            // 遍历 Jar Resource
            resources = listResources(new JarInputStream(is), path);
        } else {
            List<String> children = new ArrayList<>();
            try {
                // 判断为 JAR URL
                if (isJar(url)) {
                    // Some versions of JBoss VFS might give a JAR stream even if the resource
                    // referenced by the URL isn't actually a JAR
                    is = url.openStream();
                    try (JarInputStream jarInput = new JarInputStream(is)) {
                        if (log.isDebugEnabled()) {
                            log.debug("Listing " + url);
                        }
                        for (JarEntry entry; (entry = jarInput.getNextJarEntry()) != null; ) {
                            if (log.isDebugEnabled()) {
                                log.debug("Jar entry: " + entry.getName());
                            }
                            children.add(entry.getName());
                        }
                    }
                } else {
                    /*
                     * Some servlet containers allow reading from directory resources like a
                     * text file, listing the child resources one per line. However, there is no
                     * way to differentiate between directory and file resources just by reading
                     * them. To work around that, as each line is read, try to look it up via
                     * the class loader as a child of the current resource. If any line fails
                     * then we assume the current resource is not a directory.
                     */
                    // 【重点】<1> 获得路径下的所有资源
                    is = url.openStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(is));
                    List<String> lines = new ArrayList<>();
                    for (String line; (line = reader.readLine()) != null; ) {
                        if (log.isDebugEnabled()) {
                            log.debug("Reader entry: " + line);
                        }
                        lines.add(line);
                        if (getResources(path + "/" + line).isEmpty()) {
                            lines.clear();
                            break;
                        }
                    }

                    if (!lines.isEmpty()) {
                        if (log.isDebugEnabled()) {
                            log.debug("Listing " + url);
                        }
                        children.addAll(lines);
                    }
                }
            } catch (FileNotFoundException e) {
                /*
                 * For file URLs the openStream() call might fail, depending on the servlet
                 * container, because directories can't be opened for reading. If that happens,
                 * then list the directory directly instead.
                 */
                if ("file".equals(url.getProtocol())) {
                    File file = new File(url.getFile());
                    if (log.isDebugEnabled()) {
                        log.debug("Listing directory " + file.getAbsolutePath());
                    }
                    if (file.isDirectory()) {
                        if (log.isDebugEnabled()) {
                            log.debug("Listing " + url);
                        }
                        children = Arrays.asList(file.list());
                    }
                } else {
                    // No idea where the exception came from so rethrow it
                    throw e;
                }
            }

            // The URL prefix to use when recursively listing child resources
            // 【重点】<2> 计算 prefix
            String prefix = url.toExternalForm();
            if (!prefix.endsWith("/")) {
                prefix = prefix + "/";
            }

            // Iterate over immediate children, adding files and recursing into directories
            // 【重点】 <2> 遍历子路径
            for (String child : children) {
                // 添加到 resources 中
                String resourcePath = path + "/" + child;
                resources.add(resourcePath);
                // 递归遍历子路径，并将结果添加到 resources 中
                URL childUrl = new URL(prefix + child);
                resources.addAll(list(childUrl, resourcePath));
            }
        }

        return resources;
    } finally {
        // 关闭文件流
        if (is != null) {
            try {
                is.close();
            } catch (Exception e) {
                // Ignore
            }
        }
    }
}

代码有点长，重点读懂 <1> 和 <2> 处的代码，基本就可以了。大体逻辑就是，不断递归文件夹，获得到所有文件。设计到对 Jar 的处理，感兴趣的胖友，可以自己理解下。😈 艿艿暂时没看的特别细。

#findJarForResource(URL url) 方法，如果 url 指向的是 Jar Resource ，则返回该 Jar Resource ，否则返回 null 。代码如下：

// DefaultVFS.java

protected URL findJarForResource(URL url) throws MalformedURLException {
    if (log.isDebugEnabled()) {
        log.debug("Find JAR URL: " + url);
    }

    // If the file part of the URL is itself a URL, then that URL probably points to the JAR
    // 这段代码看起来比较神奇，虽然看起来没有 break 的条件，但是是通过 MalformedURLException 异常进行
    // 正如上面英文注释，如果 URL 的文件部分本身就是 URL ，那么该 URL 可能指向 JAR
    try {
        for (; ; ) {
            url = new URL(url.getFile());
            if (log.isDebugEnabled()) {
                log.debug("Inner URL: " + url);
            }
        }
    } catch (MalformedURLException e) {
        // This will happen at some point and serves as a break in the loop
    }

    // Look for the .jar extension and chop off everything after that
    // 判断是否意 .jar 结尾
    StringBuilder jarUrl = new StringBuilder(url.toExternalForm());
    int index = jarUrl.lastIndexOf(".jar");
    if (index >= 0) {
        jarUrl.setLength(index + 4);
        if (log.isDebugEnabled()) {
            log.debug("Extracted JAR URL: " + jarUrl);
        }
    } else {
        if (log.isDebugEnabled()) {
            log.debug("Not a JAR: " + jarUrl);
        }
        return null; // 如果不以 .jar 结尾，则直接返回 null
    }

    // Try to open and test it
    try {
        URL testUrl = new URL(jarUrl.toString());
        // 判断是否为 Jar 文件
        if (isJar(testUrl)) {
            return testUrl;
        } else {
            // WebLogic fix: check if the URL's file exists in the filesystem.
            if (log.isDebugEnabled()) {
                log.debug("Not a JAR: " + jarUrl);
            }
            // 获得文件
            jarUrl.replace(0, jarUrl.length(), testUrl.getFile()); // 替换
            File file = new File(jarUrl.toString());
            // File name might be URL-encoded
            if (!file.exists()) { // 处理路径编码问题
                try {
                    file = new File(URLEncoder.encode(jarUrl.toString(), "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException("Unsupported encoding?  UTF-8?  That's unpossible.");
                }
            }

            // 判断文件存在
            if (file.exists()) {
                if (log.isDebugEnabled()) {
                    log.debug("Trying real file: " + file.getAbsolutePath());
                }
                testUrl = file.toURI().toURL();
                // 判断是否为 Jar 文件
                if (isJar(testUrl)) {
                    return testUrl;
                }
            }
        }
    } catch (MalformedURLException e) {
        log.warn("Invalid JAR URL: " + jarUrl);
    }

    if (log.isDebugEnabled()) {
        log.debug("Not a JAR: " + jarUrl);
    }
    return null;
}

会判断要求，url 以 .jar 结尾。

#isJar(URL url) 方法，判断是否为 JAR URL 。代码如下：

// DefaultVFS.java

/** The magic header that indicates a JAR (ZIP) file. */
private static final byte[] JAR_MAGIC = {'P', 'K', 3, 4};

protected boolean isJar(URL url) {
    return isJar(url, new byte[JAR_MAGIC.length]);
}

protected boolean isJar(URL url, byte[] buffer) {
    InputStream is = null;
    try {
        is = url.openStream();
        // 读取文件头
        is.read(buffer, 0, JAR_MAGIC.length);
        // 判断文件头的 magic number 是否符合 JAR
        if (Arrays.equals(buffer, JAR_MAGIC)) {
            if (log.isDebugEnabled()) {
                log.debug("Found JAR: " + url);
            }
            return true;
        }
    } catch (Exception e) {
        // Failure to read the stream means this is not a JAR
    } finally {
        if (is != null) {
            try {
                is.close();
            } catch (Exception e) {
                // Ignore
            }
        }
    }
    return false;
}

#listResources(JarInputStream jar, String path) 方法，遍历 Jar Resource 。代码如下：

// DefaultVFS.java

protected List<String> listResources(JarInputStream jar, String path) throws IOException {
    // Include the leading and trailing slash when matching names
    // 保证头尾都是 /
    if (!path.startsWith("/")) {
        path = "/" + path;
    }
    if (!path.endsWith("/")) {
        path = path + "/";
    }

    // Iterate over the entries and collect those that begin with the requested path
    // 遍历条目并收集以请求路径开头的条目
    List<String> resources = new ArrayList<>();
    for (JarEntry entry; (entry = jar.getNextJarEntry()) != null; ) {
        if (!entry.isDirectory()) {
            // Add leading slash if it's missing
            String name = entry.getName();
            if (!name.startsWith("/")) {
                name = "/" + name;
            }

            // Check file name
            if (name.startsWith(path)) {
                if (log.isDebugEnabled()) {
                    log.debug("Found resource: " + name);
                }
                // Trim leading slash
                resources.add(name.substring(1));
            }
        }
    }
    return resources;
}

5.6 JBoss6VFS

org.apache.ibatis.io.JBoss6VFS ，继承 VFS 抽象类，基于 JBoss 的 VFS 实现类。使用时，需要引入如下：

<dependency>
    <groupId>org.jboss</groupId>
    <artifactId>jboss-vfs</artifactId>
    <version>${version></version>
</dependency>

因为实际基本没使用到，所以暂时不分析这个类。感兴趣的胖友，可以自己瞅瞅。还是简单的。反正艿艿暂时不感兴趣，哈哈哈。

666. 彩蛋

周末偷懒了，写到 1 点多，还没写完。这篇对 DefaultVFS#list(URL url, String path) 方法的源码解析，有点着急，代码看着有点乱和糟心。后续有时间，在详细补充下。

参考和推荐如下文章：

无忌《MyBatis 源码解读之工具类》
徐郡明《MyBatis 技术内幕》的「2.5 资源加载」小节

38 KiB Raw Permalink Blame History Unescape Escape