Java annotation for Null but neither Empty nor Blank

Question

Is there are any java annotation(s) that can validate like the example below?

String test;
test = null; //valid
test = ""; //invalid
test = " "; //invalid
test = "Some values"; //valid

Answer 1

You need to create a custom annotation: @NullOrNotBlank

First create the custom annotation: NullOrNotBlank.java

@Target( {ElementType.FIELD})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = NullOrNotBlankValidator.class)
public @interface NullOrNotBlank {
    String message() default "{javax.validation.constraints.NullOrNotBlank.message}";
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default {};
}

Then the actual validator: NullOrNotBlankValidator.java

public class NullOrNotBlankValidator implements ConstraintValidator<NullOrNotBlank, String> {

    public void initialize(NullOrNotBlank parameters) {
        // Nothing to do here
    }

    public boolean isValid(String value, ConstraintValidatorContext constraintValidatorContext) {
        return value == null || value.trim().length() > 0;
    }
}

Answer 2

There isn't such an annotation in either javax.validation or Hibernate Validator. There was a request to add one to Hibernate Validator but it was closed as "won't fix" due to the possibility of writing your own relatively easily. The suggest solution was to either use your own annotation type defined like this:

@ConstraintComposition(OR)
@Null
@NotBlank
@ReportAsSingleViolation
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Constraint(validatedBy = { })
public @interface NullOrNotBlank {
    String message() default "{org.hibernate.validator.constraints.NullOrNotBlank.message}";
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default { };
}

or to use the @Pattern annotation with a regular expression that requires a non-whitespace character to be present (as the Pattern annotation accepts nulls and does not match them against the pattern).

Answer 3

This is possible without creating a custom annotation, by using javax.validation.constraints.Size

// Null values are considered valid
@Size(min=1) String test;

However as theprogrammer points out, blank strings such as " " are considered valid, which is not the case for @NotBlank.

Answer 4

Where is a nice javax.validation.constraints.Pattern annotation.

You can annotate the field with:

@Pattern(regexp = "^(?!\\s*$).+", message = "must not be blank")

This checks if field matches regex. The regex itself is something but not blank (see details here). It uses negative lookahead.

Answer 5

The best way is to create your own constraint validator,

//custom annotation
@Documented
@Constraint(validatedBy = CustomCheck.class)
@Target( { ElementType.METHOD, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomConstarint {
    String message() default "Invalid data";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
} 

//validation logic goes here
public class CustomCheck implements 
  ConstraintValidator<CustomConstarint, String> {
 
    @Override
    public void initialize(CustomConstarint customConstarint) {
    }
 
    @Override
    public boolean isValid(String field,
      ConstraintValidatorContext cxt) {
        //write your logic to validate the field
    }
}

Answer 6

Did you try Hibernate-Validator? I think that's what you are looking for.

import javax.validation.constraints.NotNull;

import org.hibernate.validator.constraints.NotBlank;
import org.hibernate.validator.constraints.NotEmpty;

public class MyModel  {

    @NotNull
    private String  str1;

    @NotEmpty
    private String  str2;

    @NotBlank
    private String  str3;

}