@NotEmpty: a constrained CharSequence, Collection, Map, or Array is valid as long as it's not null, and its size/length is greater than zero. @NotBlank: a constrained String is valid as long as it's not null, and the trimmed length is greater than zero.
The @NotNull annotation is, actually, an explicit contract declaring that: A method should not return null. Variables (fields, local variables, and parameters) cannot hold a null value.
The Javax bean validation API provides the following most frequently used annotations. The Hibernate validator provides the following commonly used annotations for validation. In case of product or project development we must use both the annotations for bean validation.
Hibernate Validator allows to express and validate application constraints. The default metadata source are annotations, with the ability to override and extend through the use of XML. It is not tied to a specific application tier or programming model and is available for both server and client application programming.
@NotNull
: The CharSequence, Collection, Map or Array object is not null, but can be empty.@NotEmpty
: The CharSequence, Collection, Map or Array object is not null and size > 0.@NotBlank
: The string is not null and the trimmed length is greater than zero.
To help you understand, let's look into how these constraints are defined and carried out (I'm using version 4.1):
The @NotNull
constraint is defined as:
@Constraint(validatedBy = {NotNullValidator.class})
This class has an isValid
method defined as:
public boolean isValid(Object object, ConstraintValidatorContext constraintValidatorContext) {
return object != null;
}
The @NotEmpty
constraint is defined as:
@NotNull
@Size(min = 1)
So this constraint uses the @NotNull
constraint above, and @Size
whose definition differs based on the object but should be self explanitory.
Finally, the @NotBlank
constraint is defined as:
@NotNull
@Constraint(validatedBy = {NotBlankValidator.class})
So this constraint also uses the @NotNull
constraint, but also constrains with the NotBlankValidator class. This class has an isValid
method defined as:
if ( charSequence == null ) { //curious
return true;
}
return charSequence.toString().trim().length() > 0;
Interestingly, this method returns true if the string is null, but false if and only if the length of the trimmed string is 0. It's ok that it returns true if it's null because, as I mentioned, the @NotEmpty
definition also requires @NotNull
.
Here are a few examples:
String name = null;@NotNull
: false@NotEmpty
: false@NotBlank
: false
String name = "";@NotNull
: true@NotEmpty
: false@NotBlank
: false
String name = " ";@NotNull
: true@NotEmpty
: true@NotBlank
: false
String name = "Great answer!";@NotNull
: true@NotEmpty
: true@NotBlank
: true
I liked the explanation in the below link: http://www.itprogrammingtutorials.com/2015/java/hibernate/hibernate-validator-diff-notblank-notempty/
@NotNull: Checks whether the value is not null, disregarding the content
@NotEmpty: Checks whether the value is not null nor empty. If it has just empty spaces, it will allow it as not empty.
@NotBlank: Checks whether the value is not null nor empty, trimming the value first. It means that, it won’t allow just empty spaces.
So, if you want to validate that a field is not null but also that it doesn’t has just empty spaces, but text, you should use @NotBlank.
@NotNull:
a constrained CharSequence, Collection, Map, or Array is
valid as long as it’s not null, but it can be empty@NotEmpty:
a constrained CharSequence, Collection, Map, or Array
is valid as long as it’s not null and its size/length is greater
than zero.@NotBlank:
a constrained String is valid as long as it’s not null
and the trimmed length is greater than zero.If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With