A constraint on a JavaBean is expressed through one or more annotations. An annotation is considered a constraint definition if its retention policy contains RUNTIME and if the annotation itself is annotated with javax.validation.Constraint.

/**
 * Link between a constraint annotation and its constraint validation implementations.
 * <p/>
 * A given constraint annotation should be annotated by a @Constraint
 * annotation which refers to its list of constraint validation implementation.
 *
 * @author Emmanuel Bernard (emmanuel at hibernate.org)
 * @author Gavin King
 * @author Hardy Ferentschik
 */
@Documented
@Target({ ANNOTATION_TYPE })
@Retention(RUNTIME)
public @interface Constraint {
	/**
	 * ConstraintValidator classes must reference distinct target types.
	 * If two validators refer to the same type, an exception will occur
	 * 
	 * @return aray of ConstraintValidator classes implementing the constraint
	 */
	public Class<? extends ConstraintValidator<?,?>>[] validatedBy();
}

Constraint annotations can target any of the following ElementTypes:

While other ElementTypes are not forbidden, the provider does not have to recognize and process constraints placed on such types.

Since a given constraint definition applies to one or more specific Java types, the JavaDoc for the constraint annotation should clearly state which types are supported. Applying a constraint annotation to an incompatible type will raise a UnexpectedTypeForConstraintException. Care should be taken on defining the list of ConstraintValidator. The type resolution algorithm (see Section 3.5.3, “ConstraintValidator resolution algorithm”) could lead to exceptions due to ambiguity.

[...]

A constraint validation implementation performs the validation of a given constraint annotation for a given type. The implementation classes are specified by the validatedBy element of the@Contraint annotation that decorates the constraint definition. The constraint validation implementation implements the ConstraintValidator interface.

/**
 * Defines the logic to validate a given constraint A
 * for a given object type T.
 * Implementations must comply to the following restriction:
 * T must resolve to a non parameterized type
 *
 * @author Emmanuel Bernard
 * @author Hardy Ferentschik
 */
public interface ConstraintValidator<A extends Annotation, T> {
	/**
	 * Validator parameters for a given constraint definition
	 * Annotations parameters are passed as key/value into parameters
	 * <p/>
	 * This method is guaranteed to be called before any of the other Constraint
	 * implementation methods
	 *
	 * @param constraintAnnotation parameters for a given constraint definition
	 */
	void initialize(A constraintAnnotation);

	/**
	 * Implement the validation constraint.
	 * <code>object</code> state must not be changed by a Constraint implementation
	 *
	 * @param object object to validate
	 * @param constraintValidatorContext context in which the constraint is evaluated
	 *
	 * @return false if <code>object</code> does not pass the constraint
	 */
	boolean isValid(T object, ConstraintValidatorContext constraintValidatorContext);
}

Some restrictions apply on the generic type T (used in the isValid method). T must resolve in a non parameterized type:

Here are some examples of valid definitions in Example 2.11, “Valid ConstraintValidator definitions”.

//String is not making use of generics
public class SizeValidatorForString implements<Size, String> {...}

//Collection uses generics but the raw type is used
public class SizeValidatorForCollection implements<Size, Collection> {...}

And some invalid definitions in Example 2.12, “Invalid ConstraintValidator definitions”.

//parameterized type
public class SizeValidatorForString implements<Size, Collection<String> {...}

//parameterized type using unbounded wildcard
public class SizeValidatorForCollection implements<Size, Collection<?>> {...}

//parameterized type using bounded wildcard
public class SizeValidatorForCollection implements<Size, Collection<? extends Address>> {...}

public interface ConstraintDescriptor {
	/**
	 * Returns the annotation describing the constraint declaration.
	 * If a composing constraint, parameter values are reflecting
	 * the overridden parameters from the main constraint
	 *
	 * @return The annotation for this constraint.
	 */
	Annotation getAnnotation();

	/**
	 * @return The groups the constraint is applied on.
	 */
	Set<Class<?>> getGroups();

	/**
	 * @return the constraint validation implementation class
	 */
	Class<? extends ConstraintValidator<?,?>>[]
	    getConstraintValidatorClasses();