public class ContextLoader
extends java.lang.Object
ContextLoaderListener
.
Looks for a "contextClass"
parameter
at the web.xml
context-param level to specify the context
class type, falling back to the default of
XmlWebApplicationContext
if not found. With the default ContextLoader implementation, any context class
specified needs to implement the ConfigurableWebApplicationContext interface.
Processes a "contextConfigLocation"
context-param and passes its value to the context instance, parsing it into
potentially multiple file paths which can be separated by any number of
commas and spaces, e.g. "WEB-INF/applicationContext1.xml,
WEB-INF/applicationContext2.xml". Ant-style path patterns are supported as well,
e.g. "WEB-INF/*Context.xml,WEB-INF/spring*.xml" or "WEB-INF/**/*Context.xml".
If not explicitly specified, the context implementation is supposed to use a
default location (with XmlWebApplicationContext: "/WEB-INF/applicationContext.xml").
Note: In case of multiple config locations, later bean definitions will override ones defined in previously loaded files, at least when using one of Spring's default ApplicationContext implementations. This can be leveraged to deliberately override certain bean definitions via an extra XML file.
Above and beyond loading the root application context, this class
can optionally load or obtain and hook up a shared parent context to
the root application context. See the
loadParentContext(ServletContext)
method for more information.
As of Spring 3.1, ContextLoader
supports injecting the root web
application context via the ContextLoader(WebApplicationContext)
constructor, allowing for programmatic configuration in Servlet 3.0+ environments. See
WebApplicationInitializer
for usage examples.
ContextLoaderListener
,
ConfigurableWebApplicationContext
,
XmlWebApplicationContext
Modifier and Type | Field and Description |
---|---|
static java.lang.String |
CONFIG_LOCATION_PARAM
Name of servlet context parameter (i.e., "contextConfigLocation") that can specify the
config location for the root context, falling back to the implementation's
default otherwise.
|
private WebApplicationContext |
context
The root WebApplicationContext instance that this loader manages.
|
static java.lang.String |
CONTEXT_CLASS_PARAM
Config param for the root WebApplicationContext implementation class to use: "contextClass"
|
static java.lang.String |
CONTEXT_ID_PARAM
Config param for the root WebApplicationContext id,
to be used as serialization id for the underlying BeanFactory: "contextId"
|
static java.lang.String |
CONTEXT_INITIALIZER_CLASSES_PARAM
Config param for which
ApplicationContextInitializer classes to use
for initializing the web application context: "contextInitializerClasses" |
private static WebApplicationContext |
currentContext
The 'current' WebApplicationContext, if the ContextLoader class is
deployed in the web app ClassLoader itself.
|
private static java.util.Map<java.lang.ClassLoader,WebApplicationContext> |
currentContextPerThread
Map from (thread context) ClassLoader to corresponding 'current' WebApplicationContext.
|
private static java.lang.String |
DEFAULT_STRATEGIES_PATH
Name of the class path resource (relative to the ContextLoader class)
that defines ContextLoader's default strategy names.
|
private static java.util.Properties |
defaultStrategies |
static java.lang.String |
LOCATOR_FACTORY_KEY_PARAM
Optional servlet context parameter (i.e., "
parentContextKey ")
used only when obtaining a parent context using the default implementation
of loadParentContext(ServletContext servletContext) . |
static java.lang.String |
LOCATOR_FACTORY_SELECTOR_PARAM
Optional servlet context parameter (i.e., "
locatorFactorySelector ")
used only when obtaining a parent context using the default implementation
of loadParentContext(ServletContext servletContext) . |
private BeanFactoryReference |
parentContextRef
Holds BeanFactoryReference when loading parent factory via
ContextSingletonBeanFactoryLocator.
|
Constructor and Description |
---|
ContextLoader()
Create a new
ContextLoader that will create a web application context
based on the "contextClass" and "contextConfigLocation" servlet context-params. |
ContextLoader(WebApplicationContext context)
Create a new
ContextLoader with the given application context. |
Modifier and Type | Method and Description |
---|---|
void |
closeWebApplicationContext(ServletContext servletContext)
Close Spring's web application context for the given servlet context.
|
protected void |
configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac,
ServletContext sc) |
protected WebApplicationContext |
createWebApplicationContext(ServletContext sc)
Instantiate the root WebApplicationContext for this loader, either the
default context class or a custom context class if specified.
|
protected WebApplicationContext |
createWebApplicationContext(ServletContext sc,
ApplicationContext parent)
Deprecated.
as of Spring 3.1 in favor of
createWebApplicationContext(ServletContext) and
configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext, ServletContext) |
protected void |
customizeContext(ServletContext servletContext,
ConfigurableWebApplicationContext applicationContext)
Customize the
ConfigurableWebApplicationContext created by this
ContextLoader after config locations have been supplied to the context
but before the context is refreshed. |
protected java.lang.Class<?> |
determineContextClass(ServletContext servletContext)
Return the WebApplicationContext implementation class to use, either the
default XmlWebApplicationContext or a custom context class if specified.
|
protected java.util.List<java.lang.Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> |
determineContextInitializerClasses(ServletContext servletContext)
Return the
ApplicationContextInitializer implementation classes to use
if any have been specified by CONTEXT_INITIALIZER_CLASSES_PARAM . |
static WebApplicationContext |
getCurrentWebApplicationContext()
Obtain the Spring root web application context for the current thread
(i.e.
|
WebApplicationContext |
initWebApplicationContext(ServletContext servletContext)
Initialize Spring's web application context for the given servlet context,
using the application context provided at construction time, or creating a new one
according to the "
contextClass " and
"contextConfigLocation " context-params. |
protected ApplicationContext |
loadParentContext(ServletContext servletContext)
Template method with default implementation (which may be overridden by a
subclass), to load or obtain an ApplicationContext instance which will be
used as the parent context of the root WebApplicationContext.
|
public static final java.lang.String CONTEXT_CLASS_PARAM
public static final java.lang.String CONTEXT_ID_PARAM
public static final java.lang.String CONTEXT_INITIALIZER_CLASSES_PARAM
ApplicationContextInitializer
classes to use
for initializing the web application context: "contextInitializerClasses"public static final java.lang.String CONFIG_LOCATION_PARAM
public static final java.lang.String LOCATOR_FACTORY_SELECTOR_PARAM
locatorFactorySelector
")
used only when obtaining a parent context using the default implementation
of loadParentContext(ServletContext servletContext)
.
Specifies the 'selector' used in the
ContextSingletonBeanFactoryLocator.getInstance(String selector)
method call, which is used to obtain the BeanFactoryLocator instance from
which the parent context is obtained.
The default is classpath*:beanRefContext.xml
,
matching the default applied for the
ContextSingletonBeanFactoryLocator.getInstance()
method.
Supplying the "parentContextKey" parameter is sufficient in this case.
public static final java.lang.String LOCATOR_FACTORY_KEY_PARAM
parentContextKey
")
used only when obtaining a parent context using the default implementation
of loadParentContext(ServletContext servletContext)
.
Specifies the 'factoryKey' used in the
BeanFactoryLocator.useBeanFactory(String factoryKey)
method call,
obtaining the parent application context from the BeanFactoryLocator instance.
Supplying this "parentContextKey" parameter is sufficient when relying
on the default classpath*:beanRefContext.xml
selector for
candidate factory references.
private static final java.lang.String DEFAULT_STRATEGIES_PATH
private static final java.util.Properties defaultStrategies
private static final java.util.Map<java.lang.ClassLoader,WebApplicationContext> currentContextPerThread
private static volatile WebApplicationContext currentContext
private WebApplicationContext context
private BeanFactoryReference parentContextRef
public ContextLoader()
ContextLoader
that will create a web application context
based on the "contextClass" and "contextConfigLocation" servlet context-params.
See class-level documentation for details on default values for each.
This constructor is typically used when declaring the ContextLoaderListener
subclass as a <listener>
within web.xml
, as
a no-arg constructor is required.
The created application context will be registered into the ServletContext under
the attribute name WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
and subclasses are free to call the closeWebApplicationContext(ServletContext)
method on
container shutdown to close the application context.
public ContextLoader(WebApplicationContext context)
ContextLoader
with the given application context. This
constructor is useful in Servlet 3.0+ environments where instance-based
registration of listeners is possible through the ServletContext#addListener
API.
The context may or may not yet be refreshed. If it (a) is an implementation
of ConfigurableWebApplicationContext
and (b) has not
already been refreshed (the recommended approach), then the following will occur:
ServletContext
and ServletConfig
objects will be delegated to
the application contextcustomizeContext(ServletContext, org.springframework.web.context.ConfigurableWebApplicationContext)
will be calledApplicationContextInitializer
s specified through the
"contextInitializerClasses" init-param will be applied.refresh()
will be calledConfigurableWebApplicationContext
, none of the above will occur under the
assumption that the user has performed these actions (or not) per his or her
specific needs.
See WebApplicationInitializer
for usage examples.
In any case, the given application context will be registered into the
ServletContext under the attribute name WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
and subclasses are
free to call the closeWebApplicationContext(ServletContext)
method on container shutdown
to close the application context.
context
- the application context to manageinitWebApplicationContext(ServletContext)
,
closeWebApplicationContext(ServletContext)
public WebApplicationContext initWebApplicationContext(ServletContext servletContext)
contextClass
" and
"contextConfigLocation
" context-params.servletContext
- current servlet contextContextLoader(WebApplicationContext)
,
CONTEXT_CLASS_PARAM
,
CONFIG_LOCATION_PARAM
protected WebApplicationContext createWebApplicationContext(ServletContext sc)
This implementation expects custom contexts to implement the
ConfigurableWebApplicationContext
interface.
Can be overridden in subclasses.
In addition, customizeContext(ServletContext, org.springframework.web.context.ConfigurableWebApplicationContext)
gets called prior to refreshing the
context, allowing subclasses to perform custom modifications to the context.
sc
- current servlet contextConfigurableWebApplicationContext
@Deprecated protected WebApplicationContext createWebApplicationContext(ServletContext sc, ApplicationContext parent)
createWebApplicationContext(ServletContext)
and
configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext, ServletContext)
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc)
protected java.lang.Class<?> determineContextClass(ServletContext servletContext)
servletContext
- current servlet contextCONTEXT_CLASS_PARAM
,
XmlWebApplicationContext
protected java.util.List<java.lang.Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> determineContextInitializerClasses(ServletContext servletContext)
ApplicationContextInitializer
implementation classes to use
if any have been specified by CONTEXT_INITIALIZER_CLASSES_PARAM
.servletContext
- current servlet contextCONTEXT_INITIALIZER_CLASSES_PARAM
protected void customizeContext(ServletContext servletContext, ConfigurableWebApplicationContext applicationContext)
ConfigurableWebApplicationContext
created by this
ContextLoader after config locations have been supplied to the context
but before the context is refreshed.
The default implementation determines what (if any) context initializer classes have been specified through context init parameters and invokes each with the given web application context.
Any ApplicationContextInitializers
implementing
Ordered
or marked with @Order
will be sorted appropriately.
servletContext
- the current servlet contextapplicationContext
- the newly created application contextcreateWebApplicationContext(ServletContext, ApplicationContext)
,
CONTEXT_INITIALIZER_CLASSES_PARAM
,
ApplicationContextInitializer.initialize(ConfigurableApplicationContext)
protected ApplicationContext loadParentContext(ServletContext servletContext)
The main reason to load a parent context here is to allow multiple root web application contexts to all be children of a shared EAR context, or alternately to also share the same parent context that is visible to EJBs. For pure web applications, there is usually no need to worry about having a parent context to the root web application context.
The default implementation uses
ContextSingletonBeanFactoryLocator
,
configured via LOCATOR_FACTORY_SELECTOR_PARAM
and
LOCATOR_FACTORY_KEY_PARAM
, to load a parent context
which will be shared by all other users of ContextsingletonBeanFactoryLocator
which also use the same configuration parameters.
servletContext
- current servlet contextnull
if noneContextSingletonBeanFactoryLocator
public void closeWebApplicationContext(ServletContext servletContext)
loadParentContext(ServletContext)
implementation,
which uses ContextSingletonBeanFactoryLocator, has loaded any shared
parent context, release one reference to that shared parent context.
If overriding loadParentContext(ServletContext)
, you may have
to override this method as well.
servletContext
- the ServletContext that the WebApplicationContext runs inpublic static WebApplicationContext getCurrentWebApplicationContext()
null
if none foundSpringBeanAutowiringSupport