public AbstractFormController() 
{
	                                                                 	 
		setCacheSeconds(0);
}

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 , since the latter determines the class anyway.

"cacheSeconds" is by default set to 0 (-> no caching for all form controllers).

Also see:

setCommandName
setCommandClass
setBindOnNewForm
setSessionForm
formBackingObject

 protected Object currentFormObject(HttpServletRequest request,
    Object sessionFormObject) throws Exception 
{
		return sessionFormObject;
}

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.

 protected Object formBackingObject(HttpServletRequest request) throws Exception 
{
		return createCommand();
}

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 #createCommand() , creating a new empty instance of the specified command class. Subclasses can override this to provide a preinitialized backing object.

 protected final Object getCommand(HttpServletRequest request) throws Exception 
{
		// If not in session-form mode, create a new form-backing object.
		if (!isSessionForm()) {
			return formBackingObject(request);
		}
		// Session-form mode: retrieve form object from HTTP session attribute.
		HttpSession session = request.getSession(false);
		if (session == null) {
			throw new HttpSessionRequiredException("Must have session when trying to bind (in session-form mode)");
		}
		String formAttrName = getFormSessionAttributeName(request);
		Object sessionFormObject = session.getAttribute(formAttrName);
		if (sessionFormObject == null) {
			throw new HttpSessionRequiredException("Form object not found in session (in session-form mode)");
		}
		// Remove form object from HTTP session: we might finish the form workflow
		// in this request. If it turns out that we need to show the form view again,
		// we'll re-bind the form object to the HTTP session.
		if (logger.isDebugEnabled()) {
			logger.debug("Removing form session attribute [" + formAttrName + "]");
		}
		session.removeAttribute(formAttrName);
		return currentFormObject(request, sessionFormObject);
}

Return the form object for the given request.

Calls #formBackingObject 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.

 protected final BindException getErrorsForNewForm(HttpServletRequest request) throws Exception 
{
		// Create form-backing object for new form.
		Object command = formBackingObject(request);
		if (command == null) {
			throw new ServletException("Form object returned by formBackingObject() must not be null");
		}
		if (!checkCommand(command)) {
			throw new ServletException("Form object returned by formBackingObject() must match commandClass");
		}
		// Bind without validation, to allow for prepopulating a form, and for
		// convenient error evaluation in views (on both first attempt and resubmit).
		ServletRequestDataBinder binder = createBinder(request, command);
		BindException errors = new BindException(binder.getBindingResult());
		if (isBindOnNewForm()) {
			logger.debug("Binding to new form");
			binder.bind(request);
			onBindOnNewForm(request, command, errors);
		}
		// Return BindException object that resulted from binding.
		return errors;
}

Create a BindException instance for a new form. Called by #showNewForm .

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.

 protected String getFormSessionAttributeName() 
{
		return getClass().getName() + ".FORM." + getCommandName();
}

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.

 protected String getFormSessionAttributeName(HttpServletRequest request) 
{
		return getFormSessionAttributeName();
}

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.

 protected ModelAndView handleInvalidSubmit(HttpServletRequest request,
    HttpServletResponse response) throws Exception 
{
		Object command = formBackingObject(request);
		ServletRequestDataBinder binder = bindAndValidate(request, command);
		BindException errors = new BindException(binder.getBindingResult());
		return processFormSubmission(request, response, command, errors);
}

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 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);
}

 protected ModelAndView handleRequestInternal(HttpServletRequest request,
    HttpServletResponse response) throws Exception 
{
		// Form submission or new form to show?
		if (isFormSubmission(request)) {
			// Fetch form object from HTTP session, bind, validate, process submission.
			try {
				Object command = getCommand(request);
				ServletRequestDataBinder binder = bindAndValidate(request, command);
				BindException errors = new BindException(binder.getBindingResult());
				return processFormSubmission(request, response, command, errors);
			}
			catch (HttpSessionRequiredException ex) {
				// Cannot submit a session form if no form object is in the session.
				if (logger.isDebugEnabled()) {
					logger.debug("Invalid submit detected: " + ex.getMessage());
				}
				return handleInvalidSubmit(request, response);
			}
		}
		else {
			// New form to show: render form view.
			return showNewForm(request, response);
		}
}

Handles two cases: form submissions and showing a new form. Delegates the decision between the two to #isFormSubmission , always treating requests without existing form session attribute as new form when using session form mode.

 public final boolean isBindOnNewForm() 
{
		return this.bindOnNewForm;
}

Return true if request parameters should be bound in case of a new form.

 protected boolean isFormSubmission(HttpServletRequest request) 
{
		return "POST".equals(request.getMethod());
}

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).

 public final boolean isSessionForm() 
{
		return this.sessionForm;
}

Return true if session form mode is activated.

 protected  void onBindOnNewForm(HttpServletRequest request,
    Object command) throws Exception 
{

}

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.

 protected  void onBindOnNewForm(HttpServletRequest request,
    Object command,
    BindException errors) throws Exception 
{
		onBindOnNewForm(request, command);
}

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).

 abstract protected ModelAndView processFormSubmission(HttpServletRequest request,
    HttpServletResponse response,
    Object command,
    BindException errors) throws Exception
Process form submission request. Called by #handleRequestInternal 
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) .

 protected Map referenceData(HttpServletRequest request,
    Object command,
    Errors errors) throws Exception 
{
		return null;
}

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.

 public final  void setBindOnNewForm(boolean bindOnNewForm) 
{
		this.bindOnNewForm = bindOnNewForm;
}

Set whether request parameters should be bound to the form object in case of a non-submitting request, that is, a new form.

 public final  void setSessionForm(boolean sessionForm) 
{
		this.sessionForm = sessionForm;
}

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.

 abstract protected ModelAndView showForm(HttpServletRequest request,
    HttpServletResponse response,
    BindException errors) throws Exception
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 .
Note: If you decide to have a "formView" property specifying the
view name, consider using SimpleFormController.

 protected final ModelAndView showForm(HttpServletRequest request,
    BindException errors,
    String viewName) throws Exception 
{
		return showForm(request, errors, viewName, null);
}

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.

 protected final ModelAndView showForm(HttpServletRequest request,
    BindException errors,
    String viewName,
    Map controlModel) throws Exception 
{
		// In session form mode, re-expose form object as HTTP session attribute.
		// Re-binding is necessary for proper state handling in a cluster,
		// to notify other nodes of changes in the form object.
		if (isSessionForm()) {
			String formAttrName = getFormSessionAttributeName(request);
			if (logger.isDebugEnabled()) {
				logger.debug("Setting form session attribute [" + formAttrName + "] to: " + errors.getTarget());
			}
			request.getSession().setAttribute(formAttrName, errors.getTarget());
		}
		// Fetch errors model as starting point, containing form object under
		// "commandName", and corresponding Errors instance under internal key.
		Map model = errors.getModel();
		// Merge reference data into model, if any.
		Map referenceData = referenceData(request, errors.getTarget(), errors);
		if (referenceData != null) {
			model.putAll(referenceData);
		}
		// Merge control attributes into model, if any.
		if (controlModel != null) {
			model.putAll(controlModel);
		}
		// Trigger rendering of the specified view, using the final model.
		return new ModelAndView(viewName, model);
}

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.

 protected final ModelAndView showNewForm(HttpServletRequest request,
    HttpServletResponse response) throws Exception 
{
		logger.debug("Displaying new form");
		return showForm(request, response, getErrorsForNewForm(request));
}

Show a new form. Prepares a backing object for the current form and the given request, including checking its validity.