Hibernate Validator

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

mvn archetype:generate -DarchetypeGroupId=org.hibernate \
                       -DarchetypeArtifactId=hibernate-validator-quickstart-archetype \
                       -DarchetypeVersion=4.3.2.Final \
                       -DarchetypeRepository=http://repository.jboss.org/nexus/content/groups/public-jboss/ \
                       -DgroupId=com.mycompany \
                       -DartifactId=hv-quickstart

package com.mycompany;


import javax.validation.constraints.Min;

import javax.validation.constraints.NotNull;

import javax.validation.constraints.Size;


public class Car {


    @NotNull

    private String manufacturer;


    @NotNull

    @Size(min = 2, max = 14)

    private String licensePlate;


    @Min(2)

    private int seatCount;

    

    public Car(String manufacturer, String licencePlate, int seatCount) {

        this.manufacturer = manufacturer;

        this.licensePlate = licencePlate;

        this.seatCount = seatCount;

    }


    //getters and setters ...

}

package com.mycompany;


import static org.junit.Assert.*;


import java.util.Set;


import javax.validation.ConstraintViolation;

import javax.validation.Validation;

import javax.validation.Validator;

import javax.validation.ValidatorFactory;


import org.junit.BeforeClass;

import org.junit.Test;


public class CarTest {


    private static Validator validator;


    @BeforeClass

    public static void setUp() {

        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();

        validator = factory.getValidator();

    }


    @Test

    public void manufacturerIsNull() {

        Car car = new Car(null, "DD-AB-123", 4);


        Set<ConstraintViolation<Car>> constraintViolations =

            validator.validate(car);


        assertEquals(1, constraintViolations.size());

        assertEquals("may not be null", constraintViolations.iterator().next().getMessage());

    }


    @Test

    public void licensePlateTooShort() {

        Car car = new Car("Morris", "D", 4);


        Set<ConstraintViolation<Car>> constraintViolations = 

            validator.validate(car);


        assertEquals(1, constraintViolations.size());

        assertEquals("size must be between 2 and 14", constraintViolations.iterator().next().getMessage());

    }

    

    @Test

    public void seatCountTooLow() {

        Car car = new Car("Morris", "DD-AB-123", 1);


        Set<ConstraintViolation<Car>> constraintViolations =

            validator.validate(car);


        assertEquals(1, constraintViolations.size());

        assertEquals("must be greater than or equal to 2", constraintViolations.iterator().next().getMessage());

    }


    @Test

    public void carIsValid() {

        Car car = new Car("Morris", "DD-AB-123", 2);


        Set<ConstraintViolation<Car>> constraintViolations =

            validator.validate(car);


        assertEquals(0, constraintViolations.size());

    }

}

public class Person {

    @NotNull

    private String name;


    public Person(String name) {

        this.name = name;

    }

    // getters and setters ...

}

public class Driver extends Person {

    @Min(value = 18, message = "You have to be 18 to drive a car", groups = DriverChecks.class)

    public int age;


    @AssertTrue(message = "You first have to pass the driving test", groups = DriverChecks.class)

    public boolean hasDrivingLicense;


    public Driver(String name) {

        super( name );

    }


    public void passedDrivingTest(boolean b) {

        hasDrivingLicense = b;

    }


    public int getAge() {

        return age;

    }


    public void setAge(int age) {

        this.age = age;

    }

}

public interface DriverChecks {

}


public interface CarChecks {

}

public class Car {

    @NotNull

    private String manufacturer;


    @NotNull

    @Size(min = 2, max = 14)

    private String licensePlate;


    @Min(2)

    private int seatCount;


    @AssertTrue(message = "The car has to pass the vehicle inspection first", groups = CarChecks.class)

    private boolean passedVehicleInspection;


    @Valid

    private Driver driver;


    public Car(String manufacturer, String licencePlate, int seatCount) {

        this.manufacturer = manufacturer;

        this.licensePlate = licencePlate;

        this.seatCount = seatCount;

    }

}

public class GroupTest {


    private static Validator validator;


    @BeforeClass

    public static void setUp() {

        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();

        validator = factory.getValidator();

    }


    @Test

