The Spring Framework

## Uses of Interface
org.springframework.core.io.Resource

Packages that use Resource
org.springframework.beans.factory.parsing: Support infrastructure for bean definition parsing.
org.springframework.beans.factory.support: Classes supporting the `org.springframework.beans.factory` package.
org.springframework.beans.factory.xml: Contains an abstract XML-based `BeanFactory` implementation, including a standard "spring-beans" DTD.
org.springframework.cache.ehcache: Support classes for the open source cache EHCache, allowing to set up an EHCache CacheManager and Caches as beans in a Spring context.
org.springframework.context.support: Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
org.springframework.core.io: Generic abstraction for (file-based) resources, used throughout the framework.
org.springframework.core.io.support: Support classes for Spring's resource abstraction.
org.springframework.core.type.classreading: Core support package for type introspection through ASM-based class reading.
org.springframework.jdbc.support: Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
org.springframework.jmx.export.naming: Provides a strategy for ObjectName creation.
org.springframework.mail.javamail: JavaMail support for Spring's mail infrastructure.
org.springframework.orm.hibernate3: Package providing integration of Hibernate3 with Spring concepts.
org.springframework.orm.ibatis: Package providing integration of iBATIS Database Layer with Spring concepts.
org.springframework.orm.jdo: Package providing integration of JDO (Java Date Objects) with Spring concepts.
org.springframework.scheduling.quartz: Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scripting.support: Support classes for Spring's scripting package.
org.springframework.test.jdbc: Support classes for tests based on JDBC.
org.springframework.ui.freemarker: Support classes for setting up FreeMarker within a Spring application context.
org.springframework.ui.velocity: Support classes for setting up Velocity within a Spring application context.
org.springframework.web.context.support: Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
org.springframework.web.multipart.commons: MultipartResolver implementation for Jakarta Commons FileUpload.
org.springframework.web.portlet.context: Support for Spring's application context concept in a portlet environment, including ApplicationContext implementations and various utility classes.
org.springframework.web.servlet.view: Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.view.jasperreports: Support classes for the integration of JasperReports as Spring web view technology.
org.springframework.web.servlet.view.xslt: Support classes for XSLT, providing a View implementation for XSLT stylesheets.

Uses of Resource in org.springframework.beans.factory.parsing

Methods in org.springframework.beans.factory.parsing that return Resource
`Resource[]` `ImportDefinition.getActualResources()`
`Resource` `ReaderContext.getResource()`
`Resource` `Location.getResource()` Get the resource with which this location is associated.

Methods in org.springframework.beans.factory.parsing with parameters of type Resource
`Object` `SourceExtractor.extractSource(Object sourceCandidate, Resource definingResource)` Extract the source metadata from the candidate object supplied by the configuration parser.
`Object` `PassThroughSourceExtractor.extractSource(Object sourceCandidate, Resource definingResource)` Simply returns the supplied `sourceCandidate` as-is.
`Object` `NullSourceExtractor.extractSource(Object sourceCandidate, Resource definitionResource)` This implementation simply returns `null` for any input.
`void` `ReaderContext.fireImportProcessed(String importedResource, Resource[] actualResources, Object source)`

Constructors in org.springframework.beans.factory.parsing with parameters of type Resource
`ImportDefinition(String importedResource, Resource[] actualResources, Object source)` Create a new ImportDefinition.
`Location(Resource resource)` Create a new instance of the `Location` class.
`Location(Resource resource, Object source)` Create a new instance of the `Location` class.
`ReaderContext(Resource resource, ProblemReporter problemReporter, ReaderEventListener eventListener, SourceExtractor sourceExtractor)`

Uses of Resource in org.springframework.beans.factory.support

Methods in org.springframework.beans.factory.support that return Resource
`Resource` `AbstractBeanDefinition.getResource()` Return the resource that this bean definition came from.

Methods in org.springframework.beans.factory.support with parameters of type Resource
`int` `PropertiesBeanDefinitionReader.loadBeanDefinitions(Resource resource)` Load bean definitions from the specified properties file, using all property keys (i.e. not filtering by prefix).
`int` `BeanDefinitionReader.loadBeanDefinitions(Resource resource)` Load bean definitions from the specified resource.
`int` `BeanDefinitionReader.loadBeanDefinitions(Resource[] resources)` Load bean definitions from the specified resources.
`int` `AbstractBeanDefinitionReader.loadBeanDefinitions(Resource[] resources)`
`int` `PropertiesBeanDefinitionReader.loadBeanDefinitions(Resource resource, String prefix)` Load bean definitions from the specified properties file.
`void` `AbstractBeanDefinition.setResource(Resource resource)` Set the resource that this bean definition came from (for the purpose of showing context in case of errors).

