@Resource详解

阅读本文之前希望读者最好已经对整个Bean的大体Spring执行顺序已经有了一定的了解。

示例

定义一个接口，表示水果类，只包含一个方法代表售卖。

public interface Fruit {

    void sell();
}

有两个具体实现类，Apple🍎和Banana🍌。

@Service
public class Apple implements Fruit {


    public Apple() {
        System.out.println("Apple......");
    }

    @Override
    public void sell() {
        System.out.println("苹果2元一斤");
    }
}

@Service
public class Banana implements Fruit {

    public Banana() {
        System.out.println("Banana...");
    }

    @Override
    public void sell() {
        System.out.println("香蕉3元一串");
    }
}

具体的商店类来注入Fruit接口。

@Component
public class Store {

    @Resource
    private Fruit fruit;

    public void getFruit() {
        fruit.sell();
    }

}

测试方法：

public class Test {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.getBean(Store.class).getFruit();


        // 优雅关闭，SpringWEB中已有相关实现
        context.registerShutdownHook();
    }
}

实际执行结果：

这里可以清楚的看到报了NoUniqueBeanDefinitionException异常，说是希望单个Bean的匹配，却找到了多个。

下面就来具体的讲下为什么。

首先，@Resource中没有设置任何属性值，统统采用的是默认的值。

按照Spring Bean的加载顺序，Store Bean创建的时候，BeanFactory中已经创建了Apple和Banana Bean。

1. newInstance

第一步就是先创建出Store对象。

2. 解析类中的字段

Spring在实例化对象后，会调用 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);方法对BeanDefinition进行完善，主要为了后续的BeanPostProcessor处理器在注入对应的字段时能获取到需要注入的类的相关信息。

而对应需要注入的一个个类而言，就是使用ResourceElement对象来进行保存，相关重要的构造函数如下：

public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
   super(member, pd);
   Resource resource = ae.getAnnotation(Resource.class);
   // 获取@Resource的name属性
   String resourceName = resource.name();
   // 获取@Resource的type属性
   Class<?> resourceType = resource.type();
   this.isDefaultName = !StringUtils.hasLength(resourceName);
   if (this.isDefaultName) {
      // 如果没有设置@Resource name属性就用字段名称作为bean name
      resourceName = this.member.getName();
      // 如果member是setter方法，则取setXXX的XXX部分为bean name
      if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
         resourceName = Introspector.decapitalize(resourceName.substring(3));
      }
   }
   else if (embeddedValueResolver != null) {
      // 如果设置了@Resource name的属性，则使用EmbeddedValueResolver对象先做一次SpringEL解析得到真正的bean name
      resourceName = embeddedValueResolver.resolveStringValue(resourceName);
   }
   if (Object.class != resourceType) {
      // 确保字段或setter方法类型与resourceType一致
      checkResourceType(resourceType);
   }
   else {
      // No resource type specified... check field/method.
      resourceType = getResourceType();
   }
   this.name = (resourceName != null ? resourceName : "");
   this.lookupType = resourceType;
   String lookupValue = resource.lookup();
   // 如果使用jndi查找名字
   this.mappedName = (StringUtils.hasLength(lookupValue) ? lookupValue : resource.mappedName());
   Lazy lazy = ae.getAnnotation(Lazy.class);
   // 是否延迟注入
   this.lazyLookup = (lazy != null && lazy.value());
}

当name属性没有被设置时，就会执行下面的分支，根据是方法注入还是属性注入，分别设置为方法名称set后面的字符串或字段名称。

   if (this.isDefaultName) {
      // 如果没有设置@Resource name属性就用字段名称作为bean name
      resourceName = this.member.getName();
      // 如果member是setter方法，则取setXXX的XXX部分为bean name
      if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
         resourceName = Introspector.decapitalize(resourceName.substring(3));
      }
   }

下面是具体的ResourceElement类对象中的各属性。

然后可以测试下在@Resource注解中加入name属性；

@Resource(name = “apple”)

得到的是下面的对象。

这里可以看出name属性会有明显的不同。

这里name属性和lookupType属性其实可以对应于@Resource中的name和type属性。

3. populateBean

第三步就是类属性的注入。

执行到对应的处理器（@Resource是通过CommonAnnotationBeanPostProcessor处理器进行处理的）进行属性注入的时候，autowireResource就会用来获取对应属性需要注入的对象。

protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
      throws NoSuchBeanDefinitionException {

   // 自动装配的对象
   Object resource;
   // 自动装配的名字
   Set<String> autowiredBeanNames;
   // 依赖的属性名
   String name = element.name;

   if (factory instanceof AutowireCapableBeanFactory) {
      AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
      DependencyDescriptor descriptor = element.getDependencyDescriptor();
      // 判断是否设置了name属性的值
      if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
         autowiredBeanNames = new LinkedHashSet<>();
         resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
         if (resource == null) {
            throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
         }
      }
      else {
         resource = beanFactory.resolveBeanByName(name, descriptor);
         autowiredBeanNames = Collections.singleton(name);
      }
   }
   else {
      resource = factory.getBean(name, element.lookupType);
      autowiredBeanNames = Collections.singleton(name);
   }

   if (factory instanceof ConfigurableBeanFactory) {
      ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
      for (String autowiredBeanName : autowiredBeanNames) {
         if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
            //注册依赖关系
            beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
         }
      }
   }

   return resource;
}

这里的element对象就是我们之前解析保存的ResourceElement。

然后最重要的，上面强调过的name属性在不同Resource注解中解析出来的ResourceElement是会不同的，这里就会有不同的处理方式。

当isDefaultName为false时，说明name属性被设置了值，此时执行的如下逻辑；

     resource = beanFactory.resolveBeanByName(name, descriptor);
     autowiredBeanNames = Collections.singleton(name);

resolveBeanByName方法就是通过设置的名称来进行解析对应的Bean对象。接着就能看到经常使用到的getBean方法，从BeanFactory中拿到Bean对象。

public Object resolveBeanByName(String name, DependencyDescriptor descriptor) {
   InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
   try {
      // 获取bean
      return getBean(name, descriptor.getDependencyType());
   }
   finally {
      // 为目标工厂方法提供依赖描述符
      ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
   }
}

当Resource注解中name没有设置值，即使用的是字段名称作为beanName，执行的就是

         resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);

resolveDependency方法中实际工作的方法就是doResolveDependency：

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

   //设置新得当前切入点对象，得到旧的当前切入点对象
   InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
   
       // ...省略

      // 查找相关所有类型匹配的bean
      Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
      //如果没有候选bean对象
      if (matchingBeans.isEmpty()) {
         //如果descriptor需要注入
         if (isRequired(descriptor)) {
            //抛出NoSuchBeanDefinitionException或BeanNotOfRequiredTypeException以解决不可 解决的依赖关系
            raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
         }
         //返回null，表示么有找到候选Bean对象
         return null;
      }

      //定义用于存储唯一的候选Bean名变量
      String autowiredBeanName;
      //定义用于存储唯一的候选Bean对象变量
      Object instanceCandidate;

      //如果候选Bean对象Map不止有一个
      if (matchingBeans.size() > 1) {
         //确定candidates中可以自动注入的最佳候选Bean名称
         autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);

         if (autowiredBeanName == null) {
            // 如果有多个匹配结果，抛出异常
            if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
               //让descriptor尝试选择其中一个实例，默认实现是抛出NoUniqueBeanDefinitionException.
               return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
            }
            else {
               return null;
            }
         }
         instanceCandidate = matchingBeans.get(autowiredBeanName);
      }
      else {
         //获取machingBeans唯一的元素
         Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
         autowiredBeanName = entry.getKey();
         instanceCandidate = entry.getValue();
      }

      // ...省略
  
      //返回最佳候选Bean对象【result】
      return result;
   }
   finally {
      //设置上一个切入点对象
      ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
   }
}

doResolveDependency方法中会获取所有和指定type相同的所有bean集合，当发现bean集合中的元素个数超过1时就抛出了上面出现的错误了，如果只有一个那自然而然就是拿那个bean来返回。

这里抛出的异常其实不是直接抛出的，而是调用的DependencyDescriptor中的resolveNotUnique方法，而该方法默认实现就是会直接抛出一个NoUniqueBeanDefinitionException异常，这也是Spring留的一个可扩展的地方。

我们可以通过继承DependencyDescriptor，然后重写该方法来自定义选择一个最优的bean（比如说选择第一个），然后在BeanPostProcessor中选择我们的子类作为实现，这样在@Resource不指定任何属性的情况下，有多个实现类的bean也不会抛出异常。

拓展

• 当只指定type属性时；

@Resource(type = Apple.class)

设置type属性后，isDefaultName的值还是为true，所以执行的还是resolveDependency方法。但是由于添加了类型的限制，所以也就不会匹配到多个Bean，而产生异常。

