/*
* $Id: MethodConfigurationProvider.java 502296 2007-02-01 17:33:39Z niallp $
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.struts2.config;
import com.opensymphony.xwork2.config.ConfigurationProvider;
import com.opensymphony.xwork2.config.Configuration;
import com.opensymphony.xwork2.config.ConfigurationException;
import com.opensymphony.xwork2.config.RuntimeConfiguration;
import com.opensymphony.xwork2.config.entities.ActionConfig;
import com.opensymphony.xwork2.config.entities.PackageConfig;
import com.opensymphony.xwork2.inject.ContainerBuilder;
import com.opensymphony.xwork2.util.location.LocatableProperties;
import com.opensymphony.xwork2.ObjectFactory;
import java.util.*;
import java.lang.reflect.Method;
/**
* MethodConfigurationProvider creates ActionConfigs for potential action
* methods that lack a corresponding action mapping,
* so that these methods can be invoked without extra or redundant configuration.
* <p/>
* As a dynamic method, the behavior of this class could be represented as:
* <p/>
* <code>
* int bang = name.indexOf('!');
* if (bang != -1) {
* String method = name.substring(bang + 1);
* mapping.setMethod(method);
* name = name.substring(0, bang);
* }
* </code>
* <p/>
* If the action URL is "foo!bar", the the "foo" action is invoked,
* calling "bar" instead of "execute".
* <p/>
* Instead of scanning each request at runtime, the provider creates action mappings
* for each method that could be matched using a dynamic approach.
* Advantages over a dynamic approach are that:
* <p/>
* <ul>
* <ol>The "dynamic" methods are not a special case, but just another action mapping,
* with all the features of a hardcoded mapping.
* <ol>When needed, a manual action can be provided for a method and invoked with the same
* syntax as an automatic action.
* <ol>The ConfigBrowser can display all potential actions.
* </ul>
*/
public class MethodConfigurationProvider implements ConfigurationProvider {
/**
* Stores configuration property.
*/
private Configuration configuration;
/**
* Updates configuration property.
* @param configuration New configuration
*/
public void setConfiguration(Configuration configuration) {
this.configuration = configuration;
}
// See superclass for Javadoc
public void destroy() {
// Override to provide functionality
}
// See superclass for Javadoc
public void init(Configuration configuration) throws ConfigurationException {
setConfiguration(configuration);
configuration.rebuildRuntimeConfiguration();
}
// See superclass for Javadoc
public void register(ContainerBuilder containerBuilder, LocatableProperties locatableProperties) throws ConfigurationException {
// Override to provide functionality
}
// See superclass for Javadoc
public void loadPackages() throws ConfigurationException {
Set namespaces = Collections.EMPTY_SET;
RuntimeConfiguration rc = configuration.getRuntimeConfiguration();
Map allActionConfigs = rc.getActionConfigs();
if (allActionConfigs != null) {
namespaces = allActionConfigs.keySet();
}
if (namespaces.size() == 0) {
throw new ConfigurationException("MethodConfigurationProvider.loadPackages: namespaces.size == 0");
}
boolean added = false;
for (Object namespace : namespaces) {
Map actions = (Map) allActionConfigs.get(namespace);
Set actionNames = actions.keySet();
for (Object actionName : actionNames) {
ActionConfig actionConfig = (ActionConfig) actions.get(actionName);
added = added | addDynamicMethods(actions, (String) actionName, actionConfig);
}
}
reload = added;
}
/**
* Store needsReload property.
*/
boolean reload;
// See superclass for Javadoc
public boolean needsReload() {
return reload;
}
/**
* Stores ObjectFactory property.
*/
ObjectFactory factory;
/**
* Updates ObjectFactory property.
* @param factory
*/
public void setObjectFactory(ObjectFactory factory) {
this.factory = factory;
}
/**
* Provides ObjectFactory property.
* @return
* @throws ConfigurationException if ObjectFactory has not been set.
*/
private ObjectFactory getObjectFactory() throws ConfigurationException {
if (factory == null) {
factory = ObjectFactory.getObjectFactory();
if (factory == null) throw new
ConfigurationException("MethodConfigurationProvider.getObjectFactory: ObjectFactory==null");
}
return factory;
}
/**
* Verifies that character at a String position is upper case.
* @param pos Position to test
* @param string Text containing position
* @return True if character at a String position is upper case
*/
private boolean upperAt(int pos, String string) {
int len = string.length();
if (len < pos) return false;
String ch = string.substring(pos, pos+1);
return ch.equals(ch.toUpperCase());
}
/**
* Scans class for potential Action mehods,
* automatically generating and registering ActionConfigs as needed.
* <p/>
* The system iterates over the set of namespaces and the set of actionNames
* in a Configuration and retrieves each ActionConfig.
* For each ActionConfig that invokes the default "execute" method,
* the provider inspects the className class for other non-void,
* no-argument methods that do not begin with "getX" or "isX".
* For each qualifying method, the provider looks for another actionName in
* the same namespace that equals action.name + "!" + method.name.
* If that actionName is not found, System copies the ActionConfig,
* changes the method property, and adds it to the package configuration
* under the new actionName (action!method).
* <p/>
* The system ignores ActionConfigs with a method property set so as to
* avoid creating alias methods for alias methods.
* The system ignores "getX" and "isX" methods since these would appear to be
* JavaBeans property and would not be intended as action methods.
* (The X represents any upper character or non-letter.)
* @param actions All ActionConfigs in namespace
* @param actionName Name of ActionConfig to analyze
* @param actionConfig ActionConfig corresponding to actionName
*/
protected boolean addDynamicMethods(Map actions, String actionName, ActionConfig actionConfig) throws ConfigurationException {
String configMethod = actionConfig.getMethodName();
boolean hasMethod = (configMethod != null) && (configMethod.length() > 0);
if (hasMethod) return false;
String className = actionConfig.getClassName();
Set actionMethods = new HashSet();
Class actionClass;
ObjectFactory factory = getObjectFactory();
try {
actionClass = factory.getClassInstance(className);
} catch (ClassNotFoundException e) {
throw new ConfigurationException(e);
}
Method[] methods = actionClass.getMethods();
for (Method method : methods) {
String returnString = method.getReturnType().getName();
boolean isString = "java.lang.String".equals(returnString);
if (isString) {
Class[] parameterTypes = method.getParameterTypes();
boolean noParameters = (parameterTypes.length == 0);
String methodString = method.getName();
boolean notGetMethod = !((methodString.startsWith("get")) && upperAt(3, methodString));
boolean notIsMethod = !((methodString.startsWith("is")) && upperAt(2, methodString));
boolean notToString = !("toString".equals(methodString));
boolean notExecute = !("execute".equals(methodString));
boolean qualifies = noParameters && notGetMethod && notIsMethod && notToString && notExecute;
if (qualifies) {
actionMethods.add(methodString);
}
}
}
for (Object actionMethod : actionMethods) {
String methodName = (String) actionMethod;
StringBuilder sb = new StringBuilder();
sb.append(actionName);
sb.append("!"); // TODO: Make "!" a configurable character
sb.append(methodName);
String newActionName = sb.toString();
boolean haveAction = actions.containsKey(newActionName);
if (haveAction) continue;
ActionConfig newActionConfig = new ActionConfig(
newActionName,
actionConfig.getClassName(),
actionConfig.getParams(),
actionConfig.getResults(),
actionConfig.getInterceptors(),
actionConfig.getExceptionMappings());
newActionConfig.setMethodName(methodName);
String packageName = actionConfig.getPackageName();
newActionConfig.setPackageName(packageName);
PackageConfig packageConfig = configuration.getPackageConfig(packageName);
packageConfig.addActionConfig(newActionName, actionConfig);
}
return (actionMethods.size() > 0);
}
}
|