Uses of Resource in org.springframework.beans.factory.xml

Methods in org.springframework.beans.factory.xml with parameters of type Resource
`protected XmlReaderContext` `XmlBeanDefinitionReader.createReaderContext(Resource resource)` Create the `XmlReaderContext` to pass over to the document reader.
`protected int` `XmlBeanDefinitionReader.detectValidationMode(Resource resource)` Detects which kind of validation to perform on the XML file identified by the supplied `Resource`.
`protected int` `XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource)` Actually load bean definitions from the specified XML file.
`protected int` `XmlBeanDefinitionReader.getValidationModeForResource(Resource resource)` Gets the validation mode for the specified `Resource`.
`int` `XmlBeanDefinitionReader.loadBeanDefinitions(Resource resource)` Load bean definitions from the specified XML file.
`int` `XmlBeanDefinitionParser.registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)` Deprecated. Parse bean definitions from the given DOM document, and register them with the given bean factory.
`int` `XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource)` Register the bean definitions contained in the given DOM document.

Constructors in org.springframework.beans.factory.xml with parameters of type Resource
`XmlBeanFactory(Resource resource)` Create a new XmlBeanFactory with the given resource, which must be parsable using DOM.
`XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)` Create a new XmlBeanFactory with the given input stream, which must be parsable using DOM.
`XmlReaderContext(Resource resource, ProblemReporter problemReporter, ReaderEventListener eventListener, SourceExtractor sourceExtractor, XmlBeanDefinitionReader reader, NamespaceHandlerResolver namespaceHandlerResolver)`

Uses of Resource in org.springframework.cache.ehcache

Methods in org.springframework.cache.ehcache with parameters of type Resource
`void` `EhCacheManagerFactoryBean.setConfigLocation(Resource configLocation)` Set the location of the EHCache config file.

Uses of Resource in org.springframework.context.support

Methods in org.springframework.context.support that return Resource
`protected Resource[]` `ClassPathXmlApplicationContext.getConfigResources()`
`protected Resource[]` `AbstractXmlApplicationContext.getConfigResources()` Return an array of Resource objects, referring to the XML bean definition files that this context should be built with.
`protected Resource` `ResourceMapFactoryBean.getResource(String location)` Fetch the Resource handle for the given location, prepeding the resource base path.
`Resource` `GenericApplicationContext.getResource(String location)` This implementation delegates to this context's ResourceLoader if set, falling back to the default superclass behavior else.
`protected Resource` `FileSystemXmlApplicationContext.getResourceByPath(String path)` Resolve resource paths as file system paths.
`Resource[]` `AbstractApplicationContext.getResources(String locationPattern)`
`Resource[]` `GenericApplicationContext.getResources(String locationPattern)` This implementation delegates to this context's ResourceLoader if it implements the ResourcePatternResolver interface, falling back to the default superclass behavior else.

Methods in org.springframework.context.support with parameters of type Resource
`protected Properties` `ReloadableResourceBundleMessageSource.loadProperties(Resource resource, String filename)` Load the properties from the given resource.

Uses of Resource in org.springframework.core.io

