public DefaultActionInvocation(Map<String, Object> extraContext,
    boolean pushAction) 
{
        DefaultActionInvocation.this.extraContext = extraContext;
        DefaultActionInvocation.this.pushAction = pushAction;
}

 public  void addPreResultListener(PreResultListener listener) 
{
        if (preResultListeners == null) {
            preResultListeners = new ArrayList< PreResultListener >(1);
        }
        preResultListeners.add(listener);
}

Register a com.opensymphony.xwork2.interceptor.PreResultListener to be notified after the Action is executed and before the Result is executed. The ActionInvocation implementation must guarantee that listeners will be called in the order in which they are registered. Listener registration and execution does not need to be thread-safe.

 protected  void createAction(Map<String, Object> contextMap) 
{
        // load action
        String timerKey = "actionCreate: " + proxy.getActionName();
        try {
            UtilTimerStack.push(timerKey);
            action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
        } catch (InstantiationException e) {
            throw new XWorkException("Unable to intantiate Action!", e, proxy.getConfig());
        } catch (IllegalAccessException e) {
            throw new XWorkException("Illegal access to constructor, is it public?", e, proxy.getConfig());
        } catch (Exception e) {
            String gripe = "";
            if (proxy == null) {
                gripe = "Whoa!  No ActionProxy instance found in current ActionInvocation.  This is bad ... very bad";
            } else if (proxy.getConfig() == null) {
                gripe = "Sheesh.  Where'd that ActionProxy get to?  I can't find it in the current ActionInvocation!?";
            } else if (proxy.getConfig().getClassName() == null) {
                gripe = "No Action defined for '" + proxy.getActionName() + "' in namespace '" + proxy.getNamespace() + "'";
            } else {
                gripe = "Unable to instantiate Action, " + proxy.getConfig().getClassName() + ",  defined for '" + proxy.getActionName() + "' in namespace '" + proxy.getNamespace() + "'";
            }
            gripe += (((" -- " + e.getMessage()) != null) ? e.getMessage() : " [no message in exception]");
            throw new XWorkException(gripe, e, proxy.getConfig());
        } finally {
            UtilTimerStack.pop(timerKey);
        }
        if (actionEventListener != null) {
            action = actionEventListener.prepare(action, stack);
        }
}

 protected Map<String, Object> createContextMap() 
{
        Map< String, Object > contextMap;
        if ((extraContext != null) && (extraContext.containsKey(ActionContext.VALUE_STACK))) {
            // In case the ValueStack was passed in
            stack = (ValueStack) extraContext.get(ActionContext.VALUE_STACK);
            if (stack == null) {
                throw new IllegalStateException("There was a null Stack set into the extra params.");
            }
            contextMap = stack.getContext();
        } else {
            // create the value stack
            // this also adds the ValueStack to its context
            stack = valueStackFactory.createValueStack();
            // create the action context
            contextMap = stack.getContext();
        }
        // put extraContext in
        if (extraContext != null) {
            contextMap.putAll(extraContext);
        }
        //put this DefaultActionInvocation into the context map
        contextMap.put(ActionContext.ACTION_INVOCATION, this);
        contextMap.put(ActionContext.CONTAINER, container);
        return contextMap;
}

 public Result createResult() throws Exception 
{
        if (explicitResult != null) {
            Result ret = explicitResult;
            explicitResult = null;
            return ret;
        }
        ActionConfig config = proxy.getConfig();
        Map< String, ResultConfig > results = config.getResults();
        ResultConfig resultConfig = null;
        try {
            resultConfig = results.get(resultCode);
        } catch (NullPointerException e) {
            // swallow
        }
        if (resultConfig == null) {
            // If no result is found for the given resultCode, try to get a wildcard '*' match.
            resultConfig = results.get("*");
        }
        if (resultConfig != null) {
            try {
                return objectFactory.buildResult(resultConfig, invocationContext.getContextMap());
            } catch (Exception e) {
                LOG.error("There was an exception while instantiating the result of type " + resultConfig.getClassName(), e);
                throw new XWorkException(e, resultConfig);
            }
        } else if (resultCode != null && !Action.NONE.equals(resultCode) && unknownHandlerManager.hasUnknownHandlers()) {
            return unknownHandlerManager.handleUnknownResult(invocationContext, proxy.getActionName(), proxy.getConfig(), resultCode);
        }
        return null;
}

 public Object getAction() 
{
        return action;
}

 public ActionContext getInvocationContext() 
{
        return invocationContext;
}

 public ActionProxy getProxy() 
{
        return proxy;
}

 public Result getResult() throws Exception 
{
        Result returnResult = result;
        // If we've chained to other Actions, we need to find the last result
        while (returnResult instanceof ActionChainResult) {
            ActionProxy aProxy = ((ActionChainResult) returnResult).getProxy();
            if (aProxy != null) {
                Result proxyResult = aProxy.getInvocation().getResult();
                if ((proxyResult != null) && (aProxy.getExecuteResult())) {
                    returnResult = proxyResult;
                } else {
                    break;
                }
            } else {
                break;
            }
        }
        return returnResult;
}

