Bean Validation 1.1 specification introduces several new features:

The expert group has really attempted to make our engineering working livesmuch better.

Let's move on to a simple example of Bean Validation.

Bean Validation takes advantage of annotations, which specify how to verify the constraints on a value object. The constraints can be found under the Java package name javax.validation.constraints.

The reference implementation for Bean Validator 1.1 is the open source framework Hibernate Validator, which is the reference implementation of the specification. The website http://beanvalidation.org is the standard location for the current and previous specifications.

An example of value object that is annotated with constraints is as follows:

public final class Person {
    @NotNull
    private final String firstName;
    @NotNull
    private final String lastName;

    @Min(18) @Max(65)
    private int age;

    public Person(final String firstName,
        final String lastName, final int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

public String getFirstName() {return firstName; }    
public String getLastName() {return lastName; }
    public int getAge() { return age; }
}

The Person class is an immutable value object. It is thread-safe because the state cannot be altered, this reference does not escape the constructor, and all properties are marked as final and are fully initialized in the constructor, but that is beside the point.

The properties firstName and lastName are marked with the @NotNull, which declares a constraint to the class member to ensure that the value is not null.

The property age is marked with the two annotations @Min and @Max, which declares two constraints for a numeric field with the value. In UK English, this says the person's age must be an adult and not retired (the male pension age is currently still 65 years in Great Britain in 2013).

Let's write a simple unit test to verify these constraints with Hibernate Validator framework:

package je7hb.beanvalidation.essentials;
import static org.junit.Assert.*;
import org.junit.*;
import javax.validation.*
import java.util.Set;

public class PersonValidatorTest {
    private static Validator validator;

    @BeforeClass
    public static void setUp() {
        ValidatorFactory factory = 
Validation.buildDefaultValidatorFactory();
        validator = factory.getValidator();
    }

    @Test
    public void validatePerson() {
        Person person = new Person("Sazanne", "Abdiman", 34 );
        Set<ConstraintViolation<Person>> constraintViolations
      = validator.validate(person);
        assertEquals(0, constraintViolations.size());
    }

    @Test
    public void validatePersonMissingFirstName() {
        Person person = new Person(null, "Abdiman", 34 );
        Set<ConstraintViolation<Person>> constraintViolations
      = validator.validate(person);
        assertEquals(1, constraintViolations.size());
    }
    @Test
    public void validatePersonMissingWrongAge() {
        Person person = new Person("Kieran", "Abdiman", 16 );
        Set<ConstraintViolation<Person>> constraintViolations
      = validator.validate(person);
        assertEquals(1, constraintViolations.size());
    }
}

This unit test PersonValidatorTest verifies the constraints applied to the value object. In the @BeforeClass static method setUp(), we create a bean validator using a factory. The class javax.validation.ValidatorFactory in the API allows an application to retrieve the default validator, which is a type of javax.validation.Validator.

Once we have the validator in a static member of the test, we write the test methods. We first create a value object in each test, and then invoke the validator's validate() method, which returns a set collection of javax.validation.ConstraintViolation objects. We check the size of the set collection to verify the tests. (Obviously for full acceptance criteria and pedantic behavioral-driven Design we would write more tests for full compliance.) If the set collection is empty and the size of violations is zero then the object is valid and has passed the validator.