Spring的统一资源加载策略

清疚 2022-10-31 04:08 174阅读 0赞

## 写在前面 ##

什么是资源呢？最基本的本地磁盘上的一个文件，远端某服务器的一个图片，本地的一个jar包，本地的一个jar包内的内嵌jar包/内嵌class文件/内嵌properties文件，这些都是资源，为了能够满足各种资源的读取，spring定义了统一的资源加载策略。

## 1：Resource接口 ##

该接口在spring的`spring-core`模块中，完整类名`org.springframework.core.io.Resource`，该接口要用来抽象资源的定义的，最终资源会封装为该接口类型的一个对象，然后使用该对象来操作资源，源码如下：

public interface Resource extends InputStreamSource { 
    
    	// 判断文件是否存在
    	boolean exists();
    
    	// 判断文件是否可读，该方法是一个default方法，提供默认实现
    	default boolean isReadable() { 
    		return exists();
    	}
    
    	// 判断文件句柄是否被打开，该方法是以default方法，提供默认实现
    	default boolean isOpen() { 
    		return false;
    	}
    
    	// 判断是否为一个文件，该方法是一个default方法，提供默认实现
    	default boolean isFile() { 
    		return false;
    	}
    
    	// 获取文件对应URL（如http://,jar://,ftp://,file://等）
    	URL getURL() throws IOException;
    	// 返回资源的URI
    	URI getURI() throws IOException;
    	// 获取文件对象
    	File getFile() throws IOException;
    
    	// 返回nio的ReadableByteChannel对象，该方法为default方法，直接使用
    	// Channels的静态方法newChannel创建
    	default ReadableByteChannel readableChannel() throws IOException { 
    		return Channels.newChannel(getInputStream());
    	}
    
    	// 返回文件的长度
    	long contentLength() throws IOException;
    
    	// 返回文件的上次修改时间
    	long lastModified() throws IOException;
    	
    	// 根据当前资源的相对路径，创建其它资源的Resource
    	Resource createRelative(String relativePath) throws IOException;
    
    	// 获取文件的名称
    	@Nullable
    	String getFilename();
    
    	// 获取资源的描述
    	String getDescription();
    
    }

其继承了接口`org.springframework.core.io.InputStreamSource`,该接口只定义了一个获取输入流的方法,源码如下：

public interface InputStreamSource { 
    	// 获取资源对应的输入流对象
    	InputStream getInputStream() throws IOException;
    
    }

### 1.1：AbstractResource ###

该类是Resource接口的抽象实现类，全限定名是`org.springframework.core.io.AbstractResource`，该类定义如下：

public abstract class AbstractResource implements Resource { 
    	@Override
    	public boolean exists() { 
    		// 直接根据File获取是否存在，如果无法正常获取则进入异常
    		// 尝试其它方式获取
    		try { 
    			return getFile().exists();
    		}
    		catch (IOException ex) { 
    			// 尝试通过InputStream获取，如果是能够close则返回true
    			// 否则进入异常返回false代表资源不存在
    			try { 
    				getInputStream().close();
    				return true;
    			}
    			catch (Throwable isEx) { 
    				return false;
    			}
    		}
    	}
    
    	@Override
    	public boolean isReadable() { 
    		// 存在即可读
    		return exists();
    	}
    
    	@Override
    	public boolean isOpen() { 
    		return false;
    	}
    
    	@Override
    	public boolean isFile() { 
    		return false;
    	}
    
    	@Override
    	public URL getURL() throws IOException { 
    		// 抛出异常，强制交给子类实现
    		throw new FileNotFoundException(getDescription() + " cannot be resolved to URL");
    	}
    
    	// URL转URI
    	@Override
    	public URI getURI() throws IOException { 
    		URL url = getURL();
    		try { 
    			return ResourceUtils.toURI(url);
    		}
    		catch (URISyntaxException ex) { 
    			throw new NestedIOException("Invalid URI [" + url + "]", ex);
    		}
    	}
    
    	// 直接抛出异常强制子类实现
    	@Override
    	public File getFile() throws IOException { 
    		throw new FileNotFoundException(getDescription() + " cannot be resolved to absolute file path");
    	}
    
