null.
* Subclasses can override this to set reference data used in the view.
* @param request current HTTP request
* @return a Map with reference data entries, or <code>null if none
* @throws Exception in case of invalid state or arguments
* @see #referenceData(HttpServletRequest, Object, Errors)
* @see ModelAndView
*/
protected Map referenceData(HttpServletRequest request) throws Exception {
return null;
}
/**
* This implementation calls
* {@link #showForm(HttpServletRequest, HttpServletResponse, BindException)}
* in case of errors, and delegates to the full
* {@link #onSubmit(HttpServletRequest, HttpServletResponse, Object, BindException)}'s
* variant else.
* <p>This can only be overridden to check for an action that should be executed
* without respect to binding errors, like a cancel action. To just handle successful
* submissions without binding errors, override one of the <code>onSubmit
* methods or {@link #doSubmitAction}.
* @see #showForm(HttpServletRequest, HttpServletResponse, BindException)
* @see #onSubmit(HttpServletRequest, HttpServletResponse, Object, BindException)
* @see #onSubmit(Object, BindException)
* @see #onSubmit(Object)
* @see #doSubmitAction(Object)
*/
protected ModelAndView processFormSubmission(
HttpServletRequest request, HttpServletResponse response, Object command, BindException errors)
throws Exception {
if (errors.hasErrors()) {
if (logger.isDebugEnabled()) {
logger.debug("Data binding errors: " + errors.getErrorCount());
}
return showForm(request, response, errors);
}
else if (isFormChangeRequest(request, command)) {
logger.debug("Detected form change request -> routing request to onFormChange");
onFormChange(request, response, command, errors);
return showForm(request, response, errors);
}
else {
logger.debug("No errors -> processing submit");
return onSubmit(request, response, command, errors);
}
}
/**
* This implementation delegates to {@link #isFormChangeRequest(HttpServletRequest, Object)}:
* A form change request changes the appearance of the form and should not get
* validated but just show the new form.
* @see #isFormChangeRequest
*/
protected boolean suppressValidation(HttpServletRequest request, Object command) {
return isFormChangeRequest(request, command);
}
/**
* Determine whether the given request is a form change request.
* A form change request changes the appearance of the form
* and should always show the new form, without validation.
* <p>Gets called by {@link #suppressValidation} and {@link #processFormSubmission}.
* Consequently, this single method determines to suppress validation
* <i>and to show the form view in any case.
* <p>The default implementation delegates to
* {@link #isFormChangeRequest(javax.servlet.http.HttpServletRequest)}.
* @param request current HTTP request
* @param command form object with request parameters bound onto it
* @return whether the given request is a form change request
* @see #suppressValidation
* @see #processFormSubmission
*/
protected boolean isFormChangeRequest(HttpServletRequest request, Object command) {
return isFormChangeRequest(request);
}
/**
* Simpler <code>isFormChangeRequest variant, called by the full
* variant {@link #isFormChangeRequest(HttpServletRequest, Object)}.
* <p>The default implementation returns false. Allows subclasses to implement custom logic
* to modify the command object to directly modify data in the form.
* <p>The default implementation delegates to
* {@link #onFormChange(HttpServletRequest, HttpServletResponse, Object, BindException)}.
* @param request current servlet request
* @param response current servlet response
* @param command form object with request parameters bound onto it
* @param errors validation errors holder, allowing for additional
* custom validation
* @throws Exception in case of errors
* @see #isFormChangeRequest(HttpServletRequest)
* @see #onFormChange(HttpServletRequest, HttpServletResponse, Object)
*/
protected void onFormChange(
HttpServletRequest request, HttpServletResponse response, Object command, BindException errors)
throws Exception {
onFormChange(request, response, command);
}
/**
* Simpler <code>onFormChange variant, called by the full variant
* {@link #onFormChange(HttpServletRequest, HttpServletResponse, Object, BindException)}.
* <p>The default implementation is empty.
* @param request current servlet request
* @param response current servlet response
* @param command form object with request parameters bound onto it
* @throws Exception in case of errors
* @see #onFormChange(HttpServletRequest, HttpServletResponse, Object, BindException)
*/
protected void onFormChange(HttpServletRequest request, HttpServletResponse response, Object command)
throws Exception {
}
/**
* Submit callback with all parameters. Called in case of submit without errors
* reported by the registered validator, or on every submit if no validator.
* <p>The default implementation delegates to {@link #onSubmit(Object, BindException)}.
* For simply performing a submit action and rendering the specified success
* view, consider implementing {@link #doSubmitAction} rather than an
* <code>onSubmit variant.
* <p>Subclasses can override this to provide custom submission handling like storing
* the object to the database. Implementations can also perform custom validation and
* call showForm to return to the form. Do <i>not implement multiple onSubmit
* methods: In that case, just this method will be called by the controller.
* <p>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.
* @param request current servlet request
* @param response current servlet response
* @param command form object with request parameters bound onto it
* @param errors Errors instance without errors (subclass can add errors if it wants to)
* @return the prepared model and view, or <code>null
* @throws Exception in case of errors
* @see #onSubmit(Object, BindException)
* @see #doSubmitAction
* @see #showForm
* @see org.springframework.validation.Errors
* @see org.springframework.validation.BindException#getModel
*/
protected ModelAndView onSubmit(
HttpServletRequest request, HttpServletResponse response, Object command, BindException errors)
throws Exception {
return onSubmit(command, errors);
}
/**
* Simpler <code>onSubmit variant.
* Called by the default implementation of the
* {@link #onSubmit(HttpServletRequest, HttpServletResponse, Object, BindException)}
* variant with all parameters.
* <p>The default implementation calls {@link #onSubmit(Object)}, using the
* returned ModelAndView if actually implemented in a subclass. Else, the
* default behavior will apply: rendering the success view with the command
* and Errors instance as model.
* <p>Subclasses can override this to provide custom submission handling that
* does not need request and response.
* <p>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.
* @param command form object with request parameters bound onto it
* @param errors Errors instance without errors
* @return the prepared model and view
* @throws Exception in case of errors
* @see #onSubmit(HttpServletRequest, HttpServletResponse, Object, BindException)
* @see #onSubmit(Object)
* @see #setSuccessView
* @see org.springframework.validation.Errors
* @see org.springframework.validation.BindException#getModel
*/
protected ModelAndView onSubmit(Object command, BindException errors) throws Exception {
ModelAndView mv = onSubmit(command);
if (mv != null) {
// simplest onSubmit variant implemented in custom subclass
return mv;
}
else {
// default behavior: render success view
if (getSuccessView() == null) {
throw new ServletException("successView isn't set");
}
return new ModelAndView(getSuccessView(), errors.getModel());
}
}
/**
* Simplest <code>onSubmit variant. Called by the default implementation
* of the {@link #onSubmit(Object, BindException)} variant.
* <p>This implementation calls {@link #doSubmitAction(Object)} and returns
* <code>null as ModelAndView, making the calling onSubmit
* method perform its default rendering of the success view.
* <p>Subclasses can override this to provide custom submission handling
* that just depends on the command object. It's preferable to use either
* {@link #onSubmit(Object, BindException)} or {@link #doSubmitAction(Object)},
* though: Use the former when you want to build your own ModelAndView; use the
* latter when you want to perform an action and forward to the successView.
* @param command form object with request parameters bound onto it
* @return the prepared model and view, or <code>null for default
* (that is, rendering the configured "successView")
* @throws Exception in case of errors
* @see #onSubmit(Object, BindException)
* @see #doSubmitAction
* @see #setSuccessView
*/
protected ModelAndView onSubmit(Object command) throws Exception {
doSubmitAction(command);
return null;
}
/**
* Template method for submit actions. Called by the default implementation
* of the simplest {@link #onSubmit(Object)} variant.
* <p>This is the preferred submit callback to implement if you want to
* perform an action (like storing changes to the database) and then render
* the success view with the command and Errors instance as model.</b>
* You don't need to care about the success ModelAndView here.
* @param command form object with request parameters bound onto it
* @throws Exception in case of errors
* @see #onSubmit(Object)
* @see #setSuccessView
*/
protected void doSubmitAction(Object command) throws Exception {
}
}
Other Spring Framework examples (source code examples)
Here is a short list of links related to this Spring Framework SimpleFormController.java source code file:
The search page
Other Spring Framework source code examples at this package level
Click here to learn more about this project
Spring Framework example source code file (SimpleFormController.java)
The Spring Framework SimpleFormController.java source code/*
* Copyright 2002-2007 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.mvc;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.validation.BindException;
import org.springframework.validation.Errors;
import org.springframework.web.servlet.ModelAndView;
/**
* <p>Concrete FormController implementation that provides configurable
* form and success views, and an onSubmit chain for convenient overriding.
* Automatically resubmits to the form view in case of validation errors,
* and renders the success view in case of a valid submission.</p>
*
* <p>The workflow of this Controller does not differ much from the one described
* in the {@link AbstractFormController AbstractFormController}. The difference
* is that you do not need to implement {@link #showForm showForm} and
* {@link #processFormSubmission processFormSubmission}: A form view and a
* success view can be configured declaratively.</p>
*
* <p>Workflow
* (<a href="AbstractFormController.html#workflow">in addition to the superclass): |