• 既指定了name属性，又指定了type类型，但是是不同的类；

@Resource(name = “banana”, type = Apple.class)

name属性被设置为banana，isDefaultName变为false，执行resolveBeanByName方法。

但是由于找不到对应beanName为banana，但是类型又为Apple.class的bean，还是会抛出异常。

总结

多种@Resource不同使用情况所执行方法如下所示；

• 当@Resource不设置任何值时，isDefaultName会为true，当对应字段名称的bean或者BeanDefinition已存在时会走byName的形式，否则走byType的形式；

• 只指定了type属性时，只有当对应的名称不存在对应的bean或BeanDefinition，才会通过byType找到唯一的一个类型匹配的bean；

• 只指定了name属性，会执行getBean方法，根据指定的name来获取bean；

• 既指定了name属性，又指定了type属性，会先根据那么查找对应的bean，然后进行type类型比较。

如何解决本文最上面出现的问题？

• @Resource中指定name或着type；
• @Qualifier指定bean名称；
• 将字段名称修改为指定的bean名称；
• 直接修改对象类型。

只推荐第一种方法。

---

一、前言

@Autowired和@Resource都是用来自动装配bean的。

• @Resource是JSR-250提供的，它是Java标准，绝大部分框架都支持。
• @Autowired功能非常强大，但只适用于Spring框架，如果换成了JFinal等其他框架，功能就会失效。

Spring Bean覆盖配置

spring:
  main:
    allow-bean-definition-overriding: true

allow-bean-definition-overriding属性用于配置出现相同名称bean的情况如何处理：

• 值为false时（默认值为false），如果出现相同名称的bean，直接抛异常。
• 值为true时，表示支持相同名称的bean覆盖，后定义的bean会覆盖之前定义的相同名称的bean。

下文会提到按类型装配，那么什么是同一类型呢？

• 父类及其子类，都属于父类这一类型。
• 接口及其实现类，都属于接口这一类型。

二、@Autowired

@Autowired是Spring提供的注解，用于自动装配。

注解处理器

AutowiredAnnotationBeanPostProcessor类是Autowired注解的注解处理器。

关于注解处理器可参考文章：https://blog.csdn.net/JokerLJG/article/details/123548694

装配方式

• 按类型装配（默认使用的装配方式）。
• 按名称装配（结合@Qualifier注解使用）。

注解属性

• required：默认值true。值为true时，表示必须注入，如bean不存在则会报错；值为false时，表示bean存在就注入，不存在则不注入。

作用范围

@Autowired的作用范围：成员变量、构造器、方法、参数、注解。

1. 成员变量

@Service
public class UserService {

    @Autowired
    private IUser user;
}

使用最多的方式。

2. 构造器

@Service
public class UserService {

    private IUser user;

    @Autowired
    public UserService(IUser user) {
        this.user = user;
    }
}

构造器上使用Autowired注解，实际上还是使用了成员变量装配的方式，并非构造器装配。

3. 方法

@Service
public class UserService {

    @Autowired
    public void test(IUser user) {
       user.test();
    }
}

Spring会在项目启动的过程中，自动调用一次加了@Autowired注解的方法，我们可以在该方法做一些初始化的工作。

4. 参数

在构造器的入参上加Autowired注解

@Service
public class UserService {

    private IUser user;

    public UserService(@Autowired IUser user) {
        this.user = user;
        System.out.println("user:" + user);
    }
}

在非静态方法的入参上加Autowired注解

@Service
public class UserService {

    public void test(@Autowired IUser user) {
       user.test();
    }
}

5. 注解

略。

使用技巧

同一类型多个bean

当按类型装配时，如果该类型的bean不止一个时，会直接报错。举例说明：

接口：

public interface IUser {
    void test();
}

实现类1：

@Service
public class User1 implements IUser{
    @Override
    public void test() {
    }
}

实现类2：

@Service
public class User2 implements IUser{
    @Override
    public void test() {
    }
}

自动装配：

@Service
public class UserService {

    @Autowired
    private IUser user;
}

启动时的错误信息：

Field userService in com.joker.controller.UserController required a single bean, but 2 were found:
	- userServiceImpl1: defined in file [D:\work\my\springboot\target\classes\com\joker\controller\UserServiceImpl1.class]
	- userServiceImpl2: defined in file [D:\work\my\springboot\target\classes\com\joker\controller\UserServiceImpl2.class]

@Primary的使用