    	@Override
    	public ReadableByteChannel readableChannel() throws IOException { 
    		return Channels.newChannel(getInputStream());
    	}
    
    	// 获取文件长度，其实就是文件内容的byte数
    	@Override
    	public long contentLength() throws IOException { 
    		// 获取输入流
    		InputStream is = getInputStream();
    		try { 
    			long size = 0;
    			byte[] buf = new byte[256];
    			int read;
    			// 通过while循环读取到byte数组中累加获取最终长度
    			while ((read = is.read(buf)) != -1) { 
    				size += read;
    			}
    			return size;
    		}
    		finally { 
    			try { 
    				is.close();
    			}
    			catch (IOException ex) { 
    			}
    		}
    	}
    
    	// 获取资源的最后修改时间
    	@Override
    	public long lastModified() throws IOException { 
    		File fileToCheck = getFileForLastModifiedCheck();
    		long lastModified = fileToCheck.lastModified();
    		if (lastModified == 0L && !fileToCheck.exists()) { 
    			throw new FileNotFoundException(getDescription() +
    					" cannot be resolved in the file system for checking its last-modified timestamp");
    		}
    		return lastModified;
    	}
    
    	protected File getFileForLastModifiedCheck() throws IOException { 
    		return getFile();
    	}
    
    	// 根据当前资源的相对路径创建其它新的资源对象，直接抛出
    	// FileNotFoundException强制子类实现
    	@Override
    	public Resource createRelative(String relativePath) throws IOException { 
    		throw new FileNotFoundException("Cannot create a relative resource for " + getDescription());
    	}
    
    	// 获取文件名称，直接返回null，交给但不强制子类实现
    	@Override
    	@Nullable
    	public String getFilename() { 
    		return null;
    	}
    
    	@Override
    	public boolean equals(Object other) { 
    		return (this == other || (other instanceof Resource &&
    				((Resource) other).getDescription().equals(getDescription())));
    	}
    
    	@Override
    	public int hashCode() { 
    		return getDescription().hashCode();
    	}
    
    	@Override
    	public String toString() { 
    		return getDescription();
    	}
    
    }

如果是我们想要自定义Resource直接继承该抽象类就可以了。

## 2：ResourceLoader接口 ##

该接口在spring的spring-core模块中，限定名是`org.springframework.core.io.ResourceLoader`。该接口用于定义资源的加载，其实内部是使用的Resource接口，源码不是很复杂，如下：

public interface ResourceLoader { 
    	
    	// public static final String CLASSPATH_URL_PREFIX = "classpath:";
    	String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;
    
    	// 根据位置获取资源对象
    	// 值可以是URL如file:c:/test.txt，classpath如classpath:resources.xml
    	// 也可以是相对路径，如WEB-INF/web.xml
    	Resource getResource(String location);
    
    	// 获取类加载器
    	@Nullable
    	ClassLoader getClassLoader();
    
    }

### 2.1：DefaultResourceLoader ###

该类是ResourceLoader的默认实现类，注意是一个类，而不是抽象类，先来看一个使用的例子，代码：

@Test
    public void testResourceLoader() throws Exception { 
        // 定义resourceloader
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        // http://img.ewebweb.com/uploads/20191006/20/1570365161-shmEFlWfHU.jpg
        String resourceLocation = "https://www.baidu.com/";
        Resource resource = resourceLoader.getResource(resourceLocation);
        System.out.println(resource.getFilename());
        System.out.println(resource.contentLength());
        System.out.println(resource.getURL());
        System.out.println(resource.getURI());
    
        InputStream inputStream = resource.getInputStream();
    
        StringBuffer out = new StringBuffer();
        byte[] b = new byte[4096];
        for (int n; (n = inputStream.read(b)) != -1; ) { 
            out.append(new String(b, 0, n));
        }
        System.out.println(out);
    }

测试：

2443
    https://www.baidu.com/
    https://www.baidu.com/
    <!DOCTYPE html>
    <html> ...snip...
    title>百度一下，你就知道</title>

我们来就着例子分析下`org.springframework.core.io.ResourceLoader#getResource`部分源码：

