com.sun.faces.config.processor.ApplicationConfigProcessor Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javax.faces Show documentation
Show all versions of javax.faces Show documentation
This is the master POM file for Oracle's Implementation of the JSF 2.2 Specification.
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.faces.config.processor;
import javax.naming.InitialContext;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.LinkedHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.el.ELResolver;
import javax.faces.application.Application;
import javax.faces.application.ConfigurableNavigationHandler;
import javax.faces.application.NavigationHandler;
import javax.faces.application.ResourceHandler;
import javax.faces.application.StateManager;
import javax.faces.application.ViewHandler;
import javax.faces.context.FacesContext;
import javax.faces.el.PropertyResolver;
import javax.faces.el.VariableResolver;
import javax.faces.event.ActionListener;
import javax.faces.event.SystemEventListener;
import javax.faces.event.SystemEvent;
import javax.faces.event.NamedEvent;
import javax.servlet.ServletContext;
import com.sun.faces.application.ApplicationAssociate;
import com.sun.faces.application.ApplicationResourceBundle;
import com.sun.faces.el.ChainAwareVariableResolver;
import com.sun.faces.el.DummyPropertyResolverImpl;
import com.sun.faces.util.FacesLogger;
import com.sun.faces.util.Util;
import com.sun.faces.config.ConfigurationException;
import com.sun.faces.config.WebConfiguration;
import com.sun.faces.config.DocumentInfo;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.faces.validator.BeanValidator;
import javax.validation.Validator;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.DisableFaceletJSFViewHandler;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.DisableFaceletJSFViewHandlerDeprecated;
import javax.naming.Context;
import javax.naming.NamingException;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Document;
/**
*
* This ConfigProcessor
handles all elements defined under
* /faces-config/application
.
*
*/
public class ApplicationConfigProcessor extends AbstractConfigProcessor {
private static final Logger LOGGER = FacesLogger.CONFIG.getLogger();
/**
* /faces-config/application
*/
private static final String APPLICATION =
"application";
/**
* /faces-config/application/action-listener
*/
private static final String ACTION_LISTENER
= "action-listener";
private List actionListeners;
/**
* /faces-config/application/default-render-kit-id
*/
private static final String DEFAULT_RENDERKIT_ID
= "default-render-kit-id";
/**
* /faces-config/application/default-validators
*/
private static final String DEFAULT_VALIDATORS
= "default-validators";
/**
* /faces-config/application/default-validators/validator-id
*/
private static final String VALIDATOR_ID
= "validator-id";
/**
* /faces-config/application/message-bundle
*/
private static final String MESSAGE_BUNDLE
= "message-bundle";
/**
* /faces-config/application/navigation-handler
*/
private static final String NAVIGATION_HANDLER
= "navigation-handler";
private List navigationHandlers;
/**
* /faces-config/application/view-handler
*/
private static final String VIEW_HANDLER
= "view-handler";
private List viewHandlers;
/**
* /faces-config/application/state-manager
*/
private static final String STATE_MANAGER
= "state-manager";
private List stateManagers;
/**
* /faces-config/application/resource-handler
*/
private static final String RESOURCE_HANDLER
= "resource-handler";
private List resourceHandlers;
/**
* /faces-config/application/el-resolver
*/
private static final String EL_RESOLVER
= "el-resolver";
private List elResolvers;
/**
* /faces-config/application/property-resolver
*/
private static final String PROPERTY_RESOLVER
= "property-resolver";
/**
* /faces-config/application/variable-resolver
*/
private static final String VARIABLE_RESOLVER
= "variable-resolver";
/**
* /faces-config/application/locale-config/default-locale
*/
private static final String DEFAULT_LOCALE
= "default-locale";
/**
* /faces-config/application/locale-config/supported-locale
*/
private static final String SUPPORTED_LOCALE
= "supported-locale";
/**
* /faces-config/application/resource-bundle
*/
private static final String RESOURCE_BUNDLE
= "resource-bundle";
/**
* /faces-config/application/resource-bundle/base-name
*/
private static final String BASE_NAME
= "base-name";
/**
* /faces-config/application/resource-bundle/var
*/
private static final String VAR
= "var";
/**
* /faces-config/application/resource-bundle/description
*/
private static final String RES_DESCRIPTIONS
= "description";
/**
* /faces-config/application/resource-bundle/display-name
*/
private static final String RES_DISPLAY_NAMES
= "display-name";
/**
* /faces-config/application/system-event-listener
*/
private static final String SYSTEM_EVENT_LISTENER
= "system-event-listener";
private List systemEventListeners;
/**
* /faces-config/application/system-event-listener/system-event-listener-class
*/
private static final String SYSTEM_EVENT_LISTENER_CLASS
= "system-event-listener-class";
/**
* /faces-config/application/system-event-listener/system-event-class
*/
private static final String SYSTEM_EVENT_CLASS
= "system-event-class";
/**
* /faces-config/application/system-event-listener/source-class
*/
private static final String SOURCE_CLASS
= "source-class";
public ApplicationConfigProcessor() {
actionListeners = new CopyOnWriteArrayList();
navigationHandlers = new CopyOnWriteArrayList();
viewHandlers = new CopyOnWriteArrayList();
stateManagers = new CopyOnWriteArrayList();
resourceHandlers = new CopyOnWriteArrayList();
elResolvers = new CopyOnWriteArrayList();
systemEventListeners = new CopyOnWriteArrayList();
}
// -------------------------------------------- Methods from ConfigProcessor
/**
* @see ConfigProcessor#process(javax.servlet.ServletContext,com.sun.faces.config.DocumentInfo[])
*/
public void process(ServletContext sc, DocumentInfo[] documentInfos)
throws Exception {
Application app = getApplication();
ApplicationAssociate associate =
ApplicationAssociate.getInstance(
FacesContext.getCurrentInstance().getExternalContext());
LinkedHashMap viewHandlers = new LinkedHashMap<>();
LinkedHashSet defaultValidatorIds = null;
for (int i = 0; i < documentInfos.length; i++) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format("Processing application elements for document: ''{0}''",
documentInfos[i].getSourceURI()));
}
Document document = documentInfos[i].getDocument();
String namespace =
document.getDocumentElement().getNamespaceURI();
NodeList applicationElements = document.getDocumentElement()
.getElementsByTagNameNS(namespace, APPLICATION);
if (applicationElements != null
&& applicationElements.getLength() > 0) {
for (int a = 0, asize = applicationElements.getLength();
a < asize;
a++) {
Node appElement = applicationElements.item(a);
NodeList children = ((Element) appElement)
.getElementsByTagNameNS(namespace, "*");
if (children != null && children.getLength() > 0) {
for (int c = 0, csize = children.getLength();
c < csize;
c++) {
Node n = children.item(c);
switch (n.getLocalName()) {
case MESSAGE_BUNDLE:
setMessageBundle(app, n);
break;
case DEFAULT_RENDERKIT_ID:
setDefaultRenderKitId(app, n);
break;
case ACTION_LISTENER:
addActionListener(sc, app, n);
break;
case NAVIGATION_HANDLER:
setNavigationHandler(sc, app, n);
break;
case VIEW_HANDLER:
String viewHandler = getNodeText(n);
if (viewHandler != null) {
viewHandlers.put(viewHandler, n);
} break;
case STATE_MANAGER:
setStateManager(sc, app, n);
break;
case EL_RESOLVER:
addELResolver(sc, associate, n);
break;
case PROPERTY_RESOLVER:
addPropertyResolver(sc, associate, n);
break;
case VARIABLE_RESOLVER:
addVariableResolver(sc, associate, n);
break;
case DEFAULT_LOCALE:
setDefaultLocale(app, n);
break;
case SUPPORTED_LOCALE:
addSupportedLocale(app, n);
break;
case RESOURCE_BUNDLE:
addResouceBundle(associate, n);
break;
case RESOURCE_HANDLER:
setResourceHandler(sc, app, n);
break;
case SYSTEM_EVENT_LISTENER:
addSystemEventListener(sc, app, n);
break;
case DEFAULT_VALIDATORS:
if (defaultValidatorIds == null) {
defaultValidatorIds = new LinkedHashSet<>();
} else {
defaultValidatorIds.clear();
} break;
case VALIDATOR_ID:
defaultValidatorIds.add(getNodeText(n));
break;
}
}
}
}
}
}
registerDefaultValidatorIds(app, defaultValidatorIds);
// perform any special processing for ViewHandlers...
processViewHandlers(sc, app, viewHandlers);
// process NamedEvent annotations, if any
processAnnotations(NamedEvent.class);
// continue processing...
invokeNext(sc, documentInfos);
}
@Override
public void destroy(ServletContext sc) {
destroyInstances(sc, actionListeners);
destroyInstances(sc, navigationHandlers);
destroyInstances(sc, stateManagers);
destroyInstances(sc, viewHandlers);
destroyInstances(sc, elResolvers);
destroyInstances(sc, resourceHandlers);
destroyInstances(sc, systemEventListeners);
destroyNext(sc);
}
private void destroyInstances(ServletContext sc, List instances) {
for (Object cur : instances) {
destroyInstance(sc, cur.getClass().getName(), cur);
}
instances.clear();
}
// --------------------------------------------------------- Private Methods
/**
* If defaultValidatorIds is null, then no <default-validators> element appeared in any configuration file.
* In that case, add javax.faces.Bean if Bean Validation is available. If the <default-validators> appeared
* at least once, don't add the default (and empty <default-validator> element disabled default validators)
*/
private void registerDefaultValidatorIds(Application application, LinkedHashSet defaultValidatorIds) {
if (defaultValidatorIds == null) {
defaultValidatorIds = new LinkedHashSet<>();
if (isBeanValidatorAvailable()) {
WebConfiguration webConfig = WebConfiguration.getInstance();
if (!webConfig.isOptionEnabled(WebConfiguration.BooleanWebContextInitParameter.DisableDefaultBeanValidator)) {
defaultValidatorIds.add(BeanValidator.VALIDATOR_ID);
}
}
}
for (String validatorId : defaultValidatorIds) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.addDefaultValidatorId({0})",
validatorId));
}
application.addDefaultValidatorId(validatorId);
}
}
static boolean isBeanValidatorAvailable() {
boolean result = false;
final String beansValidationAvailabilityCacheKey =
"javax.faces.BEANS_VALIDATION_AVAILABLE";
Map appMap = FacesContext.getCurrentInstance().getExternalContext().getApplicationMap();
if (appMap.containsKey(beansValidationAvailabilityCacheKey)) {
result = (Boolean) appMap.get(beansValidationAvailabilityCacheKey);
} else {
try {
Thread.currentThread().getContextClassLoader().loadClass("javax.validation.MessageInterpolator");
// Check if the Implementation is available.
Object cachedObject = appMap.get(BeanValidator.VALIDATOR_FACTORY_KEY);
if(cachedObject instanceof ValidatorFactory) {
result = true;
} else {
Context initialContext = null;
try {
initialContext = new InitialContext();
} catch (NoClassDefFoundError nde) {
// on google app engine InitialContext is forbidden to use and GAE throws NoClassDefFoundError
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, nde.toString(), nde);
}
} catch (NamingException ne) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, ne.toString(), ne);
}
}
try {
Object validatorFactory = initialContext.lookup("java:comp/ValidatorFactory");
if (null != validatorFactory) {
appMap.put(BeanValidator.VALIDATOR_FACTORY_KEY, validatorFactory);
result = true;
}
} catch (NamingException root) {
if (LOGGER.isLoggable(Level.FINE)) {
String msg = "Could not build a default Bean Validator factory: "
+ root.getMessage();
LOGGER.fine(msg);
}
}
if (!result) {
try {
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
appMap.put(BeanValidator.VALIDATOR_FACTORY_KEY, factory);
result = true;
} catch(Throwable throwable) {
}
}
}
} catch (Throwable t) { // CNFE or ValidationException or any other
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine("Unable to load Beans Validation");
}
}
appMap.put(beansValidationAvailabilityCacheKey, result);
}
return result;
}
private void setMessageBundle(Application application,
Node messageBundle) {
if (messageBundle != null) {
String bundle = getNodeText(messageBundle);
if (bundle != null) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.setMessageBundle({0})",
bundle));
}
application.setMessageBundle(bundle);
}
}
}
private void setDefaultRenderKitId(Application application,
Node defaultId) {
if (defaultId != null) {
String id = getNodeText(defaultId);
if (id != null) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.setDefaultRenderKitId({0})",
id));
}
application.setDefaultRenderKitId(id);
}
}
}
private void addActionListener(ServletContext sc, Application application,
Node actionListener) {
if (actionListener != null) {
String listener = getNodeText(actionListener);
if (listener != null) {
boolean [] didPerformInjection = { false };
ActionListener instance = (ActionListener) createInstance(sc, listener,
ActionListener.class,
application.getActionListener(),
actionListener, true, didPerformInjection);
if (instance != null) {
if (didPerformInjection[0]) {
actionListeners.add(instance);
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.setActionListeners({0})",
listener));
}
application
.setActionListener(instance);
}
}
}
}
private void setNavigationHandler(ServletContext sc, Application application,
Node navigationHandler) {
if (navigationHandler != null) {
String handler = getNodeText(navigationHandler);
if (handler != null) {
Class rootType = findRootType(sc, handler,
navigationHandler,
new Class[] {
ConfigurableNavigationHandler.class,
NavigationHandler.class
});
boolean [] didPerformInjection = { false };
NavigationHandler instance = (NavigationHandler) createInstance(sc, handler,
((rootType != null) ? rootType : NavigationHandler.class),
application.getNavigationHandler(),
navigationHandler, true, didPerformInjection);
if (instance != null) {
if (didPerformInjection[0]) {
navigationHandlers.add(instance);
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.setNavigationHandlers({0})",
handler));
}
application
.setNavigationHandler(instance);
}
}
}
}
private void setStateManager(ServletContext sc, Application application,
Node stateManager) {
if (stateManager != null) {
String manager = getNodeText(stateManager);
if (manager != null) {
boolean [] didPerformInjection = { false };
StateManager instance = (StateManager) createInstance(sc, manager,
StateManager.class,
application.getStateManager(),
stateManager, true, didPerformInjection);
if (instance != null) {
if (didPerformInjection[0]) {
stateManagers.add(instance);
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.setStateManagers({0})",
manager));
}
application.setStateManager(instance);
}
}
}
}
private void setViewHandler(ServletContext sc, Application application,
Node viewHandler) {
if (viewHandler != null) {
String handler = getNodeText(viewHandler);
if (handler != null) {
boolean [] didPerformInjection = { false };
ViewHandler instance = (ViewHandler) createInstance(sc, handler,
ViewHandler.class,
application.getViewHandler(),
viewHandler, true, didPerformInjection);
if (instance != null) {
if (didPerformInjection[0]) {
viewHandlers.add(instance);
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.setViewHandler({0})",
handler));
}
application.setViewHandler(instance);
}
}
}
}
private void addELResolver(ServletContext sc, ApplicationAssociate associate,
Node elResolver) {
if (elResolver != null) {
if (associate != null) {
List resolvers = associate
.getELResolversFromFacesConfig();
if (resolvers == null) {
//noinspection CollectionWithoutInitialCapacity
resolvers = new ArrayList<>();
associate.setELResolversFromFacesConfig(resolvers);
}
String elResolverClass = getNodeText(elResolver);
if (elResolverClass != null) {
boolean [] didPerformInjection = { false };
ELResolver elRes = (ELResolver) createInstance(sc, elResolverClass,
ELResolver.class,
null,
elResolver, true, didPerformInjection);
if (elRes != null) {
if (didPerformInjection[0]) {
elResolvers.add(elRes);
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Adding ''{0}'' to ELResolver chain",
elResolverClass));
}
resolvers.add(elRes);
}
}
}
}
}
@SuppressWarnings("deprecation")
private void addPropertyResolver(ServletContext sc, ApplicationAssociate associate,
Node propertyResolver) {
if (propertyResolver != null) {
if (associate != null) {
Object resolverImpl = associate.getLegacyPRChainHead();
if (resolverImpl == null) {
resolverImpl = new DummyPropertyResolverImpl();
}
String resolver = getNodeText(propertyResolver);
if (resolver != null) {
boolean [] didPerformInjection = { false };
resolverImpl = createInstance(sc, resolver,
PropertyResolver.class,
resolverImpl,
propertyResolver, false, didPerformInjection);
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Adding ''{0}'' to PropertyResolver chain",
resolverImpl));
}
}
if (resolverImpl != null) {
associate
.setLegacyPRChainHead((PropertyResolver) resolverImpl);
}
}
}
}
@SuppressWarnings("deprecation")
private void addVariableResolver(ServletContext sc, ApplicationAssociate associate,
Node variableResolver) {
if (variableResolver != null) {
if (associate != null) {
Object resolverImpl = associate.getLegacyVRChainHead();
if (resolverImpl == null) {
resolverImpl = new ChainAwareVariableResolver();
}
String resolver = getNodeText(variableResolver);
if (resolver != null) {
boolean [] didPerformInjection = { false };
resolverImpl = createInstance(sc, resolver,
VariableResolver.class,
resolverImpl,
variableResolver, false, didPerformInjection);
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Adding ''{0}'' to VariableResolver chain",
resolverImpl));
}
}
if (resolverImpl != null) {
associate
.setLegacyVRChainHead((VariableResolver) resolverImpl);
}
}
}
}
private void setDefaultLocale(Application application,
Node defaultLocale) {
if (defaultLocale != null) {
String defLocale = getNodeText(defaultLocale);
if (defLocale != null) {
Locale def = Util.getLocaleFromString(defLocale);
if (def != null) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Setting default Locale to ''{0}''",
defLocale));
}
application.setDefaultLocale(def);
}
}
}
}
private void addSupportedLocale(Application application,
Node supportedLocale) {
if (supportedLocale != null) {
Set sLocales = getCurrentLocales(application);
String locString = getNodeText(supportedLocale);
if (locString != null) {
Locale loc = Util.getLocaleFromString(locString);
if (loc != null) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Adding supported Locale ''{0}''",
locString));
}
sLocales.add(loc);
}
application.setSupportedLocales(sLocales);
}
}
}
private void addResouceBundle(ApplicationAssociate associate,
Node resourceBundle) {
if (resourceBundle != null) {
NodeList children = resourceBundle.getChildNodes();
if (children != null) {
String baseName = null;
String var = null;
List descriptions = null;
List displayNames = null;
for (int i = 0, size = children.getLength(); i < size; i++) {
Node n = children.item(i);
if (n.getNodeType() == Node.ELEMENT_NODE) {
switch (n.getLocalName()) {
case BASE_NAME:
baseName = getNodeText(n);
break;
case VAR:
var = getNodeText(n);
break;
case RES_DESCRIPTIONS:
if (descriptions == null) {
descriptions = new ArrayList<>(2);
} descriptions.add(n);
break;
case RES_DISPLAY_NAMES:
if (displayNames == null) {
displayNames = new ArrayList<>(2);
} displayNames.add(n);
break;
}
}
}
if ((baseName != null) && (var != null)) {
associate.addResourceBundle(var,
new ApplicationResourceBundle(
baseName,
getTextMap(displayNames),
getTextMap(descriptions)));
}
}
}
}
private Set getCurrentLocales(Application application) {
//noinspection CollectionWithoutInitialCapacity
Set supportedLocales = new HashSet<>();
for (Iterator i = application.getSupportedLocales();
i.hasNext();) {
supportedLocales.add(i.next());
}
return supportedLocales;
}
private void setResourceHandler(ServletContext sc, Application application, Node resourceHandler) {
if (resourceHandler != null) {
String handler = getNodeText(resourceHandler);
if (handler != null) {
boolean [] didPerformInjection = { false };
ResourceHandler instance = (ResourceHandler) createInstance(sc, handler,
ResourceHandler.class,
application.getResourceHandler(),
resourceHandler, true, didPerformInjection);
if (instance != null) {
if (didPerformInjection[0]) {
resourceHandlers.add(instance);
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
MessageFormat.format(
"Calling Application.setResourceHandler({0})",
handler));
}
application.setResourceHandler(instance);
}
}
}
}
private void addSystemEventListener(ServletContext sc, Application application,
Node systemEventListener) {
NodeList children = systemEventListener.getChildNodes();
String listenerClass = null;
String eventClass = null;
String sourceClass = null;
for (int j = 0, len = children.getLength(); j < len; j++) {
Node n = children.item(j);
if (n.getNodeType() == Node.ELEMENT_NODE) {
switch (n.getLocalName()) {
case SYSTEM_EVENT_LISTENER_CLASS:
listenerClass = getNodeText(n);
break;
case SYSTEM_EVENT_CLASS:
eventClass = getNodeText(n);
break;
case SOURCE_CLASS:
sourceClass = getNodeText(n);
break;
}
}
}
if (listenerClass != null) {
SystemEventListener selInstance = (SystemEventListener)
createInstance(sc, listenerClass,
SystemEventListener.class,
null,
systemEventListener);
if (selInstance != null) {
systemEventListeners.add(selInstance);
try {
// If there is an eventClass, use it, otherwise use
// SystemEvent.class
//noinspection unchecked
Class eventClazz;
if (eventClass != null) {
eventClazz = (Class) loadClass(sc, eventClass, this, null);
} else {
eventClazz = SystemEvent.class;
}
// If there is a sourceClass, use it, otherwise use null
Class sourceClazz =
(sourceClass != null && sourceClass.length() != 0)
? Util.loadClass(sourceClass, this.getClass())
: null;
application.subscribeToEvent(eventClazz,
sourceClazz,
selInstance);
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
"Subscribing for event {0} and source {1} using listener {2}",
new Object[]{
eventClazz.getName(),
((sourceClazz != null) ? sourceClazz
.getName() : "ANY"),
selInstance.getClass().getName()
});
}
} catch (ClassNotFoundException cnfe) {
throw new ConfigurationException(cnfe);
}
}
}
}
private void processViewHandlers(ServletContext sc, Application app,
LinkedHashMap viewHandlers) {
// take special action on the ViewHandlers that have been
// configured for the application. If any of the ViewHandlers
// is the FaceletViewHandler, don't install the 2.0
// FaceletViewHandler. Make the application behave as 1.2
// unless they use our ViewHandler
WebConfiguration webConfig = WebConfiguration.getInstance();
if (!webConfig.isOptionEnabled(DisableFaceletJSFViewHandler) &&
!webConfig.isOptionEnabled(DisableFaceletJSFViewHandlerDeprecated)) {
if (viewHandlers.containsKey("com.sun.facelets.FaceletViewHandler")) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING,
"jsf.application.legacy_facelet_viewhandler_detected",
"com.sun.facelets.FaceletViewHandler");
}
webConfig.overrideContextInitParameter(DisableFaceletJSFViewHandler, true);
}
}
for (Node n : viewHandlers.values()) {
setViewHandler(sc, app, n);
}
}
}