protected DefaultActionProxy(ActionInvocation inv,
    String namespace,
    String actionName,
    String methodName,
    boolean executeResult,
    boolean cleanupContext) 
{
        
        this.invocation = inv;
		this.cleanupContext = cleanupContext;
		if (LOG.isDebugEnabled()) {
			LOG.debug("Creating an DefaultActionProxy for namespace " + namespace + " and action name " + actionName);
		}
		this.actionName = actionName;
		this.namespace = namespace;
		this.executeResult = executeResult;
        this.method = methodName;
}

This constructor is private so the builder methods (create*) should be used to create an DefaultActionProxy.

The reason for the builder methods is so that you can use a subclass to create your own DefaultActionProxy instance (like a RMIActionProxy).

 public String execute() throws Exception 
{
        ActionContext nestedContext = ActionContext.getContext();
        ActionContext.setContext(invocation.getInvocationContext());
        String retCode = null;
        String profileKey = "execute: ";
        try {
        	UtilTimerStack.push(profileKey);
            retCode = invocation.invoke();
        } finally {
            if (cleanupContext) {
                ActionContext.setContext(nestedContext);
            }
            UtilTimerStack.pop(profileKey);
        }
        return retCode;
}

 public Object getAction() 
{
        return invocation.getAction();
}

 public String getActionName() 
{
        return actionName;
}

 public ActionConfig getConfig() 
{
        return config;
}

 public boolean getExecuteResult() 
{
        return executeResult;
}

 public ActionInvocation getInvocation() 
{
        return invocation;
}

 public String getMethod() 
{
        return method;
}

 public String getNamespace() 
{
        return namespace;
}

 protected  void prepare() 
{
        String profileKey = "create DefaultActionProxy: ";
        try {
            UtilTimerStack.push(profileKey);
            config = configuration.getRuntimeConfiguration().getActionConfig(namespace, actionName);
            if (config == null && unknownHandlerManager.hasUnknownHandlers()) {
                config = unknownHandlerManager.handleUnknownAction(namespace, actionName);
            }
            if (config == null) {
                String message;
                if ((namespace != null) && (namespace.trim().length()  > 0)) {
                    message = LocalizedTextUtil.findDefaultText(XWorkMessages.MISSING_PACKAGE_ACTION_EXCEPTION, Locale.getDefault(), new String[]{
                        namespace, actionName
                    });
                } else {
                    message = LocalizedTextUtil.findDefaultText(XWorkMessages.MISSING_ACTION_EXCEPTION, Locale.getDefault(), new String[]{
                        actionName
                    });
                }
                throw new ConfigurationException(message);
            }
            resolveMethod();
            if (!config.isAllowedMethod(method)) {
                throw new ConfigurationException("Invalid method: "+method+" for action "+actionName);
            }
            invocation.init(this);
        } finally {
            UtilTimerStack.pop(profileKey);
        }
}

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

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

 public  void setExecuteResult(boolean executeResult) 
{
        this.executeResult = executeResult;
}

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

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