"required" behavior not adapted well to submit
I wrote some code to read the "not-null" property names from a Hibernate configuration file, converted the names to a "required" String array, and assigned the "required" array in an initBinder() override in my form class. The purpose is to eliminate the need to write separate validator routines simply to check whether a form input is null or empty. Ultimately, I wanted to add other "automatic" validations based upon length and type specified in the Hibernate configuration, but I wanted to try a test case first.
I implemented the test code in the petclinic application in class AbstractClinicForm as follows:
Code:
protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder)
throws Exception {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
dateFormat.setLenient(false);
binder.registerCustomEditor(Date.class, null, new CustomDateEditor(dateFormat, false));
// end pre-existing code
// begin added code:
// Assign required fields as defined in the schema to the data binder:
Object currentDataObject = binder.getTarget();
// getSchematicInfo() returns a link to the Hibernate schema information:
String requiredPropertyNames[] = getSchemaInfo().requiredFields(currentDataObject.getClass());
binder.setRequiredFields(requiredPropertyNames);
}
Hence, for the Owner forms, this would set up a required String array consisting of the following names:
Now, when I run petclinic with the above modification, EditOwnerForm works fine, but FindOwnersForm silently fails; it simply doesn't recognize the input. Sleuthing reveals that Spring's required code fails validation because the other fields that are not on the FindOwnersForm are null and thereby fail.
I can fix the above code to work by checking to see if the request parameter being "required" validated is even present and, if it isn't, drop its name from the String array of "required" names. The following code does this exactly:
Code:
protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder)
throws Exception {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
dateFormat.setLenient(false);
binder.registerCustomEditor(Date.class, null, new CustomDateEditor(dateFormat, false));
// Assign required fields as defined in the schema to the data binder:
Object currentDataObject = binder.getTarget();
String requiredPropertyNames[] = getSchemaInfo().requiredFields(currentDataObject.getClass());
List importantPropertyNames = new ArrayList();
for (int i = 0 ; i < requiredPropertyNames.length ; i++)
{
String thisName = requiredPropertyNames[i];
if (request.getParameter(thisName) != null)
{
importantPropertyNames.add(thisName);
}
}
requiredPropertyNames = new String[importantPropertyNames.size()];
for (int i = 0 ; i < importantPropertyNames.size() ; i++)
{
requiredPropertyNames[i] = (String) importantPropertyNames.get(i);
}
binder.setRequiredFields(requiredPropertyNames);
}
Here's the problem: this is clunky. Cannot the "schema-oriented" validations like required have a property flag added to not validate if the corresponding request parameter is null? Consider the code in DataBinder#bind(PropertyValues) that implements the "required" functionality:
Code:
...
// check for missing fields
if (this.requiredFields != null) {
for (int i = 0; i < this.requiredFields.length; i++) {
PropertyValue pv = pvs.getPropertyValue(this.requiredFields[i]);
if (pv == null || "".equals(pv.getValue()) || pv.getValue() == null) {
// create field error with code "required"
String field = this.requiredFields[i];
this.errors.addError(
new FieldError(this.errors.getObjectName(), field, "", true,
this.errors.resolveMessageCodes(MISSING_FIELD_ERROR_CODE, field),
getArgumentsForBindingError(field), "Field '" + field + "' is required"));
}
}
}
...
Consider changing the second if statement to read:
Code:
if (pv == null || "".equals(pv.getValue()) || (pv.getValue() == null && !canBeNull)) {
where you can see that the getValue() is only tested for null if canBeNull is false. canBeNull is a property that can be configured in the Spring configuration file and is false by default.
Now the required validation can work both ways, but we've added the power to optionally automate the schema-oriented validations for HTML input: not-null, length, and type.
What do you think?
Thanks for following the long read (that is, if you got this far :roll: )
I think I got the logic sense right
I think the sense of the logic in the proposed "if" statement is correct. I haven't tried it yet.
New "Required" Binding Framework
:idea: I've updated petclinic to switch between two meanings of required:- :arrow: validate as though request parameter was required regardless of whether the request parameter existed.
- :arrow: validate required only if request parameter exists.
This functionality is implemented as follows: - :arrow: AbstractClinicForm overrides createBinder() to create SchemaDataBinder.
- :arrow: SchemaDataBinder which subclasses ServletRequestDataBinder to implement bind(PropertyValues) as described above
Listing of SchemaDataBinder
Particularly note the highlighted (********) section:
Code:
package org.springframework.validation;
import java.util.Arrays;
import java.util.List;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyAccessException;
import org.springframework.beans.PropertyAccessExceptionsException;
import org.springframework.beans.PropertyValue;
import org.springframework.beans.PropertyValues;
import org.springframework.web.bind.ServletRequestDataBinder;
/**
* This data binder ignores the "required" validation
* if the value to be validated is not returned in the
* request parameters.
*
* @author Blotto [scott.smith@wamu.net]
* @version $Id$
*/
public class SchemaDataBinder extends ServletRequestDataBinder
{
/**
* If true, then if a required field isn't represented
* in the request parameters, then don't apply the required validation.
* If false, then apply the required validation in all cases.
*/
private boolean validateExisting;
/**
* The constructor.
*
* @param target target object to bind onto
* @param objectName objectName of the target object
* @param validateExisting whether to test only existing
* request parameters
*/
public SchemaDataBinder(Object target, String objectName, boolean validateExisting)
{
super(target, objectName);
this.validateExisting = validateExisting;
}
/**
* Like the super method except that this
* one doesn't create a required validation error if the
* value to be validated isn't in the request parameters.
*
* @param pvs property values to bind.
* @see DataBinder#bind(PropertyValues)
*/
public void bind(PropertyValues pvs) {
// check for fields to bind
String[] allowedFields = getAllowedFields();
List allowedFieldsList = (allowedFields != null) ? Arrays.asList(allowedFields) : null;
MutablePropertyValues mpvs = (pvs instanceof MutablePropertyValues) ?
(MutablePropertyValues) pvs : new MutablePropertyValues(pvs);
PropertyValue[] pvArray = pvs.getPropertyValues();
for (int i = 0; i < pvArray.length; i++) {
String field = pvArray[i].getName();
if (!((allowedFieldsList != null && allowedFieldsList.contains(field)) || isAllowed(field))) {
mpvs.removePropertyValue(pvArray[i]);
}
}
pvs = mpvs;
// check for missing fields
String[] requiredFields = getRequiredFields();
if (requiredFields != null) {
for (int i = 0; i < requiredFields.length; i++) {
PropertyValue pv = pvs.getPropertyValue(requiredFields[i]);
// *************************************************
// Here is where the modification is performed:
boolean requiredFailed = (validateExisting)
? (pv != null && "".equals(pv.getValue()))
: (pv == null || "".equals(pv.getValue()) || pv.getValue() == null);
if (requiredFailed) {
// End of modification
// *************************************************
// create field error with code "required"
String field = requiredFields[i];
BindException errors = getErrors();
errors.addError(
new FieldError(errors.getObjectName(), field, "", true,
errors.resolveMessageCodes(MISSING_FIELD_ERROR_CODE, field),
getArgumentsForBindingError(field), "Field '" + field + "' is required"));
}
}
}
try {
// bind request parameters onto params, ignoring unknown properties
getErrors().getBeanWrapper().setPropertyValues(pvs, true);
}
catch (PropertyAccessExceptionsException ex) {
PropertyAccessException[] exs = ex.getPropertyAccessExceptions();
for (int i = 0; i < exs.length; i++) {
// create field with the exceptions's code, e.g. "typeMismatch"
String field = exs[i].getPropertyChangeEvent().getPropertyName();
BindException errors = getErrors();
errors.addError(
new FieldError(errors.getObjectName(), field, exs[i].getPropertyChangeEvent().getNewValue(), true,
errors.resolveMessageCodes(exs[i].getErrorCode(), field),
getArgumentsForBindingError(field), exs[i].getLocalizedMessage()));
}
}
}
}
Here are the modified methods in AbstractClinicForm.
First, the property which defines which
required behavior is in effect:
Code:
private boolean requiredValidateExisting;
public boolean isRequiredValidateExisting()
{
return requiredValidateExisting;
}
/**
* sets whether or not to suppress <b>required</b> validation
* when the value to be validated isn't in the HTTP request
* parameters.
*
* @param requiredValidateExisting
*/
public void setRequiredValidateExisting(boolean requiredValidateExisting)
{
this.requiredValidateExisting = requiredValidateExisting;
}
Here's the override to utilize a different binder object:
Code:
/**
* Create a new binder instance for the given command and request.
* Called by bindAndValidate. This overrides the custom
* ServletRequestDataBinder with a SchemaDataBinder.
* @param request current HTTP request
* @param command the command to bind onto
* @return the new binder instance
* @throws Exception in case of invalid state or arguments
* @see #bindAndValidate
* @see #initBinder
* @see #setMessageCodesResolver
*/
protected ServletRequestDataBinder createBinder(HttpServletRequest request, Object command)
throws Exception {
SchemaDataBinder binder = new SchemaDataBinder(command, getCommandName(), requiredValidateExisting);
MessageCodesResolver messageCodesResolver = getMessageCodesResolver();
if (messageCodesResolver != null) {
binder.setMessageCodesResolver(messageCodesResolver);
}
initBinder(request, binder);
return binder;
}
Here is initBinder() which adds the required fields from the schema:
Code:
/**
* Set up a custom property editor for the application's date format.
* Also, retrieve the "required" fields from the corresponding not-null
* columns in the database schema.
*/
protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder)
throws Exception {
super.initBinder(request, binder);
registerDateFormat(binder);
registerRequired(request, binder);
}
/**
* Retrieves the "required" fields from the corresponding not-null
* columns in the database schema.
*
* @param binder what binder to assign the "required" fields to.
*/
private void registerRequired(HttpServletRequest request, ServletRequestDataBinder binder)
throws Exception
{
Object currentDataObject = binder.getTarget();
String requiredPropertyNames[] = getSchemaInfo().requiredFields(currentDataObject.getClass());
binder.setRequiredFields(requiredPropertyNames);
}
/**
* registers a date property editor
*
* @param binder the binder to register to.
*/
protected void registerDateFormat(ServletRequestDataBinder binder)
{
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
dateFormat.setLenient(false);
binder.registerCustomEditor(Date.class, null, new CustomDateEditor(dateFormat, false));
}
Finally, the section of petclinic-servlet.xml that configures AbstractClinicForm:
Code:
<bean id="abstractClinicForm" abstract="true"
class="org.springframework.samples.petclinic.web.AbstractClinicForm">
<!-- The class that implements the SchemaInfo interface to -->
<!-- answer the required fields for this data object: -->
<property name="schemaInfo"><ref bean="hibernateSchemaInfo"/></property>
<!-- Whether or not to ignore "required" validation of values -->
<!-- that are not in the request parameters -->
<property name="requiredValidateExisting"><value>true</value></property>
</bean>
This code has been tested and works for HTML input forms. It has not yet been checked w/ checkboxes and radio buttons.
Above post should be integrated into DataBinder
I propose integrating the ideas in the above post into DataBinder and BaseCommandController directly. The default functionality would match the existing functionality, but setting the property requiredValidateExisting in BaseCommandController would cause the new behavior to take place. Of course, radio button and checkbox operation should be verified first.