If the DefaultActionInvocation has been executed before and the Result is an instance of ActionChainResult, this method will walk down the chain of ActionChainResults until it finds a non-chain result, which will be returned. If the DefaultActionInvocation's result has not been executed before, the Result instance will be created and populated with the result params.

 public String getResultCode() 
{
        return resultCode;
}

 public ValueStack getStack() 
{
        return stack;
}

 public  void init(ActionProxy proxy) 
{
        this.proxy = proxy;
        Map< String, Object > contextMap = createContextMap();
        // Setting this so that other classes, like object factories, can use the ActionProxy and other
        // contextual information to operate
        ActionContext actionContext = ActionContext.getContext();
        if (actionContext != null) {
            actionContext.setActionInvocation(this);
        }
        createAction(contextMap);
        if (pushAction) {
            stack.push(action);
            contextMap.put("action", action);
        }
        invocationContext = new ActionContext(contextMap);
        invocationContext.setName(proxy.getActionName());
        // get a new List so we don't get problems with the iterator if someone changes the list
        List< InterceptorMapping > interceptorList = new ArrayList< InterceptorMapping >(proxy.getConfig().getInterceptors());
        interceptors = interceptorList.iterator();
}

 public String invoke() throws Exception 
{
        String profileKey = "invoke: ";
        try {
            UtilTimerStack.push(profileKey);
            if (executed) {
                throw new IllegalStateException("Action has already executed");
            }
            if (interceptors.hasNext()) {
                final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();
                String interceptorMsg = "interceptor: " + interceptor.getName();
                UtilTimerStack.push(interceptorMsg);
                try {
                                resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
                            }
                finally {
                    UtilTimerStack.pop(interceptorMsg);
                }
            } else {
                resultCode = invokeActionOnly();
            }
            // this is needed because the result will be executed, then control will return to the Interceptor, which will
            // return above and flow through again
            if (!executed) {
                if (preResultListeners != null) {
                    for (Object preResultListener : preResultListeners) {
                        PreResultListener listener = (PreResultListener) preResultListener;
                        String _profileKey = "preResultListener: ";
                        try {
                            UtilTimerStack.push(_profileKey);
                            listener.beforeResult(this, resultCode);
                        }
                        finally {
                            UtilTimerStack.pop(_profileKey);
                        }
                    }
                }
                // now execute the result, if we're supposed to
                if (proxy.getExecuteResult()) {
                    executeResult();
                }
                executed = true;
            }
            return resultCode;
        }
        finally {
            UtilTimerStack.pop(profileKey);
        }
}

 protected String invokeAction(Object action,
    ActionConfig actionConfig) throws Exception 
{
        String methodName = proxy.getMethod();
        if (LOG.isDebugEnabled()) {
            LOG.debug("Executing action method = " + actionConfig.getMethodName());
        }
        String timerKey = "invokeAction: " + proxy.getActionName();
        try {
            UtilTimerStack.push(timerKey);
            boolean methodCalled = false;
            Object methodResult = null;
            Method method = null;
            try {
                method = getAction().getClass().getMethod(methodName, new Class[0]);
            } catch (NoSuchMethodException e) {
                // hmm -- OK, try doXxx instead
                try {
                    String altMethodName = "do" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
                    method = getAction().getClass().getMethod(altMethodName, new Class[0]);
                } catch (NoSuchMethodException e1) {
                    // well, give the unknown handler a shot
                    if (unknownHandlerManager.hasUnknownHandlers()) {
                        try {
                            methodResult = unknownHandlerManager.handleUnknownMethod(action, methodName);
                            methodCalled = true;
                        } catch (NoSuchMethodException e2) {
                            // throw the original one
                            throw e;
                        }
                    } else {
                        throw e;
                    }
                }
            }
            if (!methodCalled) {
                methodResult = method.invoke(action, new Object[0]);
            }
            if (methodResult instanceof Result) {
                this.explicitResult = (Result) methodResult;
                // Wire the result automatically
                container.inject(explicitResult);
                return null;
            } else {
                return (String) methodResult;
            }
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException("The " + methodName + "() is not defined in action " + getAction().getClass() + "");
        } catch (InvocationTargetException e) {
            // We try to return the source exception.
            Throwable t = e.getTargetException();
            if (actionEventListener != null) {
                String result = actionEventListener.handleException(t, getStack());
                if (result != null) {
                    return result;
                }
            }
            if (t instanceof Exception) {
                throw (Exception) t;
            } else {
                throw e;
            }
        } finally {
            UtilTimerStack.pop(timerKey);
        }
}

 public String invokeActionOnly() throws Exception 
{
        return invokeAction(getAction(), proxy.getConfig());
}

 public boolean isExecuted() 
{
        return executed;
}

 public  void setActionEventListener(ActionEventListener listener) 
{
        this.actionEventListener = listener;
}

 public  void setConfiguration(Configuration configuration) 
{
        this.configuration = configuration;
}

 public  void setContainer(Container cont) 
{
        this.container = cont;
}

 public  void setObjectFactory(ObjectFactory fac) 
{
        this.objectFactory = fac;
}

 public  void setResultCode(String resultCode) 
{
        if (isExecuted())
            throw new IllegalStateException("Result has already been executed.");
        this.resultCode = resultCode;
}

 public  void setUnknownHandlerManager(UnknownHandlerManager unknownHandlerManager) 
{
        this.unknownHandlerManager = unknownHandlerManager;
}

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