org.springframework.core.io.DefaultResourceLoader#getResource
    @Override
    publicResource getResource(String location) { 
    	// 断言判断
    	Assert.notNull(location, "Location must not be null");
    	// <DefaultResourceLoader#getResource_1>
    	for (ProtocolResolver protocolResolver : getProtocolResolvers()) { 
    		Resource resource = protocolResolver.resolve(location, this);
    		if (resource != null) { 
    			return resource;
    		}
    	}
    	// 如果是以/开头则调用getResourceByPath方法，一般子类重载该方法就可以了
    	if (location.startsWith("/")) { 
    		// <DefaultResourceLoader#getResource_2>
    		return getResourceByPath(location);
    	}
    	// 如果是以classpath开头，则返回ClassPathResouce对象
    	else if (location.startsWith(CLASSPATH_URL_PREFIX)) { 
    		return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
    	}
    	else { 
    		try { 
    			// 根据位置创建url对象
    			URL url = new URL(location);
    			// <DefaultResourceLoader#getResource_3>
    			return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
    		}
    		catch (MalformedURLException ex) { 
    			// No URL -> resolve as resource path.
    			return getResourceByPath(location);
    		}
    	}
    }

`<DefaultResourceLoader#getResource_1>`处本例中没有元素，后续会分析，这里暂时忽略，如下图：  
![在这里插入图片描述][20210221155809609.png]  
这是协议扩展使用的。`<DefaultResourceLoader#getResource_2>`处源码：

protected Resource getResourceByPath(String path) { 
    	return new ClassPathContextResource(path, getClassLoader());
    }

直接使用ClassPathContextResource类创建对象作为Resource使用。`<DefaultResourceLoader#getResource_3>`是我们会真正执行到的代码位置，会首先通过`ResourceUtils.isFileURL(url)`判断是否是文件地址，比如`file://`就是文件地址，运行效果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]  
我们这里是`https`协议，所以结果为`false`，那么`<DefaultResourceLoader#getResource_3>`处的最终执行的代码就是`new UrlResource(url))`，即最终返回`UrlResouce`作为Resource。  
在`<DefaultResourceLoader#getResource_1>`并没有ResourceResolver，这是spring留给我们的扩展口，可以通过实现`org.springframework.core.io.ProtocolResolver`接口，然后通过方法`org.springframework.core.io.DefaultResourceLoader#addProtocolResolver`添加，该方法源码如下：

org.springframework.core.io.DefaultResourceLoader#addProtocolResolver
    public void addProtocolResolver(ProtocolResolver resolver) { 
    	Assert.notNull(resolver, "ProtocolResolver must not be null");
    	// private final Set<ProtocolResolver> protocolResolvers = new LinkedHashSet<>(4);
    	this.protocolResolvers.add(resolver);
    }

下面我们来自定义一个schema为`dongshidaddy:`的自定义协议解析器，在这之前我们先来看下ProtocolResolver的源码：

@FunctionalInterface
    public interface ProtocolResolver { 
    
    	@Nullable
    	Resource resolve(String location, ResourceLoader resourceLoader);
    
    }

注意到注解`@FunctionalInterface`,该注解用于编译阶段，限制接口中只能有一个抽象方法，如下就是不可以的:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]  
如下一个抽象，一个default是可以的：  
![在这里插入图片描述][20210221200752562.png]  
只有一个抽象方法自然也是可以的：  
![在这里插入图片描述][20210221200829405.png]  
接口中的方法`Resource resolve(String location, ResourceLoader resourceLoader)`就是我们需要实现的唯一的方法，最终解析我们自定义的协议，返回Resource就可以了，如下自定义协议解析器：

public class DongshiDaddyProtocolResolver implements ProtocolResolver { 
        private static final String DONGSHIDADDY_SCHEMA="dongshidaddy:";
    
        @Override
        public Resource resolve(String location, ResourceLoader resourceLoader) { 
            if (!location.startsWith(DONGSHIDADDY_SCHEMA))
                return null;
            String realPath = location.substring(13);
            String classPath = "classpath:" + realPath;
    
            return resourceLoader.getResource(classPath);
        }
    }

测试代码：

