protected boolean acceptableName(String name) 
{
        if (isAccepted(name) && !isExcluded(name)) {
            return true;
        }
        return false;
}

 protected  void addParametersToContext(ActionContext ac,
    Map<String, Object> newParams) 
{

}

Adds the parameters into context's ParameterMap

 public String doIntercept(ActionInvocation invocation) throws Exception 
{
        Object action = invocation.getAction();
        if (!(action instanceof NoParameters)) {
            ActionContext ac = invocation.getInvocationContext();
            final Map< String, Object > parameters = retrieveParameters(ac);
            if (LOG.isDebugEnabled()) {
                LOG.debug("Setting params " + getParameterLogMap(parameters));
            }
            if (parameters != null) {
                Map< String, Object > 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<String> 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 isAccepted(String paramName) 
{
        if (!this.acceptParams.isEmpty()) {
            for (Pattern pattern : acceptParams) {
                Matcher matcher = pattern.matcher(paramName);
                if (matcher.matches()) {
                    return true;
                }
            }
            return false;
        } else
            return acceptedPattern.matcher(paramName).matches();
}

 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<String, Object> retrieveParameters(ActionContext ac) 
{
        return ac.getParameters();
}

Gets the parameter map to apply from wherever appropriate

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

 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<String, Object> parameters) 
{
        ParameterNameAware parameterNameAware = (action instanceof ParameterNameAware)
                ? (ParameterNameAware) action : null;
        Map< String, Object > params;
        Map< String, Object > acceptableParameters;
        if (ordered) {
            params = new TreeMap< String, Object >(getOrderedComparator());
            acceptableParameters = new TreeMap< String, Object >(getOrderedComparator());
            params.putAll(parameters);
        } else {
            params = new TreeMap< String, Object >(parameters);
            acceptableParameters = new TreeMap< String, Object >();
        }
        for (Map.Entry< String, Object > entry : params.entrySet()) {
            String name = entry.getKey();
            boolean acceptableName = acceptableName(name)
                    && (parameterNameAware == null
                    || parameterNameAware.acceptableParameterName(name));
            if (acceptableName) {
                acceptableParameters.put(name, entry.getValue());
            }
        }
        ValueStack newStack = valueStackFactory.createValueStack(stack);
        boolean clearableStack = newStack instanceof ClearableValueStack;
        if (clearableStack) {
            //if the stack's context can be cleared, do that to prevent OGNL
            //from having access to objects in the stack, see XW-641
            ((ClearableValueStack)newStack).clearContextValues();
            Map< String, Object > context = newStack.getContext();
            ReflectionContextState.setCreatingNullObjects(context, true);
            ReflectionContextState.setDenyMethodExecution(context, true);
            ReflectionContextState.setReportingConversionErrors(context, true);
            //keep locale from original context
            context.put(ActionContext.LOCALE, stack.getContext().get(ActionContext.LOCALE));
        }
        boolean memberAccessStack = newStack instanceof MemberAccessValueStack;
        if (memberAccessStack) {
            //block or allow access to properties
            //see WW-2761 for more details
            MemberAccessValueStack accessValueStack = (MemberAccessValueStack) newStack;
            accessValueStack.setAcceptProperties(acceptParams);
            accessValueStack.setExcludeProperties(excludeParams);
        }
        for (Map.Entry< String, Object > entry : acceptableParameters.entrySet()) {
            String name = entry.getKey();
            Object value = entry.getValue();
            try {
                newStack.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[]{
                             "Unexpected Exception caught setting '" + name + "' on '" + action.getClass() + ": " + e.getMessage()
                    });
                    LOG.error(developerNotification);
                    if (action instanceof ValidationAware) {
                        ((ValidationAware) action).addActionMessage(developerNotification);
                    }
                }
            }
        }
        if (clearableStack && (stack.getContext() != null) && (newStack.getContext() != null))
            stack.getContext().put(ActionContext.CONVERSION_ERRORS, newStack.getContext().get(ActionContext.CONVERSION_ERRORS));
        addParametersToContext(ActionContext.getContext(), acceptableParameters);
}

 public  void setValueStackFactory(ValueStackFactory valueStackFactory) 
{
        this.valueStackFactory = valueStackFactory;
}