Hibernate Validator - Capture the exception using Utility Class

In this post, nothing is new, we will take care example 2 and will use the utility class to perform validation. And this Utility class will just return the list of violated constraints and we can show the same
to end user whichever the way we want.  Thanks to Andriy Redko {devmind}

Now Let us Start

Environment

• Eclipse Indigo 3.7 IDE
• Hibernate 4.1.1
• Java 1.6
• MYSQL 5.1

Step : 1

Let us set up the environment first. Follow this post to set up Hibernate with java in eclipse IDE.

Step : 2

We need to add some more jar files for validator. Please follow the steps

1. Right Click on Project and Select Properties
2. Select Java Build Path
3. Click “Add External JAR” and include the following jar files  (you can also download by clicking the following files)

• hibernate-validator-4.0.2.GA.jar
• hibernate-validator-annotation-processor-4.1.0.Final.jar
• slf4j-simple-1.4.2.jar
• log4j-1.2.15.jar
• slf4j-api-1.4.2.jar
• validation-api-1.0.0.GA.jar

Step : 3

In MYSQL, create the following table

CREATE TABLE `validatorexample6` (
  `ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `FirstName` VARCHAR(255) DEFAULT NULL,
  `LastName` VARCHAR(255) DEFAULT NULL,
  `BirthDate` DATE DEFAULT NULL,
  `CustomerNumber` VARCHAR(255) DEFAULT NULL,
  `SSN` VARCHAR(255) DEFAULT NULL,
  `Email` VARCHAR(255) DEFAULT NULL,
  `zip` VARCHAR(255) DEFAULT NULL,
  PRIMARY KEY  (`ID`)
) ENGINE=INNODB DEFAULT CHARSET=latin1;

Now let us create all the java files

1. validatorexample6

package domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Past;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.util.Date;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;

@Entity
@Table(name = "validatorexample6")
public class validatorexample6 {

    @Id
    @GeneratedValue
    @Column(name = "ID")
    private int ID;

    @NotNull(message="First name cannot be empty")
    @Size(min = 2,message="First name is too small")
    @Column(name = "FirstName")
    private String firstName;

    @Length(min = 2, max = 50, message="LastName should be 2 to 50 Characters size")
    @Column(name = "LastName")
    private String lastName;

    @Column(name = "BirthDate")
    @Temporal(TemporalType.DATE)
    @Past(message="Date of birth should be past date")
    private Date birthDate;
    
    @Pattern(regexp = "^[a-zA-Z]{2}-\\d+$", message="Invalid Customer Number")
    @Column(name = "CustomerNumber")
    private String customerNumber;

    @Pattern(regexp= "[0-9]{3}-[0-9]{2}-[0-9]{4}",   message="Invalid SSN format")
    @Column(name = "ssn")
    private String ssn;

    @Column(name = "Email")
    @org.hibernate.validator.constraints.Email(message="Invalid Email Format")
    private String Email;

    @NotEmpty
    @Length(min = 5, max = 5, message = "{zip.length}")
    @Pattern(regexp = "[0-9]+", message="Invalid Zip")
    @Column(name = "zip")
    private String zip;
     
    public int getID() {
        return ID;
    }

    public void setID(int iD) {
        ID = iD;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    public String getCustomerNumber() {
        return customerNumber;
    }

    public void setCustomerNumber(String customerNumber) {
        this.customerNumber = customerNumber;
    }

    public String getSsn() {
        return ssn;
    }

    public void setSsn(String ssn) {
        this.ssn = ssn;
    }

    public String getEmail() {
        return Email;
    }

    public void setEmail(String email) {
        Email = email;
    }

    public String getZip() {
        return zip;
    }

    public void setZip(String zip) {
        this.zip = zip;
    }


}

2. HibernateUtil.java

package HibernateUtilities;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtil {

    private static SessionFactory factory;
    private static ServiceRegistry serviceRegistry;

    public static Configuration getInitConfiguration() {
        Configuration config = new Configuration();
        config.configure();
        return config;
    }

    public static Session getSession() {
        if (factory == null) {
            Configuration config = HibernateUtil.getInitConfiguration();
            serviceRegistry = new ServiceRegistryBuilder().applySettings(
                    config.getProperties()).buildServiceRegistry();
            factory = config.buildSessionFactory(serviceRegistry);
        }
        Session hibernateSession = factory.getCurrentSession();
        return hibernateSession;
    }

    public static Session beginTransaction() {
        Session hibernateSession;
        hibernateSession = HibernateUtil.getSession();
        hibernateSession.beginTransaction();
        return hibernateSession;
    }

    public static void CommitTransaction() {
        HibernateUtil.getSession().getTransaction().commit();
    }

    public static void closeSession() {
        HibernateUtil.getSession().close();
    }

    public static void rollbackTransaction() {
        HibernateUtil.getSession().getTransaction().rollback();
    }

}

3. ValidatorUtil.java

package utility;

import java.util.HashSet;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.groups.Default;

public class ValidatorUtil {

    private final ValidatorFactory factory;

    public ValidatorUtil() {
        factory = Validation.buildDefaultValidatorFactory();
    }

    public <T> HashSet<ConstraintViolation<?>> validate(final T instance) {
        final Validator validator = factory.getValidator();

        final Set<ConstraintViolation<T>> violations = validator.validate(
                instance, Default.class);

        if (!violations.isEmpty()) {
            final Set<ConstraintViolation<?>> constraints = new HashSet<ConstraintViolation<?>>(
                    violations.size());

            for (final ConstraintViolation<?> violation : violations) {
                constraints.add(violation);
            }

            return (HashSet<ConstraintViolation<?>>) constraints;
        }
        return null;
    }

}

4. hibernate.cfg.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/sampledb</property>
        <property name="connection.username">root</property>
        <property name="connection.password">1234</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <property name="javax.persistence.validation.mode">none</property>  
        
        <!-- Mapping Classes -->
        <mapping class="domain.validatorexample6" />

    </session-factory>
</hibernate-configuration>

5. Test.Java

package test;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Set;

import javax.validation.ConstraintViolation;
import org.hibernate.Session;
import utility.ValidatorUtil;
import HibernateUtilities.HibernateUtil;
import domain.validatorexample6;

public class Test {
    public static void main(String[] args) throws Throwable {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        validatorexample6 v1 = new validatorexample6();
        v1.setFirstName("a");
        v1.setLastName("012345678900123456789001234567890012345678900123456789001234567890");
        v1.setBirthDate(sdf.parse(sdf.format(new Date()) + 1));
        v1.setCustomerNumber("#@3434");
        v1.setSsn("3fdfdfdf");
        v1.setEmail("asdasdasdsadsad");
        v1.setZip("asdasdsadasd");

        final Set<ConstraintViolation<?>> constraints = new ValidatorUtil()
                .validate(v1);
        
        for (final ConstraintViolation<?> violation : constraints)
        {
            System.out.println(violation.getPropertyPath() + " -> "
                    + violation.getMessage());
        }
        Session session = HibernateUtil.beginTransaction();
        session.save(v1);
        HibernateUtil.CommitTransaction();

    }
}

Now you run test.java and check the console

Project Structure

 

Download source here