    public void driveAway() {

        // create a car and check that everything is ok with it.

        Car car = new Car( "Morris", "DD-AB-123", 2 );

        Set<ConstraintViolation<Car>> constraintViolations = validator.validate( car );

        assertEquals( 0, constraintViolations.size() );


        // but has it passed the vehicle inspection?

        constraintViolations = validator.validate( car, CarChecks.class );

        assertEquals( 1, constraintViolations.size() );

        assertEquals("The car has to pass the vehicle inspection first", constraintViolations.iterator().next().getMessage());


        // let's go to the vehicle inspection

        car.setPassedVehicleInspection( true );

        assertEquals( 0, validator.validate( car ).size() );


        // now let's add a driver. He is 18, but has not passed the driving test yet

        Driver john = new Driver( "John Doe" );

        john.setAge( 18 );

        car.setDriver( john );

        constraintViolations = validator.validate( car, DriverChecks.class );

        assertEquals( 1, constraintViolations.size() );

        assertEquals( "You first have to pass the driving test", constraintViolations.iterator().next().getMessage() );


        // ok, John passes the test

        john.passedDrivingTest( true );

        assertEquals( 0, validator.validate( car, DriverChecks.class ).size() );


        // just checking that everything is in order now

        assertEquals( 0, validator.validate( car, Default.class, CarChecks.class, DriverChecks.class ).size() );

    }

}

package com.mycompany;


import static java.lang.annotation.ElementType.*;

import static java.lang.annotation.RetentionPolicy.*;


import java.lang.annotation.Documented;

import java.lang.annotation.Retention;

import java.lang.annotation.Target;


import javax.validation.Constraint;

import javax.validation.Payload;

import javax.validation.constraints.NotNull;

import javax.validation.constraints.Size;


@NotNull

@Size(min = 2, max = 14)

@CheckCase(CaseMode.UPPER)

@Target( { METHOD, FIELD, ANNOTATION_TYPE })

@Retention(RUNTIME)

@Constraint(validatedBy = {})

@Documented

public @interface ValidLicensePlate {


    String message() default "{com.mycompany.constraints.validlicenseplate}";


    Class<?>[] groups() default {};


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


}

package com.mycompany;


public class Car {


    @ValidLicensePlate

    private String licensePlate;


    //...


}

//...

@ReportAsSingleViolation

public @interface ValidLicensePlate {


    String message() default "{com.mycompany.constraints.validlicenseplate}";


    Class<?>[] groups() default {};


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


}

<validation-config xmlns="http://jboss.org/xml/ns/javax/validation/configuration"

 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 xsi:schemaLocation="http://jboss.org/xml/ns/javax/validation/configuration">

    <default-provider>org.hibernate.validator.HibernateValidator</default-provider>

    <message-interpolator>org.hibernate.validator.messageinterpolation.ResourceBundleMessageInterpolator</message-interpolator>

    <traversable-resolver>org.hibernate.validator.engine.resolver.DefaultTraversableResolver</traversable-resolver>

    <constraint-validator-factory>org.hibernate.validator.engine.ConstraintValidatorFactoryImpl</constraint-validator-factory>

    <constraint-mapping>/constraints-car.xml</constraint-mapping>

    <property name="prop1">value1</property>

    <property name="prop2">value2</property>

</validation-config>

<constraint-mappings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                     xsi:schemaLocation="http://jboss.org/xml/ns/javax/validation/mapping validation-mapping-1.0.xsd"

                     xmlns="http://jboss.org/xml/ns/javax/validation/mapping">

    <default-package>org.hibernate.validator.quickstart</default-package>

    <bean class="Car" ignore-annotations="true">

        <field name="manufacturer">

            <constraint annotation="javax.validation.constraints.NotNull"/>

        </field>

        <field name="licensePlate">

            <constraint annotation="javax.validation.constraints.NotNull"/>

        </field>

        <field name="seatCount">

            <constraint annotation="javax.validation.constraints.Min">

                <element name="value">2</element>

            </constraint>

        </field>

        <field name="driver">

            <valid/>

        </field>

        <getter name="passedVehicleInspection" ignore-annotations="true">

            <constraint annotation="javax.validation.constraints.AssertTrue">

                <message>The car has to pass the vehicle inspection first</message>

                <groups>

                    <value>CarChecks</value>

                </groups>

                <element name="max">10</element>

            </constraint>

        </getter>

    </bean>

    <bean class="RentalCar" ignore-annotations="true">

        <class ignore-annotations="true">

            <group-sequence>

                <value>RentalCar</value>

                <value>CarChecks</value>

            </group-sequence>

        </class>

    </bean>

    <constraint-definition annotation="org.mycompany.CheckCase">

        <validated-by include-existing-validators="false">

            <value>org.mycompany.CheckCaseValidator</value>

        </validated-by>

    </constraint-definition>

</constraint-mappings>

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();

Validator validator = factory.getValidator();

Configuration<?> config = Validation.byDefaultProvider().configure();

config.messageInterpolator(new MyMessageInterpolator())

    .traversableResolver( new MyTraversableResolver())

    .constraintValidatorFactory(new MyConstraintValidatorFactory());


