配置就是xml，spring将对物理资源的访问方式抽象成Resource。

Resource家族

Resource是个接口，继承了InputStreamSource，定义了资源的基本操作（全是读操作）

InputStreamSource有唯一一个方法getInputStream

主要是根据不同的资源，定义了不同类的实现。

ServletContextResource负责以相对于Web应用程序根目录的路径加载资源，支持以流或url的形式进行访问，在war包解压出来的情况下，也可以通过file的形式访问

ClassPathResource用于访问类加载路径下的资源，对于web应用来说，可以自动加载WEB-INF/classes目录下的资源文件，无需使用绝对路径访问

FileSystemResource用于访问文件系统资源，优势不明显，java的File类也可以做到

EncodedResource

主要实现对资源文件的编码处理，其具体的逻辑实现在getReader

当我们给资源设置了编码属性之后，Spring会使用相应的编码作为输入流的编码

AbstractResource

主要提供了Resource方法的大部分的默认公共实现，如果想要自定义Resource，不推荐直接继承Resource接口，而更应该继承这个抽象类。

WritableResource

FileSystemResource为了能实现写操作，继承了WritableResource，其中有返回输出流实例的方法

根据资源地址自动选择正确的Resource

强大的加载资源的方式：

自动识别"classpath:"、"file:"等资源地址前缀

支持自动解析Ant风格带通配符的资源地址

Ant：

路径匹配表达式，用来对URI进行匹配

？匹配任何单字符

*匹配0或者任意数量的字符

**匹配0或者更多的目录

ResourceLoader

实现不同的Resource加载策略，按需返回特定类型的Resource：

是个接口，Resource getResource(String location);方法可以根据传入的location自动返回一个Resource实例（前面说的三个具体实现类）。

还提供了ClassLoader getClassLoader();方法暴露出来类加载器

DefaultResourceLoader.java提供了ResourceLoader的实现，最关键的是getResource方法

// 获取Resource的具体实现类实例
@Override
public Resource getResource(String location) {
   Assert.notNull(location, "Location must not be null");
   // ProtocolResolver用户自定义协议资源解决策略
   // 有的话就拿过来用一下，去解析location（看用户是否提前指定好了根据不同的location去解析resource实例）
   for (ProtocolResolver protocolResolver : getProtocolResolvers()) {
      Resource resource = protocolResolver.resolve(location, this);
      if (resource != null) {
         return resource;
      }
   }
   // 如果是以/开头，则构造ClassPathContextResource返回
   if (location.startsWith("/")) {
      return getResourceByPath(location);
   }
   // 若以classpath：开头，则构造 ClassPathResource 类型资源并返回，在构造该资源时，通过 getClassLoader()获取当前的 ClassLoader
   else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
      return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
   }
   else {
      // 构造URL，尝试通过它进行资源定位，若没有抛出MalformedURLException异常，
      //    判断是否为FileURL，如果是则构造 FileUrlResource 类型资源，否则构造UrlResource。
      // 若在加载过程中抛出MalformedURLException异常，
      // 则委派 getResourceByPath实现资源定位加载
      try {
         // Try to parse the location as a URL...
         URL url = new URL(location);
         return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
      }
      catch (MalformedURLException ex) {
         // No URL -> resolve as resource path.
         // 返回的是ClassPathContextResource
         return getResourceByPath(location);
      }
   }
}

这里使用的是策略模式，Resource是策略接口，以及很多的实现子类是策略类，通过DefaultResourceLoader，决定返回的是哪个具体的策略（实现类）。策略模式需要用户明确知道策略，即什么样的资源用什么样的Resource，工厂模式用户不必知道细节。

ResourcePatternResolver提供了根据路径匹配模式，返回多个Resource实例，

Resource[] getResources(String locationPattern) throws IOException;

同时新增了一个协议前缀，该前缀由子类负责实现

String CLASSPATH_ALL_URL_PREFIX = "classpath*:";

在继承关系表中可以发现ApplicationContext也间接实现了ResourceLoader接口

AbstractApplicationContext继承了DefaultResourceLoader，并且里面有getResourcePatternResolver方法，用于生成PathMatchingResourcePatternResolver这个实例。

这个方法是在 AbstractApplicationContext 的构造函数里用的，也就意味着AbstractApplicationContext 可以调用 ResourcePatternResolver 的 getResources 方法，来根据路径返回多个Resource实例。

综上所述，AbstractApplicationContext 的实现完全可以支持ResourceLoader和ResourcePatternResolver，这也是高级容器为什么支持统一资源加载的原因。委托给了PathMatchingResourcePatternResolver 和 DefaultResourceLoader 来执行。

ResourceLoader 的使用者BeanDefinitionReader

利器的使用者

读取BeanDefinition

BeanDefinitionRegistry

BeanDefinitionReader会利用ResourceLoader或者ResourcePatternResolver将配置信息解析成一个个的BeanDefinition，并最终借助BeanDefinitionRegistry的注册接口，将BeanDefinition给注册到容器里。

BeanDefinitionReader定义了一系列加载BeanDefinition的接口，针对单个配置文件：

