To obtain a Validator
, you must first create a ValidatorFactory
. If there
is only one Bean Validation 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 Apache BVal, you can use:
ValidatorFactory avf =
Validation.byProvider(ApacheValidationProvider.class).configure().buildValidatorFactory();
You should usually not instantiate more than one factory; factory creation is a costly process. Also, the factory also acts as a cache for the available validation constraints.
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 should
perform equally well.
Below is an example that will create a singleton ValidatorFactory
and will
let you obtain Validator
s from it:
public enum MyValidatorFactory {
SINGLE_INSTANCE {
ValidatorFactory avf =
Validation.byProvider(ApacheValidationProvider.class).configure().buildValidatorFactory();
@Override
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()
If you are using Spring, you can easily inject Validator
s into 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" />
</bean>
And Spring will be able to inject Validator
s and the ValidatorFactory
into
your beans.
Apache BVal provides the bval-guice
module that simplifies
integration with Google Guice. That module has multiple purposes, such:
javax.validation.ConstraintValidator
instances using the Google
Guice Injector
to easily support DI;javax.validation.Validator
reference into components
that require it;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:
<dependency>
<groupId>org.apache.bval</groupId>
<artifactId>bval-guice</artifactId>
<version>0.3-incubating</version>
</dependency>
Let's have a look at the features:
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 com.google.inject.Guice;
import com.google.inject.Injector;
import org.apache.bval.guice.ValidationModule;
Injector injector = Guice.createInjector([...](....html),
new ValidationModule(), [...]
);
javax.validation.ConstraintValidator
instancesUsers can now implement 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;
@Inject
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
Binder
!!!
javax.validation.Validator
referenceClients 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 {
@Inject
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.
Taking advantage of the Apache BVal extension to validate method
arguments, the bval-guice
module comes with an AOP interceptor,
automatically initialized in the org.apache.bval.guice.ValidationModule
,
that facilitates the validation of method arguments.
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 {
@Validate(
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 bval-guice @Validate
annotation supports 2 values:
groups
Class array, {}
by default, that specifies the groups to be validated;validateReturnedValue
flag, false
by default, indicating whether
the method's return value should be validated.Bean Validation integration with CDI is provided by: