protected boolean acceptableName(String name) 
{
        if (name.indexOf('=") != -1 || name.indexOf(',") != -1 || name.indexOf('#") != -1
                || name.indexOf(':") != -1 || isExcluded(name)) {
            return false;
        } else {
            return true;
        }
}

 public String doIntercept(ActionInvocation invocation) throws Exception 
{
    
        Object action = invocation.getAction();
        if (!(action instanceof NoParameters)) {
            ActionContext ac = invocation.getInvocationContext();
            final Map parameters = retrieveParametersFromContext(ac);
            if (LOG.isDebugEnabled()) {
                LOG.debug("Setting params " + getParameterLogMap(parameters));
            }
            if (parameters != null) {
            	Map contextMap = ac.getContextMap();
                try {
                	ReflectionContextState.setCreatingNullObjects(contextMap, true);
                	ReflectionContextState.setDenyMethodExecution(contextMap, true);
                	ReflectionContextState.setReportingConversionErrors(contextMap, true);
                    ValueStack stack = ac.getValueStack();
                    setParameters(action, stack, parameters);
                } finally {
                	ReflectionContextState.setCreatingNullObjects(contextMap, false);
                	ReflectionContextState.setDenyMethodExecution(contextMap, false);
                	ReflectionContextState.setReportingConversionErrors(contextMap, false);
                }
            }
        }
        return invocation.invoke();
}

 protected Set getExcludeParamsSet() 
{
        return excludeParams;
}

Gets a set of regular expressions of parameters to remove from the parameter map

 protected Comparator getOrderedComparator() 
{
        return rbCollator;
}

Gets an instance of the comparator to use for the ordered sorting. Override this method to customize the ordering of the parameters as they are set to the action.

 protected boolean isExcluded(String paramName) 
{
        if (!this.excludeParams.isEmpty()) {
            for (Pattern pattern : excludeParams) {
                Matcher matcher = pattern.matcher(paramName);
                if (matcher.matches()) {
                    return true;
                }
            }
        }
        return false;
}

 public boolean isOrdered() 
{
        return ordered;
}

Whether to order the parameters or not

 protected Map retrieveParametersFromContext(ActionContext ac) 
{
        return ac.getParameters();
}

Gets the parameter map to apply from the context

 public static  void setDevMode(String mode) 
{
        devMode = "true".equals(mode);
}

 public  void setExcludeParams(String commaDelim) 
{
        Collection< String > excludePatterns = asCollection(commaDelim);
        if (excludePatterns != null) {
            excludeParams = new HashSet< Pattern >();
            for (String pattern : excludePatterns) {
                excludeParams.add(Pattern.compile(pattern));
            }
        }
}

Sets a comma-delimited list of regular expressions to match parameters that should be removed from the parameter map.

 public  void setOrdered(boolean ordered) 
{
        this.ordered = ordered;
}

Set whether to order the parameters by object depth or not

 protected  void setParameters(Object action,
    ValueStack stack,
    Map parameters) 
{
        ParameterNameAware parameterNameAware = (action instanceof ParameterNameAware)
                ? (ParameterNameAware) action : null;
        Map params = null;
        if( ordered ) {
            params = new TreeMap(getOrderedComparator());
            params.putAll(parameters);
        } else {
            params = new TreeMap(parameters); 
        }
        for (Iterator iterator = params.entrySet().iterator(); iterator.hasNext();) {
            Map.Entry entry = (Map.Entry) iterator.next();
            String name = entry.getKey().toString();
            boolean acceptableName = acceptableName(name)
                    && (parameterNameAware == null
                    || parameterNameAware.acceptableParameterName(name));
            if (acceptableName) {
                Object value = entry.getValue();
                try {
                    stack.setValue(name, value);
                } catch (RuntimeException e) {
                    if (devMode) {
                        String developerNotification = LocalizedTextUtil.findText(ParametersInterceptor.class, "devmode.notification", ActionContext.getContext().getLocale(), "Developer Notification:\n{0}", new Object[]{
                                e.getMessage()
                        });
                        LOG.error(developerNotification);
                        if (action instanceof ValidationAware) {
                            ((ValidationAware) action).addActionMessage(developerNotification);
                        }
                    } else {
                        LOG.error("ParametersInterceptor - [setParameters]: Unexpected Exception caught setting '"+name+"' on '"+action.getClass()+": " + e.getMessage());
                    }
                }
            }
        }
}