Subinterfaces of Resource in org.springframework.core.io
`interface` `ContextResource` Extended interface for a resource that is loaded from an enclosing 'context', e.g. from a `ServletContext` or a `PortletContext` but also from plain classpath paths or relative file system paths (specified without an explicit prefix, hence applying relative to the local `ResourceLoader`'s context).

Classes in org.springframework.core.io that implement Resource
`class` `AbstractResource` Convenience base class for `Resource` implementations, pre-implementing typical behavior.
`class` `ByteArrayResource` `Resource` implementation for a given byte array.
`class` `ClassPathResource` `Resource` implementation for class path resources.
`class` `DescriptiveResource` Simple `Resource` implementation that holds a resource description but does not point to an actually readable resource.
`class` `FileSystemResource` `Resource` implementation for `java.io.File` handles.
`class` `InputStreamResource` `Resource` implementation for a given InputStream.
`class` `UrlResource` `Resource` implementation for `java.net.URL` locators.

Methods in org.springframework.core.io that return Resource
`Resource` `UrlResource.createRelative(String relativePath)` This implementation creates a UrlResource, applying the given path relative to the path of the underlying URL of this resource descriptor.
`Resource` `Resource.createRelative(String relativePath)` Create a resource relative to this resource.
`Resource` `FileSystemResource.createRelative(String relativePath)` This implementation creates a FileSystemResource, applying the given path relative to the path of the underlying file of this resource descriptor.
`Resource` `ClassPathResource.createRelative(String relativePath)` This implementation creates a ClassPathResource, applying the given path relative to the path of the underlying resource of this descriptor.
`Resource` `AbstractResource.createRelative(String relativePath)` This implementation throws a FileNotFoundException, assuming that relative resources cannot be created for this resource.
`Resource` `ResourceLoader.getResource(String location)` Return a Resource handle for the specified resource.
`Resource` `DefaultResourceLoader.getResource(String location)`
`protected Resource` `FileSystemResourceLoader.getResourceByPath(String path)` Resolve resource paths as file system paths.
`protected Resource` `DefaultResourceLoader.getResourceByPath(String path)` Return a Resource handle for the resource at the given path.

Uses of Resource in org.springframework.core.io.support

Methods in org.springframework.core.io.support that return Resource
`protected Resource` `PathMatchingResourcePatternResolver.convertClassLoaderURL(URL url)` Convert the given URL as returned from the ClassLoader into a Resource object.
`protected Resource[]` `PathMatchingResourcePatternResolver.findAllClassPathResources(String location)` Find all class location resources with the given location via the ClassLoader.

`Resource`

`LocalizedResourceHelper.findLocalizedResource(String name, String extension, Locale locale)`
Find the most specific localized resource for the given name, extension and locale: The file will be searched with locations in the following order, similar to `java.util.ResourceBundle`'s search order: [name]_[language]_[country]_[variant][extension] [name]_[language]_[country][extension] [name]_[language][extension] [name][extension] If none of the specific files can be found, a resource descriptor for the default location will be returned.

`protected Resource[]` `PathMatchingResourcePatternResolver.findPathMatchingResources(String locationPattern)` Find all resources that match the given location pattern via the Ant-style PathMatcher.
`Resource` `EncodedResource.getResource()` Return the Resource held.
`Resource` `PathMatchingResourcePatternResolver.getResource(String location)`
`Resource[]` `PathMatchingResourcePatternResolver.getResources(String locationPattern)`
`Resource[]` `ResourcePatternResolver.getResources(String locationPattern)` Resolve the given location pattern into Resource objects.
`protected Resource` `PathMatchingResourcePatternResolver.resolveRootDirResource(Resource original)` Resolve the specified resource for path matching.

Methods in org.springframework.core.io.support with parameters of type Resource
`protected Set` `PathMatchingResourcePatternResolver.doFindPathMatchingFileResources(Resource rootDirResource, String subPattern)` Find all resources in the file system that match the given location pattern via the Ant-style PathMatcher.
`protected Set` `PathMatchingResourcePatternResolver.doFindPathMatchingJarResources(Resource rootDirResource, String subPattern)` Find all resources in jar files that match the given location pattern via the Ant-style PathMatcher.
`static void` `PropertiesLoaderUtils.fillProperties(Properties props, Resource resource)` Fill the given properties from the given resource.
`protected boolean` `PathMatchingResourcePatternResolver.isJarResource(Resource resource)` Return whether the given resource handle indicates a jar resource that the `doFindPathMatchingJarResources` method can handle.
`static Properties` `PropertiesLoaderUtils.loadProperties(Resource resource)` Load properties from the given resource.
`protected Resource` `PathMatchingResourcePatternResolver.resolveRootDirResource(Resource original)` Resolve the specified resource for path matching.
`void` `PropertiesLoaderSupport.setLocation(Resource location)` Set a location of a properties file to be loaded.
`void` `PropertiesLoaderSupport.setLocations(Resource[] locations)` Set locations of properties files to be loaded.

Constructors in org.springframework.core.io.support with parameters of type Resource
`EncodedResource(Resource resource)` Create a new EncodedResource for the given Resource, not specifying a specific encoding.
`EncodedResource(Resource resource, String encoding)` Create a new EncodedResource for the given Resource, using the specified encoding.

Uses of Resource in org.springframework.core.type.classreading

Methods in org.springframework.core.type.classreading with parameters of type Resource
`MetadataReader` `SimpleMetadataReaderFactory.getMetadataReader(Resource resource)`
`MetadataReader` `MetadataReaderFactory.getMetadataReader(Resource resource)` Obtain a MetadataReader for the given resource.
`MetadataReader` `CachingMetadataReaderFactory.getMetadataReader(Resource resource)`

Uses of Resource in org.springframework.jdbc.support

Methods in org.springframework.jdbc.support that return Resource
`protected Resource` `SQLErrorCodesFactory.loadResource(String path)` Load the given resource from the class path.

Uses of Resource in org.springframework.jmx.export.naming

Methods in org.springframework.jmx.export.naming with parameters of type Resource
`void` `KeyNamingStrategy.setMappingLocation(Resource location)` Set a location of a properties file to be loaded, containing object name mappings.
`void` `KeyNamingStrategy.setMappingLocations(Resource[] mappingLocations)` Set location of properties files to be loaded, containing object name mappings.

Uses of Resource in org.springframework.mail.javamail

Methods in org.springframework.mail.javamail with parameters of type Resource
`void` `MimeMessageHelper.addInline(String contentId, Resource resource)` Add an inline element to the MimeMessage, taking the content from a `org.springframework.core.io.Resource`.
`protected FileTypeMap` `ConfigurableMimeFileTypeMap.createFileTypeMap(Resource mappingLocation, String[] mappings)` Compile a FileTypeMap from the mappings in the given mapping file and the given mapping entries.
`void` `ConfigurableMimeFileTypeMap.setMappingLocation(Resource mappingLocation)` Specify the `Resource` from which mappings are loaded.

Uses of Resource in org.springframework.orm.hibernate3

Methods in org.springframework.orm.hibernate3 with parameters of type Resource
`void` `LocalSessionFactoryBean.setCacheableMappingLocations(Resource[] cacheableMappingLocations)` Set locations of cacheable Hibernate mapping files, for example as web app resource "/WEB-INF/mapping/example.hbm.xml".
`void` `LocalSessionFactoryBean.setConfigLocation(Resource configLocation)` Set the location of a single Hibernate XML config file, for example as classpath resource "classpath:hibernate.cfg.xml".
`void` `LocalSessionFactoryBean.setConfigLocations(Resource[] configLocations)` Set the locations of multiple Hibernate XML config files, for example as classpath resources "classpath:hibernate.cfg.xml,classpath:extension.cfg.xml".
`void` `LocalSessionFactoryBean.setMappingDirectoryLocations(Resource[] mappingDirectoryLocations)` Set locations of directories that contain Hibernate mapping resources, like "WEB-INF/mappings".
`void` `LocalSessionFactoryBean.setMappingJarLocations(Resource[] mappingJarLocations)` Set locations of jar files that contain Hibernate mapping resources, like "WEB-INF/lib/example.hbm.jar".
`void` `LocalSessionFactoryBean.setMappingLocations(Resource[] mappingLocations)` Set locations of Hibernate mapping files, for example as classpath resource "classpath:example.hbm.xml".

Uses of Resource in org.springframework.orm.ibatis

Methods in org.springframework.orm.ibatis with parameters of type Resource
`protected com.ibatis.sqlmap.client.SqlMapClient` `SqlMapClientFactoryBean.buildSqlMapClient(Resource[] configLocations, Resource[] mappingLocations, Properties properties)` Build a SqlMapClient instance based on the given standard configuration.
`protected com.ibatis.sqlmap.client.SqlMapClient` `SqlMapClientFactoryBean.buildSqlMapClient(Resource[] configLocations, Resource[] mappingLocations, Properties properties)` Build a SqlMapClient instance based on the given standard configuration.
`void` `SqlMapClientFactoryBean.setConfigLocation(Resource configLocation)` Set the location of the iBATIS SqlMapClient config file.
`void` `SqlMapClientFactoryBean.setConfigLocations(Resource[] configLocations)` Set multiple locations of iBATIS SqlMapClient config files that are going to be merged into one unified configuration at runtime.
`void` `SqlMapClientFactoryBean.setMappingLocations(Resource[] mappingLocations)` Set locations of iBATIS sql-map mapping files that are going to be merged into the SqlMapClient configuration at runtime.

Uses of Resource in org.springframework.orm.jdo

Methods in org.springframework.orm.jdo with parameters of type Resource
`void` `LocalPersistenceManagerFactoryBean.setConfigLocation(Resource configLocation)` Set the location of the JDO properties config file, for example as classpath resource "classpath:kodo.properties".

Uses of Resource in org.springframework.scheduling.quartz

Methods in org.springframework.scheduling.quartz with parameters of type Resource
`void` `SchedulerFactoryBean.setConfigLocation(Resource configLocation)` Set the location of the Quartz properties config file, for example as classpath resource "classpath:quartz.properties".

Uses of Resource in org.springframework.scripting.support

Methods in org.springframework.scripting.support that return Resource
`Resource` `ResourceScriptSource.getResource()` Return the `Resource` to load the script from.

Constructors in org.springframework.scripting.support with parameters of type Resource
`ResourceScriptSource(Resource resource)` Create a new ResourceScriptSource for the given resource.

Uses of Resource in org.springframework.test.jdbc

Methods in org.springframework.test.jdbc with parameters of type Resource
`static void` `SimpleJdbcTestUtils.executeSqlScript(SimpleJdbcTemplate simpleJdbcTemplate, Resource resource, boolean continueOnError)` Execute the given SQL script.

Uses of Resource in org.springframework.ui.freemarker

Methods in org.springframework.ui.freemarker with parameters of type Resource
`void` `FreeMarkerConfigurationFactory.setConfigLocation(Resource resource)` Set the location of the FreeMarker config file.

Uses of Resource in org.springframework.ui.velocity

Methods in org.springframework.ui.velocity with parameters of type Resource
`void` `VelocityEngineFactory.setConfigLocation(Resource configLocation)` Set the location of the Velocity config file.

Uses of Resource in org.springframework.web.context.support

Classes in org.springframework.web.context.support that implement Resource
`class` `ServletContextResource` `Resource` implementation for `ServletContext` resources, interpreting relative paths within the web application root directory.

Methods in org.springframework.web.context.support that return Resource
`Resource` `ServletContextResource.createRelative(String relativePath)` This implementation creates a ServletContextResource, applying the given path relative to the path of the underlying file of this resource descriptor.
`protected Resource` `StaticWebApplicationContext.getResourceByPath(String path)` This implementation supports file paths beneath the root of the ServletContext.
`protected Resource` `ServletContextResourceLoader.getResourceByPath(String path)` This implementation supports file paths beneath the root of the web application.
`protected Resource` `GenericWebApplicationContext.getResourceByPath(String path)` This implementation supports file paths beneath the root of the ServletContext.
`protected Resource` `AbstractRefreshableWebApplicationContext.getResourceByPath(String path)` This implementation supports file paths beneath the root of the ServletContext.

Methods in org.springframework.web.context.support with parameters of type Resource
`protected Set` `ServletContextResourcePatternResolver.doFindPathMatchingFileResources(Resource rootDirResource, String subPattern)` Overridden version which checks for ServletContextResource and uses `ServletContext.getResourcePaths` to find matching resources below the web application root directory.

Uses of Resource in org.springframework.web.multipart.commons

Methods in org.springframework.web.multipart.commons with parameters of type Resource
`void` `CommonsFileUploadSupport.setUploadTempDir(Resource uploadTempDir)` Set the temporary directory where uploaded files get stored.

Uses of Resource in org.springframework.web.portlet.context

Classes in org.springframework.web.portlet.context that implement Resource
`class` `PortletContextResource` `Resource` implementation for `PortletContext` resources, interpreting relative paths within the portlet application root directory.

Methods in org.springframework.web.portlet.context that return Resource
`Resource` `PortletContextResource.createRelative(String relativePath)`
`protected Resource` `StaticPortletApplicationContext.getResourceByPath(String path)` This implementation supports file paths beneath the root of the PortletContext.
`protected Resource` `PortletContextResourceLoader.getResourceByPath(String path)` This implementation supports file paths beneath the root of the web application.
`protected Resource` `AbstractRefreshablePortletApplicationContext.getResourceByPath(String path)` This implementation supports file paths beneath the root of the PortletContext.

Methods in org.springframework.web.portlet.context with parameters of type Resource
`protected Set` `PortletContextResourcePatternResolver.doFindPathMatchingFileResources(Resource rootDirResource, String subPattern)` Overridden version which checks for PortletContextResource and uses `PortletContext.getResourcePaths` to find matching resources below the web application root directory.

Uses of Resource in org.springframework.web.servlet.view

Methods in org.springframework.web.servlet.view with parameters of type Resource
`void` `XmlViewResolver.setLocation(Resource location)` Set the location of the XML file that defines the view beans.

Uses of Resource in org.springframework.web.servlet.view.jasperreports

Methods in org.springframework.web.servlet.view.jasperreports with parameters of type Resource
`protected net.sf.jasperreports.engine.JasperReport` `AbstractJasperReportsView.loadReport(Resource resource)` Loads a `JasperReport` from the specified `Resource`.

Uses of Resource in org.springframework.web.servlet.view.xslt

Methods in org.springframework.web.servlet.view.xslt that return Resource
`protected Resource` `AbstractXsltView.getStylesheetLocation()` Return the location of the XSLT stylesheet, if any.

Methods in org.springframework.web.servlet.view.xslt with parameters of type Resource
`protected Source` `AbstractXsltView.getStylesheetSource(Resource stylesheetLocation)` Load the stylesheet from the specified location.
`void` `AbstractXsltView.setStylesheetLocation(Resource stylesheetLocation)` Set the location of the XSLT stylesheet.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.