@Primary注解可以解决上述问题（按类型装配时，如果该类型的bean不止一个时，会报错）。

当我们使用自动配置的方式装配Bean时，如果这个Bean有多个候选者，假如其中一个候选者具有@Primary注解修饰，该候选者会被选中，作为自动装配的bean。

在上面代码不变的情况下，只需在User1或User2上加@Primary注解，此时@Autowired自动装配会成功，并且自动装配的是加了@Primary注解的这个类对应的bean。

User1类加@Primary注解

@Service
@Primary
public class User1 implements IUser{
    @Override
    public void test() {
    }
}

@Qualifier的使用

通过@Autowired和@Qualifier的结合使用可以按名称装配。

@Service
public class UserService {

    @Autowired
    @Qualifier("user1")
    private IUser user;
}

自动装配名称为user1的bean（注意：bean的类型也必须要满足为IUser类型）。

装配多个实例

我们一般使用的都是用@Autowired自动装配单个实例，但其实它也可以用来装配多个实例。可以通过List、Set、Map来装配多个实例，如下：

@Service
public class UserService {

    @Autowired
    private List<IUser> userList;

    @Autowired
    private Set<IUser> userSet;

    @Autowired
    private Map<String, IUser> userMap;
}

上面的装配方式会吧IUser类型的多个实例bean都装配的List、Set、Map中。

@Autowired装配未生效

下面列举常见@Autowired装配未生效的情况：

1. @Autowired所在类未加@Controller、@Service、@Component、@Repository等注解，或者或者一些其它情况（如直接new对象的到实例）。这些情况会导致该类的bean并没有交给spring容器去管理，spring就无法完成自动装配的功能。

   public class UserService {
   
       @Autowired
       private IUser user;
   
       public void test() {
           user.say();
       }
   }
   

2. 注解未被@ComponentScan扫描到。

三、@Resource

@Resource是JDK自带的注解，用于自动装配。

注解处理器

CommonAnnotationBeanPostProcessor类是Resource的注解处理器。

装配方式

@Resource默认按照名称自动注入。

• 既没指定name，也没指定type，自动按照名称装配（当注解写在字段上时，默认取字段名，当注解写在setter方法上时，默认取属性名进行装配。）；如果没有匹配，则退而按照类型装配，找不到则抛出异常。

  如果没有指定 name 属性，

• 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。

• 如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。

• 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。

注解属性

Resource注解的主要属性：

• name：指定需注入的bean的名称
• type： 指定需注入的bean的类型

作用范围

@Resource的作用范围：类、成员变量、方法。

1. 成员变量

@Service
public class UserService {

    @Resource
    private IUser user;
}

2. 方法

@Service
public class UserService {

    @Resource
    public void test(IUser user) {
        user.test();
    }
}

3. 类

略。

四、@Autowired与@Resource对比

二者对比

@Autowired	@Resource
Spring定义的注解	JSR-250定义的注解
默认按类型自动装配	默认按名称自动装配
一个参数：required(默认true)，表示是否必须注入	七个参数：最重要的两个参数是name、type
默认按类型自动装配 如果要按名称自动装配，需要使用@Qualifier一起配合	默认按名称自动装配 如果指定了name，则按名称自动装配；如果指定了type，则按类型自动装配
作用范围：构造器、方法、参数、成员变量、注解	作用范围：类、成员变量、方法

@Autowired装配流程

@Resource装配流程

        org.springframework.core.io.ClassPathResource位于Spring核心core下，用以表达类路径下的资源。
        首先简要说明一下什么是classpath，顾名思义，就是存放*.class类文件的路径，或者说ClassLoader加载类时为找到 *.class文件的路径。我们以一个WEB项目为例，发布后的目录结构大致如下：

        然后以Tomcat为例，看一下WEB项目类加载时候的目录，参考 Tomcat Class Loader How-To 中的说明:

