3. Dependencies

In the latest version of spring-boot-starter-validation, besides other dependencies, transitive dependency of hibernate-validator will be available.

If you want to add just the dependency for validation you can simply add the hibernate-validator in you pom.xml.

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>8.0.0.Final</version>
</dependency>

A quick note: hibernate-validator is entirely separate from the persistence aspects of Hibernate. So, by adding it as a dependency, we're not adding these persistence aspects into the project.

4. Using Validation Annotations

Here, we'll take a User bean and work on adding some simple validation to it:

import jakarta.validation.constraints.AssertTrue;
import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import jakarta.validation.constraints.Email;
public class User {
    @NotNull(message = "Name cannot be null")
    private String name;
    @AssertTrue
    private boolean working;
    @Size(min = 10, max = 200, message 
      = "About Me must be between 10 and 200 characters")
    private String aboutMe;
    @Min(value = 18, message = "Age should not be less than 18")
    @Max(value = 150, message = "Age should not be greater than 150")
    private int age;
    @Email(message = "Email should be valid")
    private String email;
    // standard setters and getters 
All of the annotations used in the example are standard JSR annotations:

@NotNull validates that the annotated property value is not null.
@AssertTrue validates that the annotated property value is true.
@Size validates that the annotated property value has a size between the attributes min and max; can be applied to String, Collection, Map, and array properties.
@Min validates that the annotated property has a value no smaller than the value attribute.
@Max validates that the annotated property has a value no larger than the value attribute.
@Email validates that the annotated property is a valid email address.
Some annotations accept additional attributes, but the message attribute is common to all of them. This is the message that will usually be rendered when the value of the respective property fails validation.
And some additional annotations that can be found in the JSR:
@NotEmpty validates that the property is not null or empty; can be applied to String, Collection, Map or Array values.
@NotBlank can be applied only to text values and validates that the property is not null or whitespace.
@Positive and @PositiveOrZero apply to numeric values and validate that they are strictly positive, or positive including 0.
@Negative and @NegativeOrZero apply to numeric values and validate that they are strictly negative, or negative including 0.
@Past and @PastOrPresent validate that a date value is in the past or the past including the present; can be applied to date types including those added in Java 8.
@Future and @FutureOrPresent validate that a date value is in the future, or in the future including the present.
The validation annotations can also be applied to elements of a collection:
List<@NotBlank String> preferences;
In this case, any value added to the preferences list will be validated.
Also, the specification supports the new Optional type in Java 8:

private LocalDate dateOfBirth;
public Optional<@Past LocalDate> getDateOfBirth() {
    return Optional.of(dateOfBirth);
Here, the validation framework will automatically unwrap the LocalDate value and validate it.
5. Programmatic Validation
Some frameworks — such as Spring — have simple ways to trigger the validation process by just using annotations. This is mainly so that we don't have to interact with the programmatic validation API.
Now let's go the manual route and set things up programmatically:
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
To validate a bean, we first need a Validator object, which is built using a ValidatorFactory.
5.1. Defining the Bean
We're now going to set up this invalid user — with a null name value:
User user = new User();
user.setWorking(true);
user.setAboutMe("Its all about me!");
user.setAge(50);
5.2. Validate the Bean
Now that we have a Validator, we can validate our bean by passing it to the validate method.
Any violations of the constraints defined in the User object will be returned as a Set:
Set<ConstraintViolation<User>> violations = validator.validate(user);
By iterating over the violations, we can get all the violation messages using the getMessage method:

for (ConstraintViolation<User> violation : violations) {
    log.error(violation.getMessage()); 
In our example (ifNameIsNull_nameValidationFails), the set would contain a single ConstraintViolation with the message “Name cannot be null”.
6. Conclusion
This article focused on a simple pass through the standard Java Validation API. We showed the basics of bean validation using jakarta.validation annotations and APIs.
As usual, an implementation of the concepts in this article and all code snippets can be found over on GitHub.
Partner – AEGIK AB – NPI EA (tag = SQL)


Slow MySQL query performance is all too common. Of course
it is. A good way to go is, naturally, a dedicated profiler that
actually understands the ins and outs of MySQL.
The Jet Profiler was built for MySQL only, so it can do
things like real-time query performance, focus on most used tables
or most frequent queries, quickly identify performance issues and
basically help you optimize your queries.
Critically, it has very minimal impact on your server's
performance, with most of the profiling work done separately - so
it needs no server changes, agents or separate services.
Basically, you install the desktop application, connect to your MySQL
server, hit the record button, and you'll have results
within minutes:
out the Profiler

Course – LS – All

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:
>> CHECK OUT THE COURSE
res – REST with Spring (eBook) (everywhere)

Learning to build your API

with Spring?
Download the E-book