org.springframework.context.ResourceLoaderAware Maven / Gradle / Ivy
/*
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.context;
import org.springframework.beans.factory.Aware;
import org.springframework.core.io.ResourceLoader;
/**
* Interface to be implemented by any object that wishes to be notified of the
* {@link ResourceLoader} (typically the ApplicationContext) that it runs in.
* This is an alternative to a full {@link ApplicationContext} dependency via
* the {@link org.springframework.context.ApplicationContextAware} interface.
*
* Note that {@link org.springframework.core.io.Resource} dependencies can also
* be exposed as bean properties of type {@code Resource}, populated via Strings
* with automatic type conversion by the bean factory. This removes the need for
* implementing any callback interface just for the purpose of accessing a
* specific file resource.
*
*
You typically need a {@link ResourceLoader} when your application object has to
* access a variety of file resources whose names are calculated. A good strategy is
* to make the object use a {@link org.springframework.core.io.DefaultResourceLoader}
* but still implement {@code ResourceLoaderAware} to allow for overriding when
* running in an {@code ApplicationContext}. See
* {@link org.springframework.context.support.ReloadableResourceBundleMessageSource}
* for an example.
*
*
A passed-in {@code ResourceLoader} can also be checked for the
* {@link org.springframework.core.io.support.ResourcePatternResolver} interface
* and cast accordingly, in order to resolve resource patterns into arrays of
* {@code Resource} objects. This will always work when running in an ApplicationContext
* (since the context interface extends the ResourcePatternResolver interface). Use a
* {@link org.springframework.core.io.support.PathMatchingResourcePatternResolver} as
* default; see also the {@code ResourcePatternUtils.getResourcePatternResolver} method.
*
*
As an alternative to a {@code ResourcePatternResolver} dependency, consider
* exposing bean properties of type {@code Resource} array, populated via pattern
* Strings with automatic type conversion by the bean factory at binding time.
*
* @author Juergen Hoeller
* @author Chris Beams
* @since 10.03.2004
* @see ApplicationContextAware
* @see org.springframework.core.io.Resource
* @see org.springframework.core.io.ResourceLoader
* @see org.springframework.core.io.support.ResourcePatternResolver
*/
public interface ResourceLoaderAware extends Aware {
/**
* Set the ResourceLoader that this object runs in.
*
This might be a ResourcePatternResolver, which can be checked
* through {@code instanceof ResourcePatternResolver}. See also the
* {@code ResourcePatternUtils.getResourcePatternResolver} method.
*
Invoked after population of normal bean properties but before an init callback
* like InitializingBean's {@code afterPropertiesSet} or a custom init-method.
* Invoked before ApplicationContextAware's {@code setApplicationContext}.
* @param resourceLoader the ResourceLoader object to be used by this object
* @see org.springframework.core.io.support.ResourcePatternResolver
* @see org.springframework.core.io.support.ResourcePatternUtils#getResourcePatternResolver
*/
void setResourceLoader(ResourceLoader resourceLoader);
}