WebappX — A class loader is created for each web application that is deployed in a single Tomcat instance. All unpacked classes and resources in the /WEB-INF/classes directory of your web application, plus classes and resources in JAR files under the /WEB-INF/lib directory of your web application, are made visible to this web application, but not to other ones.

        因此，对于部署在Tomcat上的WEB应用来说，/WEB-INF/classes和/WEB-INF/lib目录就是我们所指的classpath。

        ClassPathResource是org.springframework.core.io.Resource接口的实现类。可以使用ClassLoader或Class类加载资源。支持转换为java.io.File对象（在Jar文件中的资源除外）。其继承实现关系图如下：

        ClasspathResource类的属性变量和构造方法如下：

	private final String path;
	@Nullable
	private ClassLoader classLoader;// 通过ClassLoader加载资源文件
	@Nullable
	private Class<?> clazz; // 通过Class类加载资源文件
	
	// 通过类路径创建resource
	public ClassPathResource(String path){...}
	
	// 通过类路径和给定的ClassLoader创建resource
	public ClassPathResource(String path, @Nullable ClassLoader classLoader){...}
	
	// 通过类路径和给定的Class类创建resource
	public ClassPathResource(String path, @Nullable Class<?> clazz){...}
	
	// 通过类路径和给定的ClassLoader或Class创建resource
	protected ClassPathResource(String path, @Nullable ClassLoader classLoader, @Nullable Class<?> clazz){...}

        在类继承关系中，每个类定义的方法如下：

Resource	AbstractResource	AbstractFileResolvingResource	ClassPathResource
对底层资源的抽象描述 比如文件或类路径资源	对资源接口描述的基础实现 预先实现特定的行为	将URL解析为文件资源引用的抽象基类，尤其对JBOOS的vfs文件协议的支持	类路径资源的Resource实现
boolean exists() 判断该资源是否存在	public boolean exists() 实现父接口方法，检查资源（文件或目录）File对象或资源（文件）InputStream对象是否打开	public boolean exists() 重写父类方法，getURL后如果URL的文件协议是file:、vfsfile:、vfs则返回getFile().exists()直接判断该文件是否存在，如果非上述文件协议则尝试判断是否网络资源，通过HTTP请求看是否返回HTTP Status-Code=200，如果扔非上述，则尝试getInputStream().close()看文件流是否可打开	public boolean exists() 重写父类方法，判断是否能获取到该资源的URL对象
boolean isReadable() 是否可通过InputStreamSource.getInputStream()读取，这里注意返回true仍然可能读取失败，但返回false一定是不能读取 默认返回exists()	public boolean isReadable() 实现父接口方法，该方法在当资源存在的情况下始终返回true，返回值与父接口方法中定义的默认返回值一致，即返回exists()	public boolean isReadable() 重写父类方法，getURL后如果URL的文件协议是file:、vfsfile:、vfs则getFile得到该资源File对象，判断该File资源是否非目录且canRead可读，如果非上述文件协议则尝试调用网络资源，判断是否可成功调用且返回内容长度大于0，如果扔非上述，则尝试getInputStream().close()看文件流是否可打开
boolean isOpen() 表明该资源是否有打开的stream流，如果返回true则InputStream无法多次读取，且读完之后关闭流以防止内存泄露 默认返回false	public boolean isOpen() 实现父接口方法，与接口方法中定义的默认返回值一致，即始终返回false
boolean isFile() 判断该文件是否是系统文件中的文件，true值表示（但不保证）可以成功调用getFile()方法 默认返回false	public boolean isFile() 实现父接口方法，与接口方法中定义的默认返回值一致，即始终返回false	public boolean isFile() 重写父类方法，getURL后如果url为vfs开头协议（vfs/vfsfile）则交给VfsResourceDelegate类判断，如果url为file协议则返回true
		protected boolean isFile(URI uri) 重载isFile方法，根据指定的URI判断该资源是否是一个文件引用，如果URI的scheme以vfs开头则交给VfsResourceDelegate类判断，否则判断如果URI的scheme等于file则返回true
URL getURL() 返回该资源对应的URL	public URL getURL() 实现父接口方法，这里假设资源不能解析为URL，直接返回了FileNotFoundException异常		public URL getURL() 重写父类方法，根据类路径参数获取该资源的URL对象
URI getURI() 返回该资源对应的URI	public URI getURI() 实现父接口方法，基于getURL返回的URL构建一个URI
File getFile() 返回该资源的File对象	public File getFile() 实现父接口方法，这里假设资源无法解析为文件绝对路径，直接返回了FileNotFoundException异常	public File getFile() 重写父类方法，父类直接返回FileNotFoundException异常，在这里通过getURL获取到URL对象（具体URL由其子类确定，比如ClasspathResource重写了getURL通过类加载器获取到了类路径资源的URL），如果url为vfs开头协议（vfs/vfsfile）则交给VfsResourceDelegate类获取File对象，否则通过得到url获取File对象
		protected File getFile(URI uri) 重载getFile方法，根据指定的URI获取资源File对象，如果URI的scheme以vfs开头则交给VfsResourceDelegate类获取
