AbstractFormController

java.lang.Object
- org.springframework.context.support.ApplicationObjectSupport
- - org.springframework.web.context.support.WebApplicationObjectSupport
  - - org.springframework.web.servlet.support.WebContentGenerator
    - - org.springframework.web.servlet.mvc.AbstractController
      - org.springframework.web.servlet.mvc.BaseCommandController
        
        org.springframework.web.servlet.mvc.AbstractFormController

All Implemented Interfaces:: Aware, ApplicationContextAware, ServletContextAware, Controller

Direct Known Subclasses:: AbstractWizardFormController, SimpleFormController

Deprecated.

as of Spring 3.0, in favor of annotated controllers

@Deprecated
public abstract class AbstractFormController
extends BaseCommandController

Form controller that auto-populates a form bean from the request. This, either using a new bean instance per request, or using the same bean when the sessionForm property has been set to true.

This class is the base class for both framework subclasses such as SimpleFormController and AbstractWizardFormController and custom form controllers that you may provide yourself.

A form-input view and an after-submission view have to be provided programmatically. To provide those views using configuration properties, use the SimpleFormController.

Subclasses need to override showForm to prepare the form view, and processFormSubmission to handle submit requests. For the latter, binding errors like type mismatches will be reported via the given "errors" holder. For additional custom form validation, a validator (property inherited from BaseCommandController) can be used, reporting via the same "errors" instance.

