ValidatorBean

spring.jpa.properties.javax.persistence.validation.mode=auto

# Enable debug logging for validation
logging.level.org.springframework.validation=DEBUG
logging.level.org.hibernate.validator=DEBUG
logging.level.your.package.name=DEBUG

import javax.validation.constraints.NotBlank;

public class User {
    @NotBlank(message = "Username cannot be blank")
    private String username;

    // Getters and Setters
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;

import javax.validation.Validator;

@Configuration
public class ValidatorConfig {

    @Bean
    public Validator validator() {
        return new LocalValidatorFactoryBean();
    }
}



import org.springframework.stereotype.Service;
import javax.validation.ConstraintViolation;
import javax.validation.Validator;
import java.util.Set;

@Service
public class StudentService {

    private final Validator validator;

    // Injecting the Validator bean
    public StudentService(Validator validator) {
        this.validator = validator;
    }

    public void createStudent(Student student) {
        // Validate the student object
        Set<ConstraintViolation<Student>> violations = validator.validate(student);

        if (!violations.isEmpty()) {
            StringBuilder errors = new StringBuilder("Validation failed: ");
            for (ConstraintViolation<Student> violation : violations) {
                errors.append(violation.getPropertyPath()).append(" ").append(violation.getMessage()).append("; ");
            }
            throw new IllegalArgumentException(errors.toString());
        }

        // Proceed with saving the student if validation passes
        // entityManager.persist(student); // Your persistence logic here
    }
}



----

@Configuration
public class ValidationConfig {
    
    @Bean
    public Validator validator() {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        return factory.getValidator();
    }

    @Bean
    public LocalValidatorFactoryBean localValidatorFactoryBean() {
        return new LocalValidatorFactoryBean();
    }

    @Bean 
    public MethodValidationPostProcessor methodValidationPostProcessor() {
        return new MethodValidationPostProcessor();
    }
}


@Service
@Validated
public class StudentService {
    private final Validator validator;
    private final EntityManager entityManager;

    @Autowired
    public StudentService(Validator validator, EntityManager entityManager) {
        this.validator = validator;
        this.entityManager = entityManager;
    }

    @Transactional
    public void saveStudent(@Valid Student student) {
        Set<ConstraintViolation<Student>> violations = validator.validate(student);
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
        entityManager.persist(student);
    }
}


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


import org.hibernate.validator.HibernateValidator;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;

@Configuration
public class ValidationConfig {

    @Bean
    public ValidatorFactory validatorFactory() {
        return Validation.byProvider(HibernateValidator.class)
            .configure()
            .buildValidatorFactory();
    }

    @Bean
    public Validator validator(ValidatorFactory validatorFactory) {
        return validatorFactory.getValidator();
    }

    @Bean
    public LocalValidatorFactoryBean localValidatorFactoryBean() {
        LocalValidatorFactoryBean bean = new LocalValidatorFactoryBean();
        bean.setProviderClass(HibernateValidator.class);
        return bean;
    }

    @Bean
    public MethodValidationPostProcessor methodValidationPostProcessor(Validator validator) {
        MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
        processor.setValidator(validator);
        return processor;
    }
}