ReadableByteChannel readableChannel() 默认返回Channels.newChannel(getInputStream())	public ReadableByteChannel readableChannel() 实现父接口方法，与父接口的默认返回值相同	public ReadableByteChannel readableChannel() 根据指定的URI调用FileChannel.open 返回一个ReadableByteChannel对象
long contentLength() 返回该资源内容的长度	public long contentLength() 根据getInputStream()返回的InputStream，读取并计算资源的内容长度	public long contentLength() 根据getURL获得URL对象，如果是文件(file/vfsfile/vfs)URL返回文件长度，否则尝试网络连接获取资源并返回长度
long lastModified() 返回该资源最后一次修改的时间戳	public long lastModified() 获取并返回该资源文件的时间戳	public long lastModified() 根据getURL获取URL对象，如果是文件(file/vfsfile/vfs)或归档文件(jar/war/zip/vfszip/wsjar)则获取文件的最后修改时间戳，否则获取网络连接并获取最后修改时间戳
Resource createRelative(String relativePath) 根据相对于该资源的相对路径，创建一个Resource资源，比如classpath资源目录conf下有A.xml和B.xml，Resource a = new ClassPathResource("conf/A.xml"); 那么在创建b资源的时候就可以以a为参照Resource b = a.createRelative("B.xml");	public Resource createRelative(String relativePath) 实现父接口方法，这里假设改相对资源未被创建，直接返回了FileNotFoundException异常		public Resource createRelative(String relativePath) 重写父类方法，根据参照资源的类路径得到relativePath参数的真实classpath路径，并创建Resource资源对象
String getFilename() 返回该资源的文件名，通常是路径的最后一部分，比如：myfile.txt	public String getFilename() 实现父接口方法，这里假设该资源无文件名，直接返回了null		public String getFilename() 重写父类方法，根据classpath截取后面的文件名并返回
String getDescription() 返回该资源的描述，用于该资源在处理时的错误输出			public String getDescription() 重写父类方法，返回格式如class path resource [...]的内容
	protected File getFileForLastModifiedCheck() 获取用于时间戳检查的文件，这里默认返回了getFile()	protected File getFileForLastModifiedCheck() 重写父类方法，扩展了父类方法，在getFile之前先判断url协议是否为jar/war/zip/vfszip/wsjar，如果是则获取最外层的文件URL对应的File对象，比如嵌套在war中的jar文件，则返回war文件File对象。这里判断vfs开头协议扔交给VfsResourceDelegate类来处理
	public boolean equals(Object other) 重写Object的equals方法，用于比较两个Resource的Description是否相同		public boolean equals(Object other) 重写Object方法，比较类路径的值是否相同
	public int hashCode() 重写Object的hashCode方法，用于获取Resource的Description值的hashCode值		public int hashCode() 重写Object方法，获取类路径classpath的hashCode值
	public String toString() 重写Object的toString方法，返回Resource的Description信息
			public final String getPath() 返回该资源的classpath，构造函数的path参数经过规范化处理的结果
			public final ClassLoader getClassLoader() 如果指定了Class，则通过该Class获取ClassLoader，否则返回属性变量的ClassLoader参数
			public InputStream getInputStream() Resource继承了InputStreamSource接口，在ClassPathResource中得到了具体的实现，根据资源路径得到文件流

        在AbstractFileResolvingResource类中由于增加了对JBOOS的vfs文件协议的支持，因此包含了一个`VfsResourceDelegate`内部类用于获取`VfsResource`类型资源对象，该资源对象同样继承自`AbstractResource`抽象类，并针对vfs文件的特点对方法进行了重写。如下：

/**
 * Inner delegate class, avoiding a hard JBoss VFS API dependency at runtime.
 */
private static class VfsResourceDelegate {

	public static Resource getResource(URL url) throws IOException {
		return new VfsResource(VfsUtils.getRoot(url));
	}

	public static Resource getResource(URI uri) throws IOException {
		return new VfsResource(VfsUtils.getRoot(uri));
	}
}

ClassPathResource的使用：

Resource resource = new ClassPathResource("conf/custom-beans.xml");

参数path应在类路径下能够被ClassLoader所加载。

        获取到了Resource对象也就等于获取到了该资源文件，后面可以根据方法的定义对文件进行相关操作。

System.out.println(resource.getURL());
System.out.println(resource.getFilename());
System.out.println(resource.getFile().getPath());
// ... ....