Spring Validation: Requiring an exact length on an optional field

Question

In Spring MVC, I'm attempting to use annotations to perform validation of form input. I have some fields that are optional, but when input is provided, it must meet certain criteria. For example, I have one field that can be left blank, but when it is filled in, the answer must be exactly five characters long.

I've tried things like

@Size(min=5, max=5)
private String value;

but that gives the user an error if the user doesn't fill in the field.

How can I provide some "rules" for an optional field?

I think this will require a custom validator. – chrylis -cautiouslyoptimistic- Feb 10 '15 at 02:05 — chrylis -cautiouslyoptimistic-, Feb 10 '15 at 02:05
I am using spring boot 2.3. Did not face this issue – SHAKU Sep 21 '20 at 02:55 — SHAKU, Sep 21 '20 at 02:55

score 5 · Answer 1 · answered Feb 10 '15 at 06:23

First option would be to set value to null.

If you take a look at SizeValidatorForCharSequence, used by hibernate:

/**
 * Check that the length of a character sequence is between min and max.
 *
 * @author Emmanuel Bernard
 * @author Gavin King
 * @author Hardy Ferentschik
 */
public class SizeValidatorForCharSequence implements ConstraintValidator<Size, CharSequence> {

    private static final Log log = LoggerFactory.make();

    private int min;
    private int max;

    public void initialize(Size parameters) {
        min = parameters.min();
        max = parameters.max();
        validateParameters();
    }

    /**
     * Checks the length of the specified character sequence (e.g. string).
     *
     * @param charSequence The character sequence to validate.
     * @param constraintValidatorContext context in which the constraint is evaluated.
     *
     * @return Returns <code>true</code> if the string is <code>null</code> or the length of <code>charSequence</code> between the specified
     *         <code>min</code> and <code>max</code> values (inclusive), <code>false</code> otherwise.
     */
    public boolean isValid(CharSequence charSequence, ConstraintValidatorContext constraintValidatorContext) {
        if ( charSequence == null ) {
            return true;
        }
        int length = charSequence.length();
        return length >= min && length <= max;
    }

    private void validateParameters() {
        if ( min < 0 ) {
            throw log.getMinCannotBeNegativeException();
        }
        if ( max < 0 ) {
            throw log.getMaxCannotBeNegativeException();
        }
        if ( max < min ) {
            throw log.getLengthCannotBeNegativeException();
        }
    }
}

Size is invalid only if it's length does not match min, max constraints, and it's fine, if value is null.

Another option would be to create your own annotation and validator:

@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = { StringEmptyOrSizeValidator.class })
public @interface StringEmptyOrSize {

    String message() default "{javax.validation.constraints.Size.message}";

    Class<?>[] groups() default { };

    Class<? extends Payload>[] payload() default { };

    /**
     * @return size the element must be higher or equal to
     */
    int min() default 0;

    /**
     * @return size the element must be lower or equal to
     */
    int max() default Integer.MAX_VALUE;

    /**
     * Defines several {@link Size} annotations on the same element.
     *
     * @see Size
     */
    @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
    @Retention(RUNTIME)
    @Documented
    @interface List {

        Size[] value();
    }
}

with validator

public class StringEmptyOrSizeValidator implements ConstraintValidator<Size, CharSequence> {

    ....
    public boolean isValid(CharSequence charSequence, ConstraintValidatorContext constraintValidatorContext) {
        if ( charSequence == null || charSequence.isEmpty()) {
            return true;
        }
        int length = charSequence.length();
        return length >= min && length <= max;
    }

    ....
}

I assume this is an example of how to write a custom validation annotation? — Marvo, Feb 10 '15 at 19:39

jvleminc · Answer 2 · 2018-09-27T01:52:19.653

0

You could use the @Pattern(regexp="") annotation to allow customized patterns. Afterwards the error can shown with a Pattern.<bean>.value=... in your i12n property files.

Example:

In bean "Person":

Pattern(regexp="^[A-ZÑa-zñÁÉÍÓúáéíóú' -]{3,20}$")
private String names;

In messages.properties:

Pattern.person.names=Please insert a valid name

edited Sep 27 '18 at 01:52

answered Nov 15 '17 at 15:46

jvleminc

71
1
3

Consider expanding your answer. – Tom Aranda Nov 15 '17 at 16:04

score 0 · Answer 3 · answered Aug 24 '19 at 20:37

a more simple solution is to add a method into your class and add @AssertTrue annotation to it like this:

@AssertTrue
public boolean isValidValue() {
        if(this.value == null || this.value.isEmpty()) {
            return true;
        }
        else {
            return this.value.length() == 5 ? false: true;
        }
    }

with this you don't need this: @Size(min=5, max=5)

Spring Validation: Requiring an exact length on an optional field

3 Answers3