anchor.diff:  supports resolution as a `File` and as a `URL`.
   
   
  +
   [[resources-implementations-pathresource]]
   === `PathResource`
   
  
positive.code: 
  
  [[resources-implementations]]
  == Built-in Resource Implementations
  
  Spring includes several built-in `Resource` implementations, including but not limited to
  the following:
  
negative.code: 
  
  
  [[resources-resourcepatternresolver]]
  == The `ResourcePatternResolver` Interface
  
  The `ResourcePatternResolver` interface is an extension to the `ResourceLoader` interface
  which defines a strategy for resolving a location pattern (for example, an Ant-style path
  pattern) into  `Resource` objects.
  
  [source,java,indent=0,subs="verbatim,quotes",role="primary"]
  .Java
  ----
  	public interface ResourcePatternResolver extends ResourceLoader {
  
  		String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
  
  		Resource[] getResources(String locationPattern) throws IOException;
  
  	}
  ----
  [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
  .Kotlin
  ----
  	interface ResourcePatternResolver: ResourceLoader {
  
  		@JvmField
  		val CLASSPATH_ALL_URL_PREFIX: String = "classpath*:"
  
  		@Throws(IOException::class)
  		fun getResources(locationPattern: String): Resource[]
  
  	}
  ----
  
  As can be seen above, this interface also defines a special `classpath*:` resource prefix
  for all matching resources from the class path. Note that the resource location is
  expected to be a path without placeholders in this case -- for example,
  `classpath*:/config/beans.xml`. JAR files or different directories in the class path can
  contain multiple files with the same path and the same name. See
  <<resources-app-ctx-wildcards-in-resource-paths>> and its subsections for further details
  on wildcard support with the `classpath*:` resource prefix.
  
  A passed-in `ResourceLoader` (for example, one supplied via
  <<resources-resourceloaderaware, `ResourceLoaderAware`>> semantics can be checked whether
  it implements this extended interface too.
  
  `PathMatchingResourcePatternResolver` is a standalone implementation that is usable
  outside an `ApplicationContext` and is also used by `ResourceArrayPropertyEditor` for
  populating `Resource[]` bean properties.
  
  [NOTE]
  ====
  The default `ResourceLoader` in any standard `ApplicationContext` is in fact an instance
  of `PathMatchingResourcePatternResolver` which implements the `ResourcePatternResolver`
  interface. The same is true for the `ApplicationContext` instance itself which also
  implements the `ResourcePatternResolver` interface and delegates to the default
  `PathMatchingResourcePatternResolver`.
  ====
  
  
  [[resources-resourceloaderaware]]
  == The `ResourceLoaderAware` Interface
  
  The `ResourceLoaderAware` interface is a special callback interface which identifies
  components that expect to be provided a `ResourceLoader` reference. The following listing
  