@Test
    public void testSeftDefineProtocolResolver() throws Exception { 
        DefaultResourceLoader resourceLoader=new DefaultResourceLoader();
        resourceLoader.addProtocolResolver(new DongshiDaddyProtocolResolver());
        Resource resource = resourceLoader.getResource("dongshidaddy:test.txt");
        InputStream inputStream = resource.getInputStream();
        StringBuffer out = new StringBuffer();
        byte[] b = new byte[4096];
        for (int n; (n = inputStream.read(b)) != -1; ) { 
            out.append(new String(b, 0, n));
        }
        System.out.println(out);
    }

测试的文件如下:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 2]  
运行：

testing!!!
    
    Process finished with exit code 0

如下debug`org.springframework.core.io.DefaultResourceLoader#getResource`：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 3]  
因此可以说`ProtocolResolver`是spring留给我们的`扩展点`。

接下来我们单起篇幅来看下主要的`ResouceLoader`都有哪些。

## 3：FileSystemResourceLoader ##

通过该资源加载器返回的资源类是`FileSystemContextResource`。

### 3.1：测试代码 ###

@Test
    public void testFileSystemResourceLoader() { 
        String path = "d:\\test\\mystarter-1.0-SNAPSHOT.jar";
        FileSystemResourceLoader fileSystemResourceLoader = new FileSystemResourceLoader();
        Resource resource = fileSystemResourceLoader.getResource(path);
        System.out.println("resource instanceof FileSystemResource: " + (resource instanceof FileSystemResource));
        System.out.println("resource.getFilename() is: " + resource.getFilename());
    }

首先执行如下代码：

org.springframework.core.io.DefaultResourceLoader#getResource
    @Override
    public Resource getResource(String location) { 
    	Assert.notNull(location, "Location must not be null");
    
    	...snip...
    	else { 
    		try { 
    			...snip...
    		}
    		catch (MalformedURLException ex) { 
    			// <2021-02-22 13:38>
    			return getResourceByPath(location);
    		}
    	}
    }

会执行到代码`<2021-02-22 13:38>`处，最终调用到方法`org.springframework.core.io.FileSystemResourceLoader#getResourceByPath`，源码如下：

org.springframework.core.io.FileSystemResourceLoader#getResourceByPath
    @Override
    protected Resource getResourceByPath(String path) { 
    	// 处理斜杠开头的情况，一般在linux环境，本例测试是windows环境
    	// 值是d:\\test\\mystarter-1.0-SNAPSHOT.jar，因此if为false
    	if (path.startsWith("/")) { 
    		path = path.substring(1);
    	}
    	// <2021-02-22 10:41>,直接new一个FileSystemContextResource
    	return new FileSystemContextResource(path);
    }

`<2021-02-22 10:41>`处直接创建FileSystemContextResource类，该类是一个私有内部类，源码如下：

org.springframework.core.io.FileSystemResourceLoader.FileSystemContextResource
    private static class FileSystemContextResource extends FileSystemResource implements ContextResource { 
    	// <2021-02-22 10:41> 构造函数
    	public FileSystemContextResource(String path) { 
    		super(path);
    	}
    
    	@Override
    	public String getPathWithinContext() { 
    		return getPath();
    	}
    }

在构造函数中`super(path);`直接调用如下代码完成创建：

org.springframework.core.io.FileSystemResource#FileSystemResource(java.lang.String)
    public FileSystemResource(String path) { 
    	Assert.notNull(path, "Path must not be null");
    	// <2021-02-22 10:56> 处理路径为标准格式
    	this.path = StringUtils.cleanPath(path);
    	// 创建文件对象
    	this.file = new File(path);
    	// 记录文件路径
    	this.filePath = this.file.toPath();
    }

`<2021-02-22 10:56>`处可以参考[这里][Link 1]。

## 4：ClassRelativeResourceLoader ##

该类是基于class的相对路径来加载资源，先来看个例子，在`resources`目录下创建`test.xml`，然后编写如下测试代码：