Comparing this Controller to the Struts notion of the Action shows us that with Spring, you can use any ordinary JavaBeans or database- backed JavaBeans without having to implement a framework-specific class (like Struts' ActionForm). More complex properties of JavaBeans (Dates, Locales, but also your own application-specific or compound types) can be represented and submitted to the controller, by using the notion of a java.beans.PropertyEditor. For more information on that subject, see the workflow of this controller and the explanation of the BaseCommandController.

Workflow (and that defined by superclass):

The controller receives a request for a new form (typically a GET).
Call to formBackingObject() which by default, returns an instance of the commandClass that has been configured (see the properties the superclass exposes), but can also be overridden to e.g. retrieve an object from the database (that needs to be modified using the form).
Call to initBinder() which allows you to register custom editors for certain fields (often properties of non-primitive or non-String types) of the command class. This will render appropriate Strings for those property values, e.g. locale-specific date strings.
Only if bindOnNewForm is set to true, then ServletRequestDataBinder gets applied to populate the new form object with initial request parameters and the onBindOnNewForm(HttpServletRequest, Object, BindException) callback method is called. Note: any defined Validators are not applied at this point, to allow partial binding. However be aware that any Binder customizations applied via initBinder() (such as DataBinder.setRequiredFields(String[]) will still apply. As such, if using bindOnNewForm=true and initBinder() customizations are used to validate fields instead of using Validators, in the case that only some fields will be populated for the new form, there will potentially be some bind errors for missing fields in the errors object. Any view (JSP, etc.) that displays binder errors needs to be intelligent and for this case take into account whether it is displaying the initial form view or subsequent post results, skipping error display for the former.
Call to showForm() to return a View that should be rendered (typically the view that renders the form). This method has to be implemented in subclasses.
The showForm() implementation will call referenceData(), which you can implement to provide any relevant reference data you might need when editing a form (e.g. a List of Locale objects you're going to let the user select one from).
Model gets exposed and view gets rendered, to let the user fill in the form.
The controller receives a form submission (typically a POST). To use a different way of detecting a form submission, override the isFormSubmission method.
If sessionForm is not set, formBackingObject() is called to retrieve a form object. Otherwise, the controller tries to find the command object which is already bound in the session. If it cannot find the object, it does a call to handleInvalidSubmit which - by default - tries to create a new form object and resubmit the form.
The ServletRequestDataBinder gets applied to populate the form object with current request parameters.
Call to onBind(HttpServletRequest, Object, Errors) which allows you to do custom processing after binding but before validation (e.g. to manually bind request parameters to bean properties, to be seen by the Validator).
If validateOnBinding is set, a registered Validator will be invoked. The Validator will check the form object properties, and register corresponding errors via the given Errors
Call to onBindAndValidate() which allows you to do custom processing after binding and validation (e.g. to manually bind request parameters, and to validate them outside a Validator).
Call processFormSubmission() to process the submission, with or without binding errors. This method has to be implemented in subclasses.

In session form mode, a submission without an existing form object in the session is considered invalid, like in case of a resubmit/reload by the browser. The handleInvalidSubmit method is invoked then, by default trying to resubmit. It can be overridden in subclasses to show corresponding messages or to redirect to a new form, in order to avoid duplicate submissions. The form object in the session can be considered a transaction token in that case.

Note that views should never retrieve form beans from the session but always from the request, as prepared by the form controller. Remember that some view technologies like Velocity cannot even access a HTTP session.

Exposed configuration properties (and those defined by superclass):

name	default	description
bindOnNewForm	false	Indicates whether to bind servlet request parameters when creating a new form. Otherwise, the parameters will only be bound on form submission attempts.
sessionForm	false	Indicates whether the form object should be kept in the session when a user asks for a new form. This allows you e.g. to retrieve an object from the database, let the user edit it, and then persist it again. Otherwise, a new command object will be created for each request (even when showing the form again after validation errors).

Author:: Rod Johnson, Juergen Hoeller, Alef Arendsen, Rob Harrop, Colin Sampaleanu
See Also:: showForm(HttpServletRequest, HttpServletResponse, BindException), processFormSubmission(HttpServletRequest, HttpServletResponse, java.lang.Object, org.springframework.validation.BindException), SimpleFormController, AbstractWizardFormController

Field Summary

Fields
Modifier and Type Field and Description

private boolean bindOnNewForm
Deprecated.

private boolean sessionForm
Deprecated.
- Fields inherited from class org.springframework.web.servlet.mvc.BaseCommandController
  DEFAULT_COMMAND_NAME
- Fields inherited from class org.springframework.web.servlet.support.WebContentGenerator
  METHOD_GET, METHOD_HEAD, METHOD_POST
- Fields inherited from class org.springframework.context.support.ApplicationObjectSupport
  logger

Fields
Modifier and Type	Field and Description
`private boolean`	`bindOnNewForm` Deprecated.
`private boolean`	`sessionForm` Deprecated.

Constructor Summary

Constructors
Constructor and Description

AbstractFormController()
Deprecated.

Create a new AbstractFormController.

Constructors
Constructor and Description
`AbstractFormController()` Deprecated. Create a new AbstractFormController.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected java.lang.Object`	`currentFormObject(HttpServletRequest request, java.lang.Object sessionFormObject)` Deprecated. Return the current form object to use for binding and further processing, based on the passed-in form object as found in the HttpSession.
`protected java.lang.Object`	`formBackingObject(HttpServletRequest request)` Deprecated. Retrieve a backing object for the current form from the given request.
`protected java.lang.Object`	`getCommand(HttpServletRequest request)` Deprecated. Return the form object for the given request.
`protected BindException`	`getErrorsForNewForm(HttpServletRequest request)` Deprecated. Create a BindException instance for a new form.
`protected java.lang.String`	`getFormSessionAttributeName()` Deprecated. Return the name of the HttpSession attribute that holds the form object for this form controller.
`protected java.lang.String`	`getFormSessionAttributeName(HttpServletRequest request)` Deprecated. Return the name of the HttpSession attribute that holds the form object for this form controller.
`protected ModelAndView`	`handleInvalidSubmit(HttpServletRequest request, HttpServletResponse response)` Deprecated. Handle an invalid submit request, e.g.
`protected ModelAndView`	`handleRequestInternal(HttpServletRequest request, HttpServletResponse response)` Deprecated. Handles two cases: form submissions and showing a new form.
`boolean`	`isBindOnNewForm()` Deprecated. Return `true` if request parameters should be bound in case of a new form.
`protected boolean`	`isFormSubmission(HttpServletRequest request)` Deprecated. Determine if the given request represents a form submission.
`boolean`	`isSessionForm()` Deprecated. Return `true` if session form mode is activated.
`protected void`	`onBindOnNewForm(HttpServletRequest request, java.lang.Object command)` Deprecated. Callback for custom post-processing in terms of binding for a new form.
`protected void`	`onBindOnNewForm(HttpServletRequest request, java.lang.Object command, BindException errors)` Deprecated. Callback for custom post-processing in terms of binding for a new form.
`protected abstract ModelAndView`	`processFormSubmission(HttpServletRequest request, HttpServletResponse response, java.lang.Object command, BindException errors)` Deprecated. Process form submission request.
`protected java.util.Map`	`referenceData(HttpServletRequest request, java.lang.Object command, Errors errors)` Deprecated. Create a reference data map for the given request, consisting of bean name/bean instance pairs as expected by ModelAndView.
`void`	`setBindOnNewForm(boolean bindOnNewForm)` Deprecated. Set whether request parameters should be bound to the form object in case of a non-submitting request, that is, a new form.
`void`	`setSessionForm(boolean sessionForm)` Deprecated. Activate/deactivate session form mode.
`protected ModelAndView`	`showForm(HttpServletRequest request, BindException errors, java.lang.String viewName)` Deprecated. Prepare model and view for the given form, including reference and errors.
`protected ModelAndView`	`showForm(HttpServletRequest request, BindException errors, java.lang.String viewName, java.util.Map controlModel)` Deprecated. Prepare model and view for the given form, including reference and errors, adding a controller-specific control model.
`protected abstract ModelAndView`	`showForm(HttpServletRequest request, HttpServletResponse response, BindException errors)` Deprecated. Prepare the form model and view, including reference and error data.
`protected ModelAndView`	`showNewForm(HttpServletRequest request, HttpServletResponse response)` Deprecated. Show a new form.

Methods inherited from class org.springframework.web.servlet.mvc.AbstractController
handleRequest, isSynchronizeOnSession, setSynchronizeOnSession

Methods inherited from class org.springframework.web.servlet.support.WebContentGenerator
applyCacheSeconds, applyCacheSeconds, cacheForSeconds, cacheForSeconds, checkAndPrepare, checkAndPrepare, getCacheSeconds, getSupportedMethods, isAlwaysMustRevalidate, isRequireSession, isUseCacheControlHeader, isUseCacheControlNoStore, isUseExpiresHeader, preventCaching, setAlwaysMustRevalidate, setCacheSeconds, setRequireSession, setSupportedMethods, setUseCacheControlHeader, setUseCacheControlNoStore, setUseExpiresHeader

Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport
getServletContext, getTempDir, getWebApplicationContext, initApplicationContext, initServletContext, isContextRequired, setServletContext

Methods inherited from class org.springframework.context.support.ApplicationObjectSupport
getApplicationContext, getMessageSourceAccessor, requiredContextClass, setApplicationContext

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

- Field Detail
  - bindOnNewForm
```
private boolean bindOnNewForm
```
    Deprecated.
  - sessionForm
```
private boolean sessionForm
```
    Deprecated.
- Constructor Detail
  - AbstractFormController
```
public AbstractFormController()
```
    Deprecated.
    
    Create a new AbstractFormController.
    Subclasses should set the following properties, either in the constructor or via a BeanFactory: commandName, commandClass, bindOnNewForm, sessionForm. Note that "commandClass" doesn't need to be set when overriding formBackingObject(HttpServletRequest), since the latter determines the class anyway.
    "cacheSeconds" is by default set to 0 (-> no caching for all form controllers).
    
    See Also:
    
    BaseCommandController.setCommandName(java.lang.String), BaseCommandController.setCommandClass(java.lang.Class), setBindOnNewForm(boolean), setSessionForm(boolean), formBackingObject(HttpServletRequest)
- Method Detail
  - setBindOnNewForm
```
public final void setBindOnNewForm(boolean bindOnNewForm)
```
    Deprecated.
    
    Set whether request parameters should be bound to the form object in case of a non-submitting request, that is, a new form.
  - isBindOnNewForm
```
public final boolean isBindOnNewForm()
```
    Deprecated.
    
    Return true if request parameters should be bound in case of a new form.
  - setSessionForm
```
public final void setSessionForm(boolean sessionForm)
```
    Deprecated.
    
    Activate/deactivate session form mode. In session form mode, the form is stored in the session to keep the form object instance between requests, instead of creating a new one on each request.
    This is necessary for either wizard-style controllers that populate a single form object from multiple pages, or forms that populate a persistent object that needs to be identical to allow for tracking changes.
    Please note that the AbstractFormController class (and all subclasses of it unless stated to the contrary) do not support the notion of a conversation. This is important in the context of this property, because it means that there is only one form per session: this means that if session form mode is activated and a user opens up say two tabs in their browser and attempts to edit two distinct objects using the same form, then the shared session state can potentially (and most probably will) be overwritten by the last tab to be opened, which can lead to errors when either of the forms in each is finally submitted.
    If you need to have per-form, per-session state management (that is, stateful web conversations), the recommendation is to use Spring WebFlow, which has full support for conversations and has a much more flexible usage model overall.
    
    Parameters:
    
    sessionForm - true if session form mode is to be activated
  - isSessionForm
```
public final boolean isSessionForm()
```
    Deprecated.
    
    Return true if session form mode is activated.
  - handleRequestInternal
```
protected ModelAndView handleRequestInternal(HttpServletRequest request,
                                             HttpServletResponse response)
                                      throws java.lang.Exception
```
    Deprecated.
    
    Handles two cases: form submissions and showing a new form. Delegates the decision between the two to isFormSubmission(HttpServletRequest), always treating requests without existing form session attribute as new form when using session form mode.
    
    Specified by:
    
    handleRequestInternal in class AbstractController
    
    Throws:
    
    java.lang.Exception
    
    See Also:
    
    isFormSubmission(HttpServletRequest), showNewForm(HttpServletRequest, HttpServletResponse), processFormSubmission(HttpServletRequest, HttpServletResponse, java.lang.Object, org.springframework.validation.BindException)
  - isFormSubmission
```
protected boolean isFormSubmission(HttpServletRequest request)
```
    Deprecated.
    
    Determine if the given request represents a form submission.
    The default implementation treats a POST request as form submission. Note: If the form session attribute doesn't exist when using session form mode, the request is always treated as new form by handleRequestInternal.
    Subclasses can override this to use a custom strategy, e.g. a specific request parameter (assumably a hidden field or submit button name).
    
    Parameters:
    
    request - current HTTP request
    
    Returns:
    
    if the request represents a form submission
  - getFormSessionAttributeName
```
protected java.lang.String getFormSessionAttributeName(HttpServletRequest request)
```
    Deprecated.
    
    Return the name of the HttpSession attribute that holds the form object for this form controller.
    The default implementation delegates to the getFormSessionAttributeName() variant without arguments.
    
    Parameters:
    
    request - current HTTP request
    
    Returns:
    
    the name of the form session attribute, or null if not in session form mode
    
    See Also:
    
    getFormSessionAttributeName(HttpServletRequest), javax.servlet.http.HttpSession#getAttribute
  - getFormSessionAttributeName
```
protected java.lang.String getFormSessionAttributeName()
```
    Deprecated.
    
    Return the name of the HttpSession attribute that holds the form object for this form controller.
    Default is an internal name, of no relevance to applications, as the form session attribute is not usually accessed directly. Can be overridden to use an application-specific attribute name, which allows other code to access the session attribute directly.
    
    Returns:
    
    the name of the form session attribute
    
    See Also:
    
    javax.servlet.http.HttpSession#getAttribute
  - showNewForm
```
protected final ModelAndView showNewForm(HttpServletRequest request,
                                         HttpServletResponse response)
                                  throws java.lang.Exception
```
    Deprecated.
    
    Show a new form. Prepares a backing object for the current form and the given request, including checking its validity.
    
    Parameters:
    
    request - current HTTP request
    
    response - current HTTP response
    
    Returns:
    
    the prepared form view
    
    Throws:
    
    java.lang.Exception - in case of an invalid new form object
    
    See Also:
    
    getErrorsForNewForm(HttpServletRequest)
  - getErrorsForNewForm
```
protected final BindException getErrorsForNewForm(HttpServletRequest request)
                                           throws java.lang.Exception
```
    Deprecated.
    
    Create a BindException instance for a new form. Called by showNewForm(HttpServletRequest, HttpServletResponse).
    Can be used directly when intending to show a new form but with special errors registered on it (for example, on invalid submit). Usually, the resulting BindException will be passed to showForm(HttpServletRequest, HttpServletResponse, BindException), after registering the errors on it.
    
    Parameters:
    
    request - current HTTP request
    
    Returns:
    
    the BindException instance
    
    Throws:
    
    java.lang.Exception - in case of an invalid new form object
    
    See Also:
    
    showNewForm(HttpServletRequest, HttpServletResponse), showForm(HttpServletRequest, HttpServletResponse, BindException), handleInvalidSubmit(HttpServletRequest, HttpServletResponse)
  - onBindOnNewForm
```
protected void onBindOnNewForm(HttpServletRequest request,
                               java.lang.Object command,
                               BindException errors)
                        throws java.lang.Exception
```
    Deprecated.
    
    Callback for custom post-processing in terms of binding for a new form. Called when preparing a new form if bindOnNewForm is true.
    The default implementation delegates to onBindOnNewForm(request, command).
    
    Parameters:
    
    request - current HTTP request
    
    command - the command object to perform further binding on
    
    errors - validation errors holder, allowing for additional custom registration of binding errors
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
    
    See Also:
    
    #onBindOnNewForm(javax.servlet.http.HttpServletRequest, Object), setBindOnNewForm(boolean)
  - onBindOnNewForm
```
protected void onBindOnNewForm(HttpServletRequest request,
                               java.lang.Object command)
                        throws java.lang.Exception
```
    Deprecated.
    
    Callback for custom post-processing in terms of binding for a new form.
    Called by the default implementation of the onBindOnNewForm(HttpServletRequest, Object, BindException) variant with all parameters, after standard binding when displaying the form view. Only called if bindOnNewForm is set to true.
    The default implementation is empty.
    
    Parameters:
    
    request - current HTTP request
    
    command - the command object to perform further binding on
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
    
    See Also:
    
    onBindOnNewForm(HttpServletRequest, Object, BindException), setBindOnNewForm(boolean)
  - getCommand
```
protected final java.lang.Object getCommand(HttpServletRequest request)
                                     throws java.lang.Exception
```
    Deprecated.
    
    Return the form object for the given request.
    Calls formBackingObject(HttpServletRequest) if not in session form mode. Else, retrieves the form object from the session. Note that the form object gets removed from the session, but it will be re-added when showing the form for resubmission.
    
    Overrides:
    
    getCommand in class BaseCommandController
    
    Parameters:
    
    request - current HTTP request
    
    Returns:
    
    object form to bind onto
    
    Throws:
    
    HttpSessionRequiredException - if a session was expected but no active session (or session form object) found
    
    java.lang.Exception - in case of invalid state or arguments
    
    See Also:
    
    formBackingObject(HttpServletRequest)
  - formBackingObject
```
protected java.lang.Object formBackingObject(HttpServletRequest request)
                                      throws java.lang.Exception
```
    Deprecated.
    
    Retrieve a backing object for the current form from the given request.
    The properties of the form object will correspond to the form field values in your form view. This object will be exposed in the model under the specified command name, to be accessed under that name in the view: for example, with a "spring:bind" tag. The default command name is "command".
    Note that you need to activate session form mode to reuse the form-backing object across the entire form workflow. Else, a new instance of the command class will be created for each submission attempt, just using this backing object as template for the initial form.
    The default implementation calls BaseCommandController.createCommand(), creating a new empty instance of the specified command class. Subclasses can override this to provide a preinitialized backing object.
    
    Parameters:
    
    request - current HTTP request
    
    Returns:
    
    the backing object
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
    
    See Also:
    
    BaseCommandController.setCommandName(java.lang.String), BaseCommandController.setCommandClass(java.lang.Class), BaseCommandController.createCommand()
  - currentFormObject
```
protected java.lang.Object currentFormObject(HttpServletRequest request,
                                             java.lang.Object sessionFormObject)
                                      throws java.lang.Exception
```
    Deprecated.
    
    Return the current form object to use for binding and further processing, based on the passed-in form object as found in the HttpSession.
    The default implementation simply returns the session form object as-is. Subclasses can override this to post-process the session form object, for example reattaching it to a persistence manager.
    
    Parameters:
    
    sessionFormObject - the form object retrieved from the HttpSession
    
    Returns:
    
    the form object to use for binding and further processing
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
  - showForm
```
protected abstract ModelAndView showForm(HttpServletRequest request,
                                         HttpServletResponse response,
                                         BindException errors)
                                  throws java.lang.Exception
```
    Deprecated.
    
    Prepare the form model and view, including reference and error data. Can show a configured form page, or generate a form view programmatically.
    A typical implementation will call showForm(request, errors, "myView") to prepare the form view for a specific view name, returning the ModelAndView provided there.
    For building a custom ModelAndView, call errors.getModel() to populate the ModelAndView model with the command and the Errors instance, under the specified command name, as expected by the "spring:bind" tag. You also need to include the model returned by referenceData(HttpServletRequest, java.lang.Object, org.springframework.validation.Errors).
    Note: If you decide to have a "formView" property specifying the view name, consider using SimpleFormController.
    
    Parameters:
    
    request - current HTTP request
    
    response - current HTTP response
    
    errors - validation errors holder
    
    Returns:
    
    the prepared form view, or null if handled directly
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
    
    See Also:
    
    showForm(HttpServletRequest, BindException, String), Errors, BindException.getModel(), referenceData(HttpServletRequest, Object, Errors), SimpleFormController.setFormView(java.lang.String)
  - showForm
```
protected final ModelAndView showForm(HttpServletRequest request,
                                      BindException errors,
                                      java.lang.String viewName)
                               throws java.lang.Exception
```
    Deprecated.
    
    Prepare model and view for the given form, including reference and errors.
    In session form mode: Re-puts the form object in the session when returning to the form, as it has been removed by getCommand.
    Can be used in subclasses to redirect back to a specific form page.
    
    Parameters:
    
    request - current HTTP request
    
    errors - validation errors holder
    
    viewName - name of the form view
    
    Returns:
    
    the prepared form view
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
  - showForm
```
protected final ModelAndView showForm(HttpServletRequest request,
                                      BindException errors,
                                      java.lang.String viewName,
                                      java.util.Map controlModel)
                               throws java.lang.Exception
```
    Deprecated.
    
    Prepare model and view for the given form, including reference and errors, adding a controller-specific control model.
    In session form mode: Re-puts the form object in the session when returning to the form, as it has been removed by getCommand.
    Can be used in subclasses to redirect back to a specific form page.
    
    Parameters:
    
    request - current HTTP request
    
    errors - validation errors holder
    
    viewName - name of the form view
    
    controlModel - model map containing controller-specific control data (e.g. current page in wizard-style controllers or special error message)
    
    Returns:
    
    the prepared form view
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
  - referenceData
```
protected java.util.Map referenceData(HttpServletRequest request,
                                      java.lang.Object command,
                                      Errors errors)
                               throws java.lang.Exception
```
    Deprecated.
    
    Create a reference data map for the given request, consisting of bean name/bean instance pairs as expected by ModelAndView.
    The default implementation returns null. Subclasses can override this to set reference data used in the view.
    
    Parameters:
    
    request - current HTTP request
    
    command - form object with request parameters bound onto it
    
    errors - validation errors holder
    
    Returns:
    
    a Map with reference data entries, or null if none
    
    Throws:
    
    java.lang.Exception - in case of invalid state or arguments
    
    See Also:
    
    ModelAndView
  - processFormSubmission
```
protected abstract ModelAndView processFormSubmission(HttpServletRequest request,
                                                      HttpServletResponse response,
                                                      java.lang.Object command,
                                                      BindException errors)
                                               throws java.lang.Exception
```
    Deprecated.
    
    Process form submission request. Called by handleRequestInternal(HttpServletRequest, HttpServletResponse) in case of a form submission, with or without binding errors. Implementations need to proceed properly, typically showing a form view in case of binding errors or performing a submit action else.
    Subclasses can implement this to provide custom submission handling like triggering a custom action. They can also provide custom validation and call showForm(HttpServletRequest, HttpServletResponse, BindException) or proceed with the submission accordingly.
    For a success view, call errors.getModel() to populate the ModelAndView model with the command and the Errors instance, under the specified command name, as expected by the "spring:bind" tag. For a form view, simply return the ModelAndView object provided by showForm(HttpServletRequest, HttpServletResponse, BindException).
    
    Parameters:
    
    request - current servlet request
    
    response - current servlet response
    
    command - form object with request parameters bound onto it
    
    errors - holder without errors (subclass can add errors if it wants to)
    
    Returns:
    
    the prepared model and view, or null
    
    Throws:
    
    java.lang.Exception - in case of errors
    
    See Also:
    
    handleRequestInternal(HttpServletRequest, HttpServletResponse), isFormSubmission(HttpServletRequest), showForm(HttpServletRequest, HttpServletResponse, BindException), Errors, BindException.getModel()
  - handleInvalidSubmit
```
protected ModelAndView handleInvalidSubmit(HttpServletRequest request,
                                           HttpServletResponse response)
                                    throws java.lang.Exception
```
    Deprecated.
    Handle an invalid submit request, e.g. when in session form mode but no form object was found in the session (like in case of an invalid resubmit by the browser).
    The default implementation simply tries to resubmit the form with a new form object. This should also work if the user hit the back button, changed some form data, and resubmitted the form.
    Note: To avoid duplicate submissions, you need to override this method. Either show some "invalid submit" message, or call showNewForm(HttpServletRequest, HttpServletResponse) for resetting the form (prepopulating it with the current values if "bindOnNewForm" is true). In this case, the form object in the session serves as transaction token.
```
 protected ModelAndView handleInvalidSubmit(HttpServletRequest request, HttpServletResponse response) throws Exception {
   return showNewForm(request, response);
 }
```
    You can also show a new form but with special errors registered on it:
```
 protected ModelAndView handleInvalidSubmit(HttpServletRequest request, HttpServletResponse response) throws Exception {
   BindException errors = getErrorsForNewForm(request);
   errors.reject("duplicateFormSubmission", "Duplicate form submission");
   return showForm(request, response, errors);
 }
```
    Parameters:
    
    request - current HTTP request
    
    response - current HTTP response
    
    Returns:
    
    a prepared view, or null if handled directly
    
    Throws:
    
    java.lang.Exception - in case of errors
    
    See Also:
    
    showNewForm(HttpServletRequest, HttpServletResponse), getErrorsForNewForm(HttpServletRequest), showForm(HttpServletRequest, HttpServletResponse, BindException), setBindOnNewForm(boolean)

Class AbstractFormController

Field Summary

Fields inherited from class org.springframework.web.servlet.mvc.BaseCommandController

Fields inherited from class org.springframework.web.servlet.support.WebContentGenerator

Fields inherited from class org.springframework.context.support.ApplicationObjectSupport

Constructor Summary

Method Summary

Methods inherited from class org.springframework.web.servlet.mvc.BaseCommandController

Methods inherited from class org.springframework.web.servlet.mvc.AbstractController

Methods inherited from class org.springframework.web.servlet.support.WebContentGenerator

Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport

Methods inherited from class org.springframework.context.support.ApplicationObjectSupport

Methods inherited from class java.lang.Object

Field Detail

bindOnNewForm

sessionForm

Constructor Detail

AbstractFormController

Method Detail

setBindOnNewForm

isBindOnNewForm

setSessionForm

isSessionForm

handleRequestInternal

isFormSubmission

getFormSessionAttributeName

getFormSessionAttributeName

showNewForm

getErrorsForNewForm

onBindOnNewForm

onBindOnNewForm

getCommand

formBackingObject

currentFormObject

showForm

showForm

showForm

referenceData

processFormSubmission

handleInvalidSubmit