/*
* Copyright 2002-2008 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
*
* http://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.support;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationContextException;
/**
* Convenient superclass for application objects that want to be aware of
* the application context, e.g. for custom lookup of collaborating beans
* or for context-specific resource access. It saves the application
* context reference and provides an initialization callback method.
* Furthermore, it offers numerous convenience methods for message lookup.
*
* <p>There is no requirement to subclass this class: It just makes things
* a little easier if you need access to the context, e.g. for access to
* file resources or to the message source. Note that many application
* objects do not need to be aware of the application context at all,
* as they can receive collaborating beans via bean references.
*
* <p>Many framework classes are derived from this class, particularly
* within the web support.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see org.springframework.web.context.support.WebApplicationObjectSupport
*/
public abstract class ApplicationObjectSupport implements ApplicationContextAware {
/** Logger that is available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());
/** ApplicationContext this object runs in */
private ApplicationContext applicationContext;
/** MessageSourceAccessor for easy message access */
private MessageSourceAccessor messageSourceAccessor;
public final void setApplicationContext(ApplicationContext context) throws BeansException {
if (context == null && !isContextRequired()) {
// Reset internal context state.
this.applicationContext = null;
this.messageSourceAccessor = null;
}
else if (this.applicationContext == null) {
// Initialize with passed-in context.
if (!requiredContextClass().isInstance(context)) {
throw new ApplicationContextException(
"Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
}
this.applicationContext = context;
this.messageSourceAccessor = new MessageSourceAccessor(context);
initApplicationContext(context);
}
else {
// Ignore reinitialization if same context passed in.
if (this.applicationContext != context) {
throw new ApplicationContextException(
"Cannot reinitialize with different application context: current one is [" +
this.applicationContext + "], passed-in one is [" + context + "]");
}
}
}
/**
* Determine whether this application object needs to run in an ApplicationContext.
* <p>Default is "false". Can be overridden to enforce running in a context
* (i.e. to throw IllegalStateException on accessors if outside a context).
* @see #getApplicationContext
* @see #getMessageSourceAccessor
*/
protected boolean isContextRequired() {
return false;
}
/**
* Determine the context class that any context passed to
* <code>setApplicationContext</code> must be an instance of.
* Can be overridden in subclasses.
* @see #setApplicationContext
*/
protected Class requiredContextClass() {
return ApplicationContext.class;
}
/**
* Subclasses can override this for custom initialization behavior.
* Gets called by <code>setApplicationContext</code> after setting the context instance.
* <p>Note: Does </i>not</i> get called on reinitialization of the context
* but rather just on first initialization of this object's context reference.
* <p>The default implementation calls the overloaded {@link #initApplicationContext()}
* method without ApplicationContext reference.
* @param context the containing ApplicationContext
* @throws ApplicationContextException in case of initialization errors
* @throws BeansException if thrown by ApplicationContext methods
* @see #setApplicationContext
*/
protected void initApplicationContext(ApplicationContext context) throws BeansException {
initApplicationContext();
}
/**
* Subclasses can override this for custom initialization behavior.
* <p>The default implementation is empty. Called by
* {@link #initApplicationContext(org.springframework.context.ApplicationContext)}.
* @throws ApplicationContextException in case of initialization errors
* @throws BeansException if thrown by ApplicationContext methods
* @see #setApplicationContext
*/
protected void initApplicationContext() throws BeansException {
}
/**
* Return the ApplicationContext that this object is associated with.
* @throws IllegalStateException if not running in an ApplicationContext
*/
public final ApplicationContext getApplicationContext() throws IllegalStateException {
if (this.applicationContext == null && isContextRequired()) {
throw new IllegalStateException(
"ApplicationObjectSupport instance [" + this + "] does not run in an ApplicationContext");
}
return this.applicationContext;
}
/**
* Return a MessageSourceAccessor for the application context
* used by this object, for easy message access.
* @throws IllegalStateException if not running in an ApplicationContext
*/
protected final MessageSourceAccessor getMessageSourceAccessor() throws IllegalStateException {
if (this.messageSourceAccessor == null && isContextRequired()) {
throw new IllegalStateException(
"ApplicationObjectSupport instance [" + this + "] does not run in an ApplicationContext");
}
return this.messageSourceAccessor;
}
}