/**
     * <p>Return an <code>Action</code> instance that will be used to process
     * the current request, creating a new one if necessary.</p>
     *
     * @param request  The servlet request we are processing
     * @param response The servlet response we are creating
     * @param mapping  The mapping we are using
     * @return An <code>Action</code> instance that will be used to process
     *         the current request.
     * @throws IOException if an input/output error occurs
     */
    protected Action processActionCreate(HttpServletRequest request,
        HttpServletResponse response, ActionMapping mapping)
        throws IOException {
        // Acquire the Action instance we will be using (if there is one)
        String className = mapping.getType();

        if (log.isDebugEnabled()) {
            log.debug(" Looking for Action instance for class " + className);
        }

        // If there were a mapping property indicating whether
        // an Action were a singleton or not ([true]),
        // could we just instantiate and return a new instance here?
        Action instance;

        synchronized (actions) {
            // Return any existing Action instance of this class
            instance = (Action) actions.get(className);

            if (instance != null) {
                if (log.isTraceEnabled()) {
                    log.trace("  Returning existing Action instance");
                }

                return (instance);
            }

            // Create and return a new Action instance
            if (log.isTraceEnabled()) {
                log.trace("  Creating new Action instance");
            }

            try {
                instance = (Action) RequestUtils.applicationInstance(className);

                // Maybe we should propagate this exception
                // instead of returning null.
            } catch (Exception e) {
                log.error(getInternal().getMessage("actionCreate",
                        mapping.getPath()), e);

                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                    getInternal().getMessage("actionCreate", mapping.getPath()));

                return (null);
            }

            actions.put(className, instance);
        }

        if (instance.getServlet() == null) {
            instance.setServlet(this.servlet);
        }

        return (instance);
    }

Spring的DelegatingRequestProcessor得到Action的方法：

	/**
	 * Override the base class method to return the delegate action.
	 * @see #getDelegateAction
	 */
	protected Action processActionCreate(
			HttpServletRequest request, HttpServletResponse response, ActionMapping mapping)
			throws IOException {
                //先试图从Sping的Action容器中获取对应的Action，如果没有找到，再调用Strut提供的RequestProcessor的processActionCreate方法得到对应的Action。
		Action action = getDelegateAction(mapping);
		if (action != null) {
			return action;
		}//如果没有找到，再调用Strut提供的RequestProcessor的processActionCreate方法得到对应的Action。
		return super.processActionCreate(request, response, mapping);
	}

	/**
	 * Return the delegate <code>Action</code> for the given mapping.
	 * <p>The default implementation determines a bean name from the
	 * given <code>ActionMapping</code> and looks up the corresponding
	 * bean in the <code>WebApplicationContext</code>.
	 * @param mapping the Struts <code>ActionMapping</code>
	 * @return the delegate <code>Action</code>, or <code>null</code> if none found
	 * @throws BeansException if thrown by <code>WebApplicationContext</code> methods
	 * @see #determineActionBeanName
	 */
	protected Action getDelegateAction(ActionMapping mapping) throws BeansException {
		String beanName = determineActionBeanName(mapping);
		if (!getWebApplicationContext().containsBean(beanName)) {
			return null;
		}
		return (Action) getWebApplicationContext().getBean(beanName, Action.class);
	}