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, as 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 formBackingObject(PortletRequest 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.

Default implementation calls BaseCommandController.createCommand, creating a new empty instance of the command class. Subclasses can override this to provide a preinitialized backing object.

 protected final Object getCommand(PortletRequest 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 portlet session attribute.
		PortletSession session = request.getPortletSession(false);
		if (session == null) {
			throw new PortletSessionRequiredException("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 PortletSessionRequiredException("Form object not found in session (in session-form mode)");
		}
		// Remove form object from porlet 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 portlet session.
		if (logger.isDebugEnabled()) {
			logger.debug("Removing form session attribute [" + formAttrName + "]");
		}
		session.removeAttribute(formAttrName);
		// Check the command object to make sure its valid
		if (!checkCommand(sessionFormObject)) {
			throw new PortletSessionRequiredException("Object found in session does not match commandClass");
		}
		return sessionFormObject;
}

Return the form object for the given request.

Calls formBackingObject if the object is not in the session

 protected final BindException getErrorsForNewForm(RenderRequest request) throws Exception 
{
		// Create form-backing object for new form
		Object command = formBackingObject(request);
		if (command == null) {
			throw new PortletException("Form object returned by formBackingObject() must not be null");
		}
		if (!checkCommand(command)) {
			throw new PortletException("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).
		PortletRequestDataBinder binder = createBinder(request, command);
		BindException errors = new BindException(binder.getBindingResult());
		if (isBindOnNewForm()) {
			if (logger.isDebugEnabled()) {
				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, after registering the errors on it.

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

Return the name of the PortletSession 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(PortletRequest request) 
{
		return getFormSessionAttributeName();
}

Return the name of the PortletSession attribute that holds the form object for this form controller.

Default implementation delegates to the getFormSessionAttributeName version without arguments.

 protected String getFormSubmitParameterName() 
{
		return FORM_SUBMISSION_PARAMETER;
}

Return the name of the render parameter that indicates this was a form submission.

 protected String getInvalidSubmitParameterName() 
{
		return INVALID_SUBMISSION_PARAMETER;
}

Return the name of the render parameter that indicates this was an invalid form submission.

 public String[] getRenderParameters() 
{
		return this.renderParameters;
}

Returns the list of parameters that will be passed forward from the action phase to the render phase whenever the form is rerendered or when #passRenderParameters is called.

 protected  void handleActionRequestInternal(ActionRequest request,
    ActionResponse response) throws Exception 
{
		// Form submission or new form to show?
		if (isFormSubmission(request)) {
			// Fetch form object, bind, validate, process submission.
			try {
				Object command = getCommand(request);
				if (logger.isDebugEnabled()) {
					logger.debug("Processing valid submit (redirectAction = " + isRedirectAction() + ")");
				}
				if (!isRedirectAction()) {
					setFormSubmit(response);
				}
				PortletRequestDataBinder binder = bindAndValidate(request, command);
				BindException errors = new BindException(binder.getBindingResult());
				processFormSubmission(request, response, command, errors);
				setRenderCommandAndErrors(request, command, errors);
				return;
			}
			catch (PortletSessionRequiredException ex) {
				// Cannot submit a session form if no form object is in the session.
				if (logger.isDebugEnabled()) {
					logger.debug("Invalid submit detected: " + ex.getMessage());
				}
				setFormSubmit(response);
				setInvalidSubmit(response);
				handleInvalidSubmit(request, response);
				return;
			}
		}
		else {
			logger.debug("Not a form submit - passing parameters to render phase");
			passRenderParameters(request, response);
			return;
		}
}

Handles action phase of 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.

 protected  void handleInvalidSubmit(ActionRequest request,
    ActionResponse response) throws Exception 
{
		passRenderParameters(request, response);
		Object command = formBackingObject(request);
		if (command == null) {
			throw new PortletException("Form object returned by formBackingObject() must not be null");
		}
		if (!checkCommand(command)) {
			throw new PortletException("Form object returned by formBackingObject() must match commandClass");
		}
		PortletRequestDataBinder binder = bindAndValidate(request, command);
		BindException errors = new BindException(binder.getBindingResult());
		processFormSubmission(request, response, command, errors);
		setRenderCommandAndErrors(request, 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).

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. Most likely you will simply want it to do nothing here in the action phase and diplay an appropriate error and a new form in the render phase.

protected void handleInvalidSubmit(ActionRequest request, ActionResponse response) throws Exception {
}

If you override this method but you do need a command object and bind errors in the render phase, be sure to call setRenderCommandAndErrors from here.

 protected ModelAndView handleRenderRequestInternal(RenderRequest request,
    RenderResponse response) throws Exception 
{
		// Form submission or new form to show?
		if (isFormSubmission(request)) {
			// If it is an invalid submit then handle it.
			if (isInvalidSubmission(request)) {
				logger.debug("Invalid submit - calling renderInvalidSubmit");
				return renderInvalidSubmit(request, response);
			}
			// Valid submit - > render.
			logger.debug("Valid submit - calling renderFormSubmission");
			return renderFormSubmission(request, response, getRenderCommand(request), getRenderErrors(request));
		}
		else {
			// New form to show: render form view.
			return showNewForm(request, response);
		}
}

Handles render phase of 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 if request parameters should be bound in case of a new form.

 protected boolean isFormSubmission(PortletRequest request) 
{
		return (request instanceof ActionRequest ? true :
				TRUE.equals(request.getParameter(getFormSubmitParameterName())));
}

Determine if the given request represents a form submission.

Default implementation checks to see if this is an ActionRequest and treats all action requests as form submission. During the action phase it will pass forward a render parameter to indicate to the render phase that this is a form submission. This method can check both kinds of requests and indicate if this is a form submission.

Subclasses can override this to use a custom strategy, e.g. a specific request parameter (assumably a hidden field or submit button name). Make sure that the override can handle both ActionRequest and RenderRequest objects properly.

 protected boolean isInvalidSubmission(PortletRequest request) 
{
		return TRUE.equals(request.getParameter(getInvalidSubmitParameterName()));
}

Determine if the given request represents an invalid form submission.

 public boolean isRedirectAction() 
{
		return this.redirectAction;
}

Return if ActionResponse#sendRedirect is expected to be called in the action phase.

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

Return if session form mode is activated.

 protected  void onBindOnNewForm(RenderRequest 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 version with all parameters, after standard binding when displaying the form view. Only called if bindOnNewForm is set to true.

Default implementation is empty.

 protected  void onBindOnNewForm(RenderRequest 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.

Default implementation delegates to onBindOnNewForm(request, command).

 protected  void passRenderParameters(ActionRequest request,
    ActionResponse response) 
{
		if (this.renderParameters == null) {
			return;
		}
		try {
			for (int i = 0; i <  this.renderParameters.length; i++) {
				String paramName = this.renderParameters[i];
				String paramValues[] = request.getParameterValues(paramName);
				if (paramValues != null) {
					if (logger.isDebugEnabled()) {
						logger.debug("Passing parameter to render phase '" + paramName + "' = " +
								(paramValues == null ? "NULL" : Arrays.asList(paramValues).toString()));
					}
					response.setRenderParameter(paramName, paramValues);
				}
			}
		}
		catch (IllegalStateException ex) {
			// Ignore in case sendRedirect was already set.
		}
}

Pass the specified list of action request parameters to the render phase by putting them into the action response object. This may not be called when the action will call will call sendRedirect .

 abstract protected  void processFormSubmission(ActionRequest request,
    ActionResponse response,
    Object command,
    BindException errors) throws Exception
Process action phase of form submission request. Called by handleRequestInternal
in case of a form submission, with or without binding errors. Implementations
need to proceed properly, typically performing a submit action if there are no binding errors.
Subclasses can implement this to provide custom submission handling
like triggering a custom action. They can also provide custom validation
or proceed with the submission accordingly.

 protected Map referenceData(PortletRequest 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.

Default implementation returns null. Subclasses can override this to set reference data used in the view.

 abstract protected ModelAndView renderFormSubmission(RenderRequest request,
    RenderResponse response,
    Object command,
    BindException errors) throws Exception
Process render phase of 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 rendering the result of a submit action else.
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 privded by showForm.

 protected ModelAndView renderInvalidSubmit(RenderRequest request,
    RenderResponse response) throws Exception 
{
		return renderFormSubmission(request, response, getRenderCommand(request), getRenderErrors(request));
}

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

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(RenderRequest request, RenderResponse response) throws Exception {
return showNewForm(request, response);
}

You can also show a new form but with special errors registered on it:

protected ModelAndView handleInvalidSubmit(RenderRequest request, RenderResponse response) throws Exception {
BindException errors = getErrorsForNewForm(request);
errors.reject("duplicateFormSubmission", "Duplicate form submission");
return showForm(request, response, errors);
}

WARNING: If you override this method, be sure to also override the action phase version of this method so that it will not attempt to perform the resubmit action by default.

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

Set if request parameters should be bound to the form object in case of a non-submitting request, i.e. a new form.

 protected final  void setFormSubmit(ActionResponse response) 
{
		if (logger.isDebugEnabled()) {
			logger.debug("Setting render parameter [" + getFormSubmitParameterName() +
					"] to indicate this is a form submission");
		}
		try {
			response.setRenderParameter(getFormSubmitParameterName(), TRUE);
		}
		catch (IllegalStateException ex) {
			// Ignore in case sendRedirect was already set.
		}
}

Set the action response parameter that indicates this in a form submission.

 protected final  void setInvalidSubmit(ActionResponse response) 
{
		if (logger.isDebugEnabled()) {
			logger.debug("Setting render parameter [" + getInvalidSubmitParameterName() +
					"] to indicate this is an invalid submission");
		}
		try {
			response.setRenderParameter(getInvalidSubmitParameterName(), TRUE);
		}
		catch (IllegalStateException ex) {
			// Ignore in case sendRedirect was already set.
		}
}

Set the action response parameter that indicates this in an invalid submission.

 public  void setRedirectAction(boolean redirectAction) 
{
		this.redirectAction = redirectAction;
}

Specify whether the action phase is expected to call ActionResponse#sendRedirect . This information is important because some methods may not be called before ActionResponse#sendRedirect , e.g. ActionResponse#setRenderParameter and ActionResponse#setRenderParameters .

 public  void setRenderParameters(String[] parameters) 
{
		this.renderParameters = parameters;
}

Specify the list of parameters that should be passed forward from the action phase to the render phase whenever the form is rerendered or when #passRenderParameters is called.

 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.

 abstract protected ModelAndView showForm(RenderRequest request,
    RenderResponse 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(RenderRequest 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(RenderRequest request,
    BindException errors,
    String viewName,
    Map controlModel) throws Exception 
{
		// In session form mode, re-expose form object as portlet 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.getPortletSession().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(RenderRequest request,
    RenderResponse 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.