@Test
    public void testClassRelativeResourceLoader() throws Exception { 
        ResourceLoader resourceLoader = new ClassRelativeResourceLoader(MyFirstSpringBean.class);
        Resource resource = resourceLoader.getResource("../../test.xml");
        File file = resource.getFile();
        System.out.println(file.getPath());
    }

编译后`MyFirstSpringBean.class`和`test.xml`路径关系如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 4]  
执行测试代码：

E:\workspace-idea\java-life\target\classes\test.xml
    
    Process finished with exit code 0

来看下是否为实际的系统路径：  
![在这里插入图片描述][20210222113448893.png]  
来看下源码执行过程，首先执行到代码：

@Override
    public Resource getResource(String location) { 
    	Assert.notNull(location, "Location must not be null");
    
    	...snip...
    	else { 
    		try { 
    			...snip...
    		}
    		catch (MalformedURLException ex) { 
    			// <2021-02-22 11:42>
    			return getResourceByPath(location);
    		}
    	}
    }

`<2021-02-22 11:42>`处执行代码`org.springframework.core.io.ClassRelativeResourceLoader#getResourceByPath`，源码如下：

org.springframework.core.io.ClassRelativeResourceLoader#getResourceByPath
    @Override
    protected Resource getResourceByPath(String path) { 
    	return new ClassRelativeContextResource(path, this.clazz);
    }

继续：

org.springframework.core.io.ClassRelativeResourceLoader.ClassRelativeContextResource#ClassRelativeContextResource
    public ClassRelativeContextResource(String path, Class<?> clazz) { 
    	// <2021-02-22 11:43>
    	super(path, clazz);
    	this.clazz = clazz;
    }

`<2021-02-22 11:43>`处执行如下代码：

org.springframework.core.io.ClassPathResource#ClassPathResource(java.lang.String, java.lang.Class<?>)
    public ClassPathResource(String path, @Nullable Class<?> clazz) { 
    	Assert.notNull(path, "Path must not be null");
    	// 该处处理前路径为../../test.xml，处理后路径依然是../../test.xml
    	this.path = StringUtils.cleanPath(path);
    	// 记录clazz到属性中
    	this.clazz = clazz;
    }

最后我们来看下测试代码`File file = resource.getFile();`是如何通过class和相对路径来获取文件对象的，执行到代码：

org.springframework.core.io.AbstractFileResolvingResource#getFile()
    @Override
    public File getFile() throws IOException { 
    	// <2021-02-22 11:59>
    	URL url = getURL();
    	if (url.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) { 
    		return VfsResourceDelegate.getResource(url).getFile();
    	}
    	return ResourceUtils.getFile(url, getDescription());
    }

直接看`<2021-02-22 11:59>`处源码：

org.springframework.core.io.ClassPathResource#getURL
    @Override
    public URL getURL() throws IOException { 
    	// <2021-02-22 12:00>
    	URL url = resolveURL();
    	if (url == null) { 
    		throw new FileNotFoundException(getDescription() + " cannot be resolved to URL because it does not exist");
    	}
    	return url;
    }

继续看`<2021-02-22 12:00>`处源码：

@Nullable
    protected URL resolveURL() { 
    	// 会进入if
    	if (this.clazz != null) { 
    		// 直接通过java.lang.Class#getResource获取URL
    		return this.clazz.getResource(this.path);
    	}
    	else if (this.classLoader != null) { 
    		return this.classLoader.getResource(this.path);
    	}
    	else { 
    		return ClassLoader.getSystemResource(this.path);
    	}
    }

这里就通过class对象获取了对应文件的URL了，后续也都是基于该URL来操作了。

## 5：ResourcePatternResolver ##

ResourceLoader接口定义的API只能通过一个位置获取资源对象，如果是我们有根据多个路径获取多个资源的需求，除了for循环一个一个的获取，别无他法，为了解决这个问题，spring定义了接口`org.springframework.core.io.support.ResourcePatternResolver`,源码如下：

public interface ResourcePatternResolver extends ResourceLoader { 
    	// 预定义的基于classpath的多个路径协议
    	String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
    
    	// 根据模式路径获取多个资源的方法
    	Resource[] getResources(String locationPattern) throws IOException;
    
    }

最常用的一个子类是`PathMatchingResourcePatternResolver`,我们先来看下该类的主要的用法。

