## org.springframework.web.struts
Class DelegatingActionProxy

    java.lang.Object
      org.apache.struts.action.Action
          org.springframework.web.struts.DelegatingActionProxy

    public class DelegatingActionProxy

extends Action

Proxy for a Spring-managed Struts `Action` that is defined in `ContextLoaderPlugIn's` `WebApplicationContext`.

The proxy is defined in the Struts config file, specifying this class as the action class. This class will delegate to a Struts `Action` bean in the `ContextLoaderPlugIn` context.

    <action path="/login" type="org.springframework.web.struts.DelegatingActionProxy"/>

The name of the `Action` bean in the `WebApplicationContext` will be determined from the mapping path and module prefix. This can be customized by overriding the `determineActionBeanName` method.

Example:

- mapping path "/login" -> bean name "/login"
- mapping path "/login", module prefix "/mymodule" -> bean name "/mymodule/login"

A corresponding bean definition in the `ContextLoaderPlugin` context would look as follows; notice that the `Action` is now able to leverage fully Spring's configuration facilities:

     <bean name="/login" class="myapp.MyAction">
       <property name="...">...</property>
     </bean>

Note that you can use a single `ContextLoaderPlugIn` for all Struts modules. That context can in turn be loaded from multiple XML files, for example split according to Struts modules. Alternatively, define one `ContextLoaderPlugIn` per Struts module, specifying appropriate "contextConfigLocation" parameters. In both cases, the Spring bean name has to include the module prefix.

If you want to avoid having to specify `DelegatingActionProxy` as the `Action` type in your struts-config file (for example to be able to generate your Struts config file with XDoclet) consider using the `DelegatingRequestProcessor`. The latter's disadvantage is that it might conflict with the need for a different `RequestProcessor` subclass.

The default implementation delegates to the `DelegatingActionUtils` class as much as possible, to reuse as much code as possible with `DelegatingRequestProcessor` and `DelegatingTilesRequestProcessor`.

Note: The idea of delegating to Spring-managed Struts Actions originated in Don Brown's Spring Struts Plugin. `ContextLoaderPlugIn` and `DelegatingActionProxy` constitute a clean-room implementation of the same idea, essentially superseding the original plugin. Many thanks to Don Brown and Matt Raible for the original work and for the agreement to reimplement the idea in Spring proper!

Since:
  1.0.1
Author:
  Juergen Hoeller
See Also:
  `determineActionBeanName(org.apache.struts.action.ActionMapping)`, `DelegatingRequestProcessor`, `DelegatingTilesRequestProcessor`, `DelegatingActionUtils`, `ContextLoaderPlugIn`

Field Summary

Fields inherited from class org.apache.struts.action.Action
`defaultLocale, servlet`

Constructor Summary
`DelegatingActionProxy()`

Method Summary
`protected String` `determineActionBeanName(ActionMapping mapping)` Determine the name of the `Action` bean, to be looked up in the `WebApplicationContext`.
`ActionForward` `execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)` Pass the execute call on to the Spring-managed delegate `Action`.
`protected Action` `getDelegateAction(ActionMapping mapping)` Return the delegate `Action` for the given `mapping`.
`protected WebApplicationContext` `getWebApplicationContext(ActionServlet actionServlet, ModuleConfig moduleConfig)` Fetch ContextLoaderPlugIn's `WebApplicationContext` from the `ServletContext`, falling back to the root `WebApplicationContext`.

Methods inherited from class org.apache.struts.action.Action
`addErrors, addMessages, execute, generateToken, getDataSource, getDataSource, getErrors, getLocale, getMessages, getResources, getResources, getServlet, isCancelled, isTokenValid, isTokenValid, resetToken, saveErrors, saveErrors, saveErrors, saveMessages, saveMessages, saveToken, setLocale, setServlet`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### DelegatingActionProxy

    public DelegatingActionProxy()

Method Detail

### execute

    public ActionForward execute(ActionMapping mapping,
                                 ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response)
                          throws Exception

  Pass the execute call on to the Spring-managed delegate `Action`.

  Overrides:
    `execute` in class `Action`
  Throws:
    `Exception`
  See Also:
    `getDelegateAction(org.apache.struts.action.ActionMapping)`

### getDelegateAction

    protected Action getDelegateAction(ActionMapping mapping)
                                throws BeansException

  Return the delegate `Action` for the given `mapping`.

  The default implementation determines a bean name from the given `ActionMapping` and looks up the corresponding bean in the `WebApplicationContext`.

  Parameters:
    `mapping` - the Struts `ActionMapping`
  Returns:
    the delegate `Action`
  Throws:
    `BeansException` - if thrown by `WebApplicationContext` methods
  See Also:
    `determineActionBeanName(org.apache.struts.action.ActionMapping)`

### getWebApplicationContext

    protected WebApplicationContext getWebApplicationContext(ActionServlet actionServlet,
                                                             ModuleConfig moduleConfig)
                                                      throws IllegalStateException

  Fetch ContextLoaderPlugIn's `WebApplicationContext` from the `ServletContext`, falling back to the root `WebApplicationContext`.

  This context is supposed to contain the Struts `Action` beans to delegate to.

  Parameters:
    `actionServlet` - the associated `ActionServlet`
    `moduleConfig` - the associated `ModuleConfig`
  Returns:
    the `WebApplicationContext`
  Throws:
    `IllegalStateException` - if no `WebApplicationContext` could be found
  See Also:
    `DelegatingActionUtils.findRequiredWebApplicationContext(org.apache.struts.action.ActionServlet, org.apache.struts.config.ModuleConfig)`, `ContextLoaderPlugIn.SERVLET_CONTEXT_PREFIX`

### determineActionBeanName

    protected String determineActionBeanName(ActionMapping mapping)

  Determine the name of the `Action` bean, to be looked up in the `WebApplicationContext`.

  The default implementation takes the `mapping path` and prepends the `module prefix`, if any.

  Parameters:
    `mapping` - the Struts `ActionMapping`
  Returns:
    the name of the Action bean
  See Also:
    `DelegatingActionUtils.determineActionBeanName(org.apache.struts.action.ActionMapping)`, `ActionConfig.getPath()`, `ModuleConfig.getPrefix()`

Copyright © 2002-2008 The Spring Framework.