The Spring Framework

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

Packages that use ResourceLoader
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.beans.support: Classes supporting the org.springframework.beans package, such as utility classes for sorting and holding lists of beans.
org.springframework.context: This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
org.springframework.context.annotation: Annotation support for context configuration, including classpath scanning for autowire candidates.
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.jca.context: Integration package that allows for deploying a Spring application context as a JCA 1.5 compliant RAR file.
org.springframework.mock.web: A comprehensive set of Servlet API mock objects, targeted at usage with Spring's web MVC framework.
org.springframework.mock.web.portlet: A comprehensive set of Portlet API mock objects, targeted at usage with Spring's web MVC framework.
org.springframework.orm.jpa: Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.persistenceunit: Internal support for managing JPA persistence units.
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: Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web 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.portlet.context: Support for Spring's application context concept in a portlet environment, including ApplicationContext implementations and various utility classes.

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

Methods in org.springframework.beans.factory.support that return ResourceLoader
`ResourceLoader` `BeanDefinitionReader.getResourceLoader()` Return the resource loader to use for resource locations.
`ResourceLoader` `AbstractBeanDefinitionReader.getResourceLoader()`

Methods in org.springframework.beans.factory.support with parameters of type ResourceLoader
`void` `AbstractBeanDefinitionReader.setResourceLoader(ResourceLoader resourceLoader)` Set the ResourceLoader to use for resource locations.

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

Methods in org.springframework.beans.factory.xml that return ResourceLoader
`ResourceLoader` `XmlReaderContext.getResourceLoader()`

Constructors in org.springframework.beans.factory.xml with parameters of type ResourceLoader
`ResourceEntityResolver(ResourceLoader resourceLoader)` Create a ResourceEntityResolver for the specified ResourceLoader (usually, an ApplicationContext).

Uses of ResourceLoader in org.springframework.beans.support

Constructors in org.springframework.beans.support with parameters of type ResourceLoader
`ResourceEditorRegistrar(ResourceLoader resourceLoader)` Create a new ResourceEditorRegistrar for the given ResourceLoader

Uses of ResourceLoader in org.springframework.context

Subinterfaces of ResourceLoader in org.springframework.context
`interface` `ApplicationContext` Central interface to provide configuration for an application.
`interface` `ConfigurableApplicationContext` SPI interface to be implemented by most if not all application contexts.

Methods in org.springframework.context with parameters of type ResourceLoader
`void` `ResourceLoaderAware.setResourceLoader(ResourceLoader resourceLoader)` Set the ResourceLoader that this object runs in.

Uses of ResourceLoader in org.springframework.context.annotation

Methods in org.springframework.context.annotation that return ResourceLoader
`ResourceLoader` `ClassPathScanningCandidateComponentProvider.getResourceLoader()` Return the ResourceLoader that this component provider uses.

Methods in org.springframework.context.annotation with parameters of type ResourceLoader
`void` `ClassPathScanningCandidateComponentProvider.setResourceLoader(ResourceLoader resourceLoader)` Set the ResourceLoader to use for resource locations.

Uses of ResourceLoader in org.springframework.context.support

Classes in org.springframework.context.support that implement ResourceLoader
`class` `AbstractApplicationContext` Abstract implementation of the `ApplicationContext` interface.
`class` `AbstractRefreshableApplicationContext` Base class for `ApplicationContext` implementations which are supposed to support multiple refreshs, creating a new internal bean factory instance every time.
`class` `AbstractRefreshableConfigApplicationContext` `AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
`class` `AbstractXmlApplicationContext` Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
`class` `ClassPathXmlApplicationContext` Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.
`class` `FileSystemXmlApplicationContext` Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.
`class` `GenericApplicationContext` Generic ApplicationContext implementation that holds a single internal `DefaultListableBeanFactory` instance and does not assume a specific bean definition format.
`class` `StaticApplicationContext` `ApplicationContext` implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.

Methods in org.springframework.context.support with parameters of type ResourceLoader
`void` `ResourceMapFactoryBean.setResourceLoader(ResourceLoader resourceLoader)`
`void` `ReloadableResourceBundleMessageSource.setResourceLoader(ResourceLoader resourceLoader)` Set the ResourceLoader to use for loading bundle properties files.
`void` `GenericApplicationContext.setResourceLoader(ResourceLoader resourceLoader)` Set a ResourceLoader to use for this context.

Uses of ResourceLoader in org.springframework.core.io

Classes in org.springframework.core.io that implement ResourceLoader
`class` `DefaultResourceLoader` Default implementation of the `ResourceLoader` interface.
`class` `FileSystemResourceLoader` `ResourceLoader` implementation that resolves plain paths as file system resources rather than as class path resources (the latter is `DefaultResourceLoader`'s default strategy).

Constructors in org.springframework.core.io with parameters of type ResourceLoader
`ResourceEditor(ResourceLoader resourceLoader)` Create a new instance of the `ResourceEditor` class using the given `ResourceLoader`.

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

Subinterfaces of ResourceLoader in org.springframework.core.io.support
`interface` `ResourcePatternResolver` Strategy interface for resolving a location pattern (for example, an Ant-style path pattern) into Resource objects.

Classes in org.springframework.core.io.support that implement ResourceLoader
`class` `PathMatchingResourcePatternResolver` A `ResourcePatternResolver` implementation that is able to resolve a specified resource location path into one or more matching Resources.

Methods in org.springframework.core.io.support that return ResourceLoader
`ResourceLoader` `PathMatchingResourcePatternResolver.getResourceLoader()` Return the ResourceLoader that this pattern resolver works with.

Methods in org.springframework.core.io.support with parameters of type ResourceLoader
`static ResourcePatternResolver` `ResourcePatternUtils.getResourcePatternResolver(ResourceLoader resourceLoader)` Return a default ResourcePatternResolver for the given ResourceLoader.

Constructors in org.springframework.core.io.support with parameters of type ResourceLoader
`LocalizedResourceHelper(ResourceLoader resourceLoader)` Create a new LocalizedResourceHelper with the given ResourceLoader.
`PathMatchingResourcePatternResolver(ResourceLoader resourceLoader)` Create a new PathMatchingResourcePatternResolver.

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

Constructors in org.springframework.core.type.classreading with parameters of type ResourceLoader
`CachingMetadataReaderFactory(ResourceLoader resourceLoader)` Create a new CachingMetadataReaderFactory for the given resource loader.
`SimpleMetadataReaderFactory(ResourceLoader resourceLoader)` Create a new SimpleMetadataReaderFactory for the given resource loader.

Uses of ResourceLoader in org.springframework.jca.context

Classes in org.springframework.jca.context that implement ResourceLoader
`class` `ResourceAdapterApplicationContext` `ApplicationContext` implementation for a JCA ResourceAdapter.

Uses of ResourceLoader in org.springframework.mock.web

Constructors in org.springframework.mock.web with parameters of type ResourceLoader
`MockServletContext(ResourceLoader resourceLoader)` Create a new MockServletContext, using the specified ResourceLoader and no base path.
`MockServletContext(String resourceBasePath, ResourceLoader resourceLoader)` Create a new MockServletContext.

Uses of ResourceLoader in org.springframework.mock.web.portlet

Constructors in org.springframework.mock.web.portlet with parameters of type ResourceLoader
`MockPortletContext(ResourceLoader resourceLoader)` Create a new MockPortletContext, using the specified ResourceLoader and no base path.
`MockPortletContext(String resourceBasePath, ResourceLoader resourceLoader)` Create a new MockPortletContext.

Uses of ResourceLoader in org.springframework.orm.jpa

Methods in org.springframework.orm.jpa with parameters of type ResourceLoader
`void` `LocalContainerEntityManagerFactoryBean.setResourceLoader(ResourceLoader resourceLoader)`

Uses of ResourceLoader in org.springframework.orm.jpa.persistenceunit

Methods in org.springframework.orm.jpa.persistenceunit with parameters of type ResourceLoader
`void` `DefaultPersistenceUnitManager.setResourceLoader(ResourceLoader resourceLoader)`

Uses of ResourceLoader in org.springframework.scheduling.quartz

Methods in org.springframework.scheduling.quartz that return ResourceLoader
`static ResourceLoader` `SchedulerFactoryBean.getConfigTimeResourceLoader()` Return the ResourceLoader for the currently configured Quartz Scheduler, to be used by ResourceLoaderClassLoadHelper.

Methods in org.springframework.scheduling.quartz with parameters of type ResourceLoader
`void` `SchedulerFactoryBean.setResourceLoader(ResourceLoader resourceLoader)`

Constructors in org.springframework.scheduling.quartz with parameters of type ResourceLoader
`ResourceLoaderClassLoadHelper(ResourceLoader resourceLoader)` Create a new ResourceLoaderClassLoadHelper for the given ResourceLoader.

Uses of ResourceLoader in org.springframework.scripting.support

Methods in org.springframework.scripting.support with parameters of type ResourceLoader
`protected ScriptSource` `ScriptFactoryPostProcessor.convertToScriptSource(String beanName, String scriptSourceLocator, ResourceLoader resourceLoader)` Convert the given script source locator to a ScriptSource instance.
`void` `ScriptFactoryPostProcessor.setResourceLoader(ResourceLoader resourceLoader)`

Uses of ResourceLoader in org.springframework.test.jdbc

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

Uses of ResourceLoader in org.springframework.ui.freemarker

Methods in org.springframework.ui.freemarker that return ResourceLoader
`protected ResourceLoader` `FreeMarkerConfigurationFactory.getResourceLoader()` Return the Spring ResourceLoader to use for loading FreeMarker template files.

Methods in org.springframework.ui.freemarker with parameters of type ResourceLoader
`void` `FreeMarkerConfigurationFactory.setResourceLoader(ResourceLoader resourceLoader)` Set the Spring ResourceLoader to use for loading FreeMarker template files.

Constructors in org.springframework.ui.freemarker with parameters of type ResourceLoader
`SpringTemplateLoader(ResourceLoader resourceLoader, String templateLoaderPath)` Create a new SpringTemplateLoader.

Uses of ResourceLoader in org.springframework.ui.velocity

Methods in org.springframework.ui.velocity that return ResourceLoader
`protected ResourceLoader` `VelocityEngineFactory.getResourceLoader()` Return the Spring ResourceLoader to use for loading Velocity template files.

Methods in org.springframework.ui.velocity with parameters of type ResourceLoader
`void` `VelocityEngineFactory.setResourceLoader(ResourceLoader resourceLoader)` Set the Spring ResourceLoader to use for loading Velocity template files.

Uses of ResourceLoader in org.springframework.web.context

Subinterfaces of ResourceLoader in org.springframework.web.context
`interface` `ConfigurableWebApplicationContext` Interface to be implemented by configurable web application contexts.
`interface` `WebApplicationContext` Interface to provide configuration for a web application.

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

Classes in org.springframework.web.context.support that implement ResourceLoader
`class` `AbstractRefreshableWebApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
`class` `GenericWebApplicationContext` Subclass of `GenericApplicationContext`, suitable for web environments.
`class` `ServletContextResourceLoader` ResourceLoader implementation that resolves paths as ServletContext resources, for use outside a WebApplicationContext (for example, in a HttpServletBean or GenericFilterBean subclass).
`class` `ServletContextResourcePatternResolver` ServletContext-aware subclass of `PathMatchingResourcePatternResolver`, able to find matching resources below the web application root directory via Servlet 2.3's `ServletContext.getResourcePaths`.
`class` `StaticWebApplicationContext` Static `WebApplicationContext` implementation for testing.
`class` `XmlWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Constructors in org.springframework.web.context.support with parameters of type ResourceLoader
`ServletContextResourcePatternResolver(ResourceLoader resourceLoader)` Create a new ServletContextResourcePatternResolver.

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

Subinterfaces of ResourceLoader in org.springframework.web.portlet.context
`interface` `ConfigurablePortletApplicationContext` Interface to be implemented by configurable portlet application contexts.

Classes in org.springframework.web.portlet.context that implement ResourceLoader
`class` `AbstractRefreshablePortletApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurablePortletApplicationContext` interface for portlet environments.
`class` `PortletContextResourceLoader` ResourceLoader implementation that resolves paths as PortletContext resources, for use outside a Portlet ApplicationContext (for example, in a GenericPortletBean subclass).
`class` `PortletContextResourcePatternResolver` PortletContext-aware subclass of `PathMatchingResourcePatternResolver`, able to find matching resources below the web application root directory via Portlet API's `PortletContext.getResourcePaths`.
`class` `StaticPortletApplicationContext` Static Portlet-based `ApplicationContext` implementation for testing.
`class` `XmlPortletApplicationContext` Portlet-based `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Constructors in org.springframework.web.portlet.context with parameters of type ResourceLoader
`PortletContextResourcePatternResolver(ResourceLoader resourceLoader)` Create a new PortletContextResourcePatternResolver.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.