ValidatorFactory factory = config.buildValidatorFactory();

Validator validator = factory.getValidator();

HibernateValidatorConfiguration config = Validation.byProvider( HibernateValidator.class ).configure();

config.messageInterpolator(new MyMessageInterpolator())

    .traversableResolver( new MyTraversableResolver())

    .constraintValidatorFactory(new MyConstraintValidatorFactory());


ValidatorFactory factory = config.buildValidatorFactory();

Validator validator = factory.getValidator();

Configuration<?> config = Validation.byDefaultProvider()

    .providerResolver( new OSGiServiceDiscoverer() )

    .configure();


ValidatorFactory factory = config.buildValidatorFactory();

Validator validator = factory.getValidator();

public interface ValidationProviderResolver {

    /**

     * Returns a list of ValidationProviders available in the runtime environment.

     *

     * @return list of validation providers.  

     */

    List<ValidationProvider<?>> getValidationProviders();

}

Configuration<?> configuration = Validation.byDefaultProvider().configure();

ValidatorFactory factory = configuration

    .messageInterpolator(new ValueFormatterMessageInterpolator(configuration.getDefaultMessageInterpolator()))

    .buildValidatorFactory();


Validator validator = factory.getValidator();

/**

 * Contract determining if a property can be accessed by the Bean Validation provider

 * This contract is called for each property that is being either validated or cascaded.

 *

 * A traversable resolver implementation must be thread-safe.

 *

 */

public interface TraversableResolver {

    /**

     * Determine if the Bean Validation provider is allowed to reach the property state

     *

     * @param traversableObject object hosting <code>traversableProperty</code> or null  

     *                          if validateValue is called

     * @param traversableProperty the traversable property.

     * @param rootBeanType type of the root object passed to the Validator.

     * @param pathToTraversableObject path from the root object to

     *        <code>traversableObject</code>

     *        (using the path specification defined by Bean Validator).

     * @param elementType either <code>FIELD</code> or <code>METHOD</code>.

     *

     * @return <code>true</code> if the Bean Validation provider is allowed to

     *         reach the property state, <code>false</code> otherwise.

     */

     boolean isReachable(Object traversableObject,

                         Path.Node traversableProperty,

                         Class<?> rootBeanType,

                         Path pathToTraversableObject,

                         ElementType elementType);


    /**

     * Determine if the Bean Validation provider is allowed to cascade validation on

     * the bean instance returned by the property value

     * marked as <code>@Valid</code>.

     * Note that this method is called only if isReachable returns true for the same set of

     * arguments and if the property is marked as <code>@Valid</code>

     *

     * @param traversableObject object hosting <code>traversableProperty</code> or null

     *                          if validateValue is called

     * @param traversableProperty the traversable property.

     * @param rootBeanType type of the root object passed to the Validator.

     * @param pathToTraversableObject path from the root object to

     *        <code>traversableObject</code>

     *        (using the path specification defined by Bean Validator).

     * @param elementType either <code>FIELD</code> or <code>METHOD</code>.

     *

     * @return <code>true</code> if the Bean Validation provider is allowed to

     *         cascade validation, <code>false</code> otherwise.

     */

     boolean isCascadable(Object traversableObject,

                          Path.Node traversableProperty,

                          Class<?> rootBeanType,

                          Path pathToTraversableObject,

                          ElementType elementType);

}

Configuration<?> configuration = Validation.byDefaultProvider().configure();

ValidatorFactory factory = configuration

    .traversableResolver(new MyTraversableResolver())

    .buildValidatorFactory();


Validator validator = factory.getValidator();

Configuration<?> configuration = Validation.byDefaultProvider().configure();

ValidatorFactory factory = configuration

    .constraintValidatorFactory(new IOCConstraintValidatorFactory())

    .buildValidatorFactory();


Validator validator = factory.getValidator();

public interface ConstraintValidatorFactory {

    /**

     * @param key The class of the constraint validator to instantiate.

     *

     * @return A constraint validator instance of the specified class.

     */

     <T extends ConstraintValidator<?,?>> T getInstance(Class<T> key);

}

Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
BeanDescriptor beanDescriptor = validator.getConstraintsForClass(Person.class);
PropertyDescriptor propertyDescriptor = beanDescriptor.getConstraintsForProperty("name");
Set<ConstraintDescriptor<?>> constraints = propertyDescriptor.findConstraints()
                                           .declaredOn(ElementType.METHOD)
                                           .unorderedAndMatchingGroups(Default.class)
                                           .lookingAt(Scope.LOCAL_ELEMENT)
                                           .getConstraintDescriptors();