### 5.1：PathMatchingResourcePatternResolver用法 ###

#### 5.1.1：加载单个文件 ####

*  代码

@Test
    public void testPathMatchingResourcePatternResolverWithClass() throws Exception { 
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resources = resolver.getResources("yudaosourcecode/spring/DiUser.class");
        System.out.println("resources.length is: " + resources.length);
        for (Resource resource : resources) { 
            System.out.println(resource.getClass());
            System.out.println(resource.getFile().getPath());
        }
    }

*  测试

resources.length is: 1
    class org.springframework.core.io.DefaultResourceLoader$ClassPathContextResource
    E:\workspace-idea\java-life\target\classes\yudaosourcecode\spring\DiUser.class

#### 5.1.2：通过classpath\*加载多个文件 ####

*  代码

@Test
    public void testPathMatchingResourcePatternResolverWithClasspathStart() throws IOException { 
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resources = resolver.getResources("classpath*:yudaosourcecode/spring/*.class");
        System.out.println("resources.length is: " + resources.length);
        for (Resource resource : resources) { 
            System.out.println(resource.getClass());
            System.out.println(resource.getFile().getPath());
        }
    }

*  测试

resources.length is: 9
    class org.springframework.core.io.FileSystemResource
    E:\workspace-idea\java-life\target\classes\yudaosourcecode\spring\ConstructorDi.class
    class org.springframework.core.io.FileSystemResource
    E:\workspace-idea\java-life\target\classes\yudaosourcecode\spring\DiPerson.class
    class org.springframework.core.io.FileSystemResource
    E:\workspace-idea\java-life\target\classes\yudaosourcecode\spring\DiUser.class
    class org.springframework.core.io.FileSystemResource
    E:\workspace-idea\java-life\target\classes\yudaosourcecode\spring\DongshiDaddyProtocolResolver.class
    class org.springframework.core.io.FileSystemResource
    ...snip...

### 5.2：PathMatchingResourcePatternResolver源码 ###

该类的路径是`org.springframework.core.io.support.PathMatchingResourcePatternResolver`，该类除了支持ResourcePatternResolver新增的`classpath*:`外，还支持Ant风格的路径匹配模式，如`**/*/*.xml`。来看下源码,首先到方法`org.springframework.core.io.support.PathMatchingResourcePatternResolver#getResources`，源码如下：

org.springframework.core.io.support.PathMatchingResourcePatternResolver#getResources
    @Override
    public Resource[] getResources(String locationPattern) throws IOException { 
    	Assert.notNull(locationPattern, "Location pattern must not be null");
    	// 以CLASSPATH_ALL_URL_PREFIX,即org.springframework.core.io.support.ResourcePatternResolver#CLASSPATH_ALL_URL_PREFIX 
    	// String CLASSPATH_ALL_URL_PREFIX = "classpath*:";开头
    	if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) { 
    		// <2021-02-22 15:50>
    		// 通过Ant路径匹配器AntPathMatcher判断路径是否为Ant风格路径
    		if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) { 
    			// <2021-02-22 15:53>
    			return findPathMatchingResources(locationPattern);
    		}
    		// 如果是路径不是Ant风格的
    		else { 
    			// <2021-02-22 15:54>
    			return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
    		}
    	}
    	// 如果不是以classpath*开头的
    	else { 
    		int prefixEnd = (locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 :
    				locationPattern.indexOf(':') + 1);
    		if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) { 
    			return findPathMatchingResources(locationPattern);
    		}
    		else { 
    			// a single resource with the given name
    			return new Resource[] { getResourceLoader().getResource(locationPattern)};
    		}
    	}
    }

`<2021-02-22 15:50>`处代码，方法`getPathMatcher()`源码如下：

public PathMatcher getPathMatcher() { 
    	// private PathMatcher pathMatcher = new AntPathMatcher();
    	// 返回接口PathMatcher的实现类AntPathMatcher
    	return this.pathMatcher;
    }

接着调用方法`org.springframework.util.AntPathMatcher#isPattern`源码如下：

