bval-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
Subject [CONF] Apache BVal > Obtaining a validator
Date Wed, 22 Feb 2012 03:20:00 GMT
Space: Apache BVal (
Page: Obtaining a validator (

Edited by Matt Benson:
To obtain a validator, you must first create a ValidatorFactory. If there is only one jsr303
implementation in your classpath, you can use:

ValidatorFactory vf = Validation.buildDefaultValidatorFactory();

to obtain the factory. If there are various implementations in the classpath, or you want
to be sure you are using the Apache one, you can use:

ValidatorFactory avf = Validation.byProvider(ApacheValidationProvider.class).configure().buildValidatorFactory();

You should not instantiate more than one factory, as factory creation is a costly process
and the factory also acts as a constraint cache for the validators.

Once you have a ValidatorFactory, obtaining a validator just requires you to call {{ValidatorFactory#getValidator()}}.
The validator implementation is thread-safe, so you can choose to re-use a single instance
of it in all your code or create validators on demand: both options are fine and should perform
equally well.

Below is an example that will create a singleton ValidatorFactory and will let you obtain
validators from it:

public enum MyValidatorFactory {
        ValidatorFactory avf = Validation.byProvider(ApacheValidationProvider.class).configure().buildValidatorFactory();
        public Validator getValidator() {
            return avf.getValidator();
    public abstract Validator getValidator(); 

Using the above class, obtaining a validator just requires you to call: {{MyValidatorFactory.SINGLE_INSTANCE.getValidator()}}

h3. Using Spring

If you are using Spring, you can easily inject validators in your beans. Simply configure
the factory in your applicationContext by adding:

    <!-- Validator bean -->
    <bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
        <property name="providerClass" value="org.apache.bval.jsr303.ApacheValidationProvider"

And Spring will be able to inject Validators and the ValidatorFactory in your beans.

h3. Using Google Guice

_Apache BVal_ provides the {{bval-guice}} module that simplifies integration with _Google
Guice_. That module has multiple purposes, such:

* bootstrap _Apache BVal_ using _Google Guice_;
* obtain _javax.validation.ConstraintValidator_ instances using the _Google Guice Injector_,
to easily support the DI;
* easily inject the _javax.validation.Validator_ reference into components that require it;
* easily intercept methods and validate method arguments.

First of all, users have to add the {{bval-guice}} module in the classpath; _Apache Maven_
users can easily include it just by adding the following dependency in the POM:


Let's have a look at the features:

h5. Apache BVal bootstrapping

Simply, the {{org.apache.bval.guice.ValidationModule}} is the _Google Guice_ module that bootstraps
_Apache BVal_; all users have to do is add this module when creating the _Google Guice Injector_:


import org.apache.bval.guice.ValidationModule;

Injector injector = Guice.createInjector([...], new ValidationModule(), [...]);

h5. obtain _javax.validation.ConstraintValidator_ instances

Users can implement now _javax.validation.ConstraintValidator_ classes that require _Dependency
Injection_ by _Google Guice_:

import javax.validation.ConstraintValidator;

public class MyCustomValidator implements ConstraintValidator<MyAssert, MyType> {

    private final MyExternalService service;

    public MyCustomValidator(MyExternalService service) {
        this.service = service;

    public void initialize(MyAssert annotation) {
        // do something

    public boolean isValid(MyType value, ConstraintValidatorContext context) {
        return value == null || this.service.doSomething(value);


Don't forget to bind the {{MyExternalService}} class in the _Google Guice Bincer_!!!

h5. Inject the _javax.validation.Validator_ reference

Clients can easily inject {{javax.validation.Validator}} instances into their custom components
just marking it using the _Google Guice Inject_ annotation:

import javax.validation.Validator;

public class MyValidatorClient {

    private Validator validator;

    public void setValidator(Validator validator) {
        this.validator = validator;



When obtaining {{MyValidatorClient}} instances from the _Injector_, the {{javax.validation.Validator}}
will be automagically bound.

h5. Intercept methods and validate method arguments

Taking advantage from the _Apache BVal_ extension to validate method arguments, the {{bval-guice}}
comes with an _AOP_ interceptor - automatically initialized in the {{org.apache.bval.guice.ValidationModule}}
- that makes easier the methods arguments validation.

All users have to do is annotate interested methods with {{org.apache.bval.guice.Validate}}
annotation, then annotate arguments with constraints, as follows below:

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.apache.bval.guice.Validate;

public class MyService {

            groups = { MyGroup.class },
            validateReturnedValue = true
    public Country insertCountry(@NotNull(groups = { MyGroup.class })
            String name,
            @NotNull(groups = { MyGroup.class })
            @Size(max = 2, groups = { MyGroup.class, MyOtherGroup.class })
            String iso2Code,
            @NotNull(groups = { MyGroup.class })
            @Size(max = 3, groups = { MyGroup.class, MyOtherGroup.class })
            String iso3Code) {

        return ...;


The {{org.apache.bval.guice.Validate}} supports 2 parameters:

* {{groups}} Class array, _empty_ by default, that marks the groups have to be validated;
* {{validateReturnedValue}} flag, _false_ by default, that marks that if the returned object
by the method execution has to be validated.

h3. Using CDI

We recommend [MyFaces CODI|].

Change your notification preferences:

View raw message