int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;

针对多个配置文件：

int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;

针对单个Resource资源实例：

int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;

针对多个Resource资源实例：

int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;

最终的目的就是将配置文件的配置转换成一个个的BeanDefinition

还有其他方法：

/**
 * 获取BeanDefinitionRegistry对象，这个类的主要作用将BeanDefinition注册到BeanDefinition的注册表中
 * @return
 */
BeanDefinitionRegistry getRegistry();

/**
 * Bean的名字生成器，为匿名bean生成一个名字，就是id
 * @return
 */
BeanNameGenerator getBeanNameGenerator();

BeanDefinitionReader体系结构

AbstractBeanDefinitionReader实现了公共处理逻辑，主要的一个方法是loadBeanDefinitions，方法内先获取ResourceLoader，再判断获取的实例是哪一个实例，如果是ResourcePatternResolver的话则代表需要加载多个资源，else里面是只加载单个资源，最终都会调用loadBeanDefinitions方法做进一步的加载。

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
   // 获取资源加载器，主要的功能就是根据路径和类加载器获取Resource对象
   ResourceLoader resourceLoader = getResourceLoader();
   // 判断资源加载器是否为空
   if (resourceLoader == null) {
      throw new BeanDefinitionStoreException(
            "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
   }
   // ResourcePatternResolver 用于加载多个文件或者能够加载Ant风格路径的文件资源
   if (resourceLoader instanceof ResourcePatternResolver) {
      // Resource pattern matching available.
      try {
         Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
         int count = loadBeanDefinitions(resources);
         if (actualResources != null) {
            Collections.addAll(actualResources, resources);
         }
         if (logger.isTraceEnabled()) {
            logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
         }
         return count;
      }
      catch (IOException ex) {
         throw new BeanDefinitionStoreException(
               "Could not resolve bean definition resource pattern [" + location + "]", ex);
      }
   }
   else {
      // Can only load single resources by absolute URL.
      // 加载单个文件资源
      // 直接使用ResouceLoader加载
      Resource resource = resourceLoader.getResource(location);
      int count = loadBeanDefinitions(resource);
      if (actualResources != null) {
         actualResources.add(resource);
      }
      if (logger.isTraceEnabled()) {
         logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
      }
      return count;
   }
}

XmlBeanDefinitionReader

从xml文件中读取bean definitions的方法

@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
   return loadBeanDefinitions(new EncodedResource(resource));
}

又主要调用了上面的loadBeanDefinitions的if里面的逻辑

会根据location获取到Resource实例。

loadBeanDefinitions方法会先指定编码以解析xml资源：

new EncodedResource(resource)

之后执行XmlBeanDefinitionReader的loadBeanDefinitions，这个方法返回一个int类型的数据，表示本次加载并注册到容器里面的bean definition的个数。

为了支持多线程加载，加载是一个耗时过程，方法里面用到了resourcesCurrentlyBeingLoaded，是一个ThreadLocal类型的本地变量来存储正在加载的资源。（使用ThreadLocal修饰的变量只能当前线程对其修改，key是线程号，value是线程对应的资源）。

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
   Assert.notNull(encodedResource, "EncodedResource must not be null");
   if (logger.isTraceEnabled()) {
      logger.trace("Loading XML bean definitions from " + encodedResource);
   }
   // 从本地线程变量中获取当前的正在加载的资源
   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
   // 如果本地线程变量中不存在正在加载的资源，那么将其添加进去
   if (currentResources == null) {
      currentResources = new HashSet<>(4);
      this.resourcesCurrentlyBeingLoaded.set(currentResources);
   }
   // 如果encodedResource添加进入currentResources失败，表明其中已经存在这个资源，只不过没有加载完成
   if (!currentResources.add(encodedResource)) {
      throw new BeanDefinitionStoreException(
            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
   }
   try {
      // 获取文件的输入流
      InputStream inputStream = encodedResource.getResource().getInputStream();
      try {
         // 封装成InputSource，其中指定了输入流和编码格式
         InputSource inputSource = new InputSource(inputStream);
         // 如果存在编码，那么将其添加进入InputSource中
         if (encodedResource.getEncoding() != null) {
            inputSource.setEncoding(encodedResource.getEncoding());
         }
         // 调用同类的方法继续解析
         return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
      }
      finally {
         // 关闭输入流
         inputStream.close();
      }
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException(
            "IOException parsing XML document from " + encodedResource.getResource(), ex);
   }
   finally {
      currentResources.remove(encodedResource);
      if (currentResources.isEmpty()) {
         this.resourcesCurrentlyBeingLoaded.remove();
      }
   }
}

SpringIOC源码解析（4）—— Resource、ResourceLoader、容器之间的微妙关系

Resource家族

AbstractResource

WritableResource

根据资源地址自动选择正确的Resource

强大的加载资源的方式：

Ant：

ResourceLoader

ResourceLoader 的使用者BeanDefinitionReader

利器的使用者

BeanDefinitionReader体系结构

XmlBeanDefinitionReader

容器服务

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像