@Override
    public boolean isPattern(String path) { 
    	boolean uriVar = false;
    	for (int i = 0; i < path.length(); i++) { 
    		char c = path.charAt(i);
    		if (c == '*' || c == '?') { 
    			return true;
    		}
    		if (c == '{') { 
    			uriVar = true;
    			continue;
    		}
    		if (c == '}' && uriVar) { 
    			return true;
    		}
    	}
    	return false;
    }

主要是判断是否包含`*`,`?`,`{}`等通配符，有的话就返回true，否则返回false。`<2021-02-22 15:53>`处代码源码如下：

org.springframework.core.io.support.PathMatchingResourcePatternResolver#findPathMatchingResources
    protected Resource[] findPathMatchingResources(String locationPattern) throws IOException { 
    	// <2021-02-22 15:54> 获取路径去除通配符的部分，作为根路径
    	String rootDirPath = determineRootDir(locationPattern);
    	// 获取通配符部分路径，如classpath*:yudaosourcecode/spring/*.class
    	// subPattern结果就是*.class
    	String subPattern = locationPattern.substring(rootDirPath.length());
    	// 再重复调用getResources获取所有资源的Resouces数组
    	// 这里一般就是一个文件夹对应的资源，所以长度一般为1
    	Resource[] rootDirResources = getResources(rootDirPath);
    	// 最终我们需要的资源的结果集合
    	Set<Resource> result = new LinkedHashSet<>(16);
    	// 循环所有的的资源，只留下我们需要的资源
    	for (Resource rootDirResource : rootDirResources) { 
    		// 该方法直接返回自己，因此该行代码目前没有实际作用
    		rootDirResource = resolveRootDirResource(rootDirResource);
    		URL rootDirUrl = rootDirResource.getURL();
    		// 这里处理bundle，不是和了解，先忽略，有需要再看
    		if (equinoxResolveMethod != null && rootDirUrl.getProtocol().startsWith("bundle")) { 
    			URL resolvedUrl = (URL) ReflectionUtils.invokeMethod(equinoxResolveMethod, null, rootDirUrl);
    			if (resolvedUrl != null) { 
    				rootDirUrl = resolvedUrl;
    			}
    			rootDirResource = new UrlResource(rootDirUrl);
    		}
    		// 处理vfg，不是很了解，先忽略
    		if (rootDirUrl.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) { 
    			result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirUrl, subPattern, getPathMatcher()));
    		}
    		// 处理jar:,war:,等协议路径
    		else if (ResourceUtils.isJarURL(rootDirUrl) || isJarResource(rootDirResource)) { 
    			result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirUrl, subPattern));
    		}
    		// 处理其他路径协议，这里包括classpath*:
    		else { 
    		// 该处代码根据资源和需要的文件通配符，从文件夹资源下获取对应的资源,如果路径为classpath*:yudaosourcecode/spring/*.class，则rootDirResource为
    		// URL [file:/E:/workspace-idea/java-life/target/classes/yudaosourcecode/spring/]
    		// subPattern为*.class
    		// 比较复杂，先不深究
    		result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
    		}
    	}
    	if (logger.isTraceEnabled()) { 
    		logger.trace("Resolved location pattern [" + locationPattern + "] to resources " + result);
    	}
    	return result.toArray(new Resource[0]);
    }

[20210221155809609.png]: /images/20221024/049af6c17acd4afbbb5b042f3176a2a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]: /images/20221024/d4477a9ea31a424194942ed5a28a7971.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]: /images/20221024/01c5038334284ff08b08f494558f299a.png
[20210221200752562.png]: /images/20221024/c89cdb01e769439c97ee37ac207bf5b7.png
[20210221200829405.png]: /images/20221024/2d2f42686ddc4b00aa9edd19b0fc2bd5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 2]: /images/20221024/77eed9d9666145c29ae55ecba199e522.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 3]: /images/20221024/8747d6d9d54c4609970a42fc66da5f81.png
[Link 1]: https://blog.csdn.net/wang0907/article/details/113460564
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 4]: /images/20221024/711598261e7d4fefb887a0da36458fb4.png
[20210222113448893.png]: /images/20221024/5ca0c1c541f14e5e9caf959d917678e0.png