Hibernate Validator (Bean Validation)

Introduction

So far, nothing has stopped you from saving an Employee with a blank name or a negative salary — Hibernate will happily generate the INSERT and send it to the database. Hibernate Validator closes that gap by letting you declare validation rules directly on your entity fields, and checking them before the data ever reaches the database.

Hibernate Validator is the reference implementation of Bean Validation (JSR 380 / Jakarta Bean Validation), the same way Hibernate ORM is the reference implementation of JPA. It integrates with Hibernate ORM so that entities are validated automatically at the point they are persisted or updated.

What Is Bean Validation?

Bean Validation is a Java standard for expressing validation rules as annotations on fields, rather than scattering manual if-checks throughout your code. Hibernate Validator implements that standard, and Hibernate ORM automatically triggers it right before an entity is inserted or updated, via a mechanism called pre-persist/pre-update validation.

Adding Hibernate Validator

Hibernate Validator ships as a separate dependency from Hibernate ORM itself. Add it alongside an expression language implementation, which the validator needs to build readable error messages.

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>8.0.1.Final</version>
</dependency>
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>jakarta.el</artifactId>
    <version>4.0.2</version>
</dependency>

Common Validation Annotations

Annotating an Entity

import javax.persistence.*;
import javax.validation.constraints.*;

@Entity
@Table(name = "employees")
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank(message = "Name must not be blank")
    @Size(min = 2, max = 50, message = "Name must be between 2 and 50 characters")
    private String name;

    @NotBlank(message = "Email is required")
    @Email(message = "Email must be a valid address")
    private String email;

    @NotNull(message = "Salary is required")
    @Positive(message = "Salary must be greater than zero")
    private Double salary;

    // Getters and setters
}

Validating Manually

You can validate an object explicitly, without persisting it, using a Validator obtained from a ValidatorFactory. This is useful when you want to check data — for example, from a web form — before you even build the entity for persistence.

import javax.validation.*;
import java.util.Set;

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();

Employee emp = new Employee();
emp.setName("A");
emp.setEmail("not-an-email");
emp.setSalary(-500.0);

Set<ConstraintViolation<Employee>> violations = validator.validate(emp);

for (ConstraintViolation<Employee> violation : violations) {
    System.out.println(violation.getPropertyPath() + ": " + violation.getMessage());
}

Validation on Persist

When Hibernate Validator is on the classpath alongside Hibernate ORM, validation runs automatically right before an entity is inserted or updated — you do not have to call the Validator yourself. A failed check throws a ConstraintViolationException instead of sending an invalid INSERT to the database.

Session session = factory.openSession();
Transaction tx = session.beginTransaction();

try {
    Employee emp = new Employee();
    emp.setName("");
    emp.setEmail("bad-email");
    emp.setSalary(-100.0);

    session.persist(emp);
    tx.commit();
} catch (javax.validation.ConstraintViolationException e) {
    tx.rollback();
    e.getConstraintViolations().forEach(v ->
        System.out.println(v.getPropertyPath() + ": " + v.getMessage())
    );
} finally {
    session.close();
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Hibernate Validator lets you declare data quality rules right where your entity fields are defined, and enforces them automatically before persistence. Combined with transactions from the previous lesson, it ensures both consistency and correctness for every write your application makes.