Custom Validators | Validation | Hibernate Tutorial

Introduction

In Hibernate, validation is a crucial aspect of ensuring data integrity and correctness. While Hibernate provides a set of built-in validators, there are scenarios where custom validation logic is required. Custom validators allow developers to define their own validation rules tailored to specific business needs. This tutorial will guide you through the process of creating and using custom validators in Hibernate.

Setting Up Hibernate Validator

Before creating custom validators, ensure that you have Hibernate Validator set up in your project. You can include it in your Maven project by adding the following dependency in your pom.xml file:


                    <dependency>

                      <groupId>org.hibernate.validator</groupId>

                      <artifactId>hibernate-validator</artifactId>

                      <version>6.0.13.Final</version>

                    </dependency>

After adding the dependency, make sure to refresh your project to download the necessary libraries.

Creating a Custom Validator

To create a custom validator, you need to define an annotation and a class that implements the validation logic. Here's a step-by-step process:

Step 1: Define the Annotation

Create a custom annotation called ValidAge that can be used to validate an age field. This annotation will include metadata about the validation.


                    import javax.validation.Constraint;

                    import javax.validation.Payload;

                    import java.lang.annotation.ElementType;

                    import java.lang.annotation.Retention;

                    import java.lang.annotation.RetentionPolicy;

                    import java.lang.annotation.Target;


                    @Target({ ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.PARAMETER })

                    @Retention(RetentionPolicy.RUNTIME)

                    @Constraint(validatedBy = AgeValidator.class)

                    public @interface ValidAge {

                      String message() default "Age must be between 18 and 65";

                      Class[] groups() default {};

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

                    }

Step 2: Implement the Validator

Next, create the AgeValidator class that implements the actual validation logic.


                    import javax.validation.ConstraintValidator;

                    import javax.validation.ConstraintValidatorContext;


                    public class AgeValidator implements ConstraintValidator<ValidAge, Integer> {

                      @Override

                      public void initialize(ValidAge constraintAnnotation) { }


                      @Override

                      public boolean isValid(Integer age, ConstraintValidatorContext context) {

                        if (age == null) {

                          return true; // null values are valid (we can use @NotNull for that)

                        }

                        return age >= 18 && age <= 65;

                      }

                    }

Using the Custom Validator

Now that we have our custom validator, we can use it in an entity class. Here's how to apply the ValidAge annotation to an entity's field.


                    import javax.persistence.Entity;

                    import javax.persistence.Id;


                    @Entity

                    public class User {

                        @Id

                        private Long id;


                        @ValidAge

                        private Integer age;


                         // getters and setters

                    }

With the custom validator applied, Hibernate will now validate the age field according to the rules defined in AgeValidator.

Testing the Custom Validator

To test the custom validator, you can use a simple main method or a unit test. Here’s an example of how to validate a User object:


                    import javax.validation.Validation;

                    import javax.validation.Validator;

                    import javax.validation.ValidatorFactory;

                    import javax.validation.ConstraintViolation;

                    import java.util.Set;


                    public class Main {

                      public static void main(String[] args) {

                        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();

                        Validator validator = factory.getValidator();


                        User user = new User();

                        user.setAge(17);


                        Set<ConstraintViolation<User>> violations = validator.validate(user);


                        if (!violations.isEmpty()) {

                          for (ConstraintViolation<User> violation : violations) {

                            System.out.println(violation.getMessage());

                          }

                        } else {

                          System.out.println("Validation passed!");

                        }

                    }
                    }

This code will print the error message "Age must be between 18 and 65" if the age is less than 18 or greater than 65.

Conclusion

Custom validators in Hibernate provide a powerful way to enforce specific validation rules that go beyond the built-in capabilities. By following the steps outlined in this tutorial, you can create and implement your own custom validators to ensure that your entity data adheres to your business logic and requirements.

Custom Validators in Hibernate