Red Hat Summit Red Hat SummitSupportConsoleDevelopersStart a trialContact

Chapter 46. Bean Validator Component

Available as of Camel version 2.3

The Validator component performs bean validation of the message body using the Java Bean Validation API (JSR 303). Camel uses the reference implementation, which is Hibernate Validator.

Maven users will need to add the following dependency to their pom.xml for this component: 

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-bean-validator</artifactId>
    <version>x.y.z</version>
    <!-- use the same version as your Camel core version -->
</dependency>
Copy to Clipboard Toggle word wrap

46.1. URI format
Copy link

bean-validator:label[?options]
Copy to Clipboard Toggle word wrap

or 

bean-validator://label[?options]
Copy to Clipboard Toggle word wrap

Where label is an arbitrary text value describing the endpoint.
You can append query options to the URI in the following format, ?option=value&option=value&…​

46.2. URI Options
Copy link

The Bean Validator component has no options.

The Bean Validator endpoint is configured using URI syntax: 

bean-validator:label
Copy to Clipboard Toggle word wrap

with the following path and query parameters:

46.2.1. Path Parameters (1 parameters):
Copy link

Expand
NameDescriptionDefaultType

label

Required Where label is an arbitrary text value describing the endpoint

 

String

46.2.2. Query Parameters (6 parameters):
Copy link

Expand
NameDescriptionDefaultType

constraintValidatorFactory (producer)

To use a custom ConstraintValidatorFactory

 

ConstraintValidator Factory

group (producer)

To use a custom validation group

javax.validation.groups.Default

String

messageInterpolator (producer)

To use a custom MessageInterpolator

 

MessageInterpolator

traversableResolver (producer)

To use a custom TraversableResolver

 

TraversableResolver

validationProviderResolver (producer)

To use a a custom ValidationProviderResolver

 

ValidationProvider Resolver

synchronous (advanced)

Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported).

false

boolean

46.3. OSGi deployment
Copy link

To use Hibernate Validator in the OSGi environment use dedicated ValidationProviderResolver implementation, just as org.apache.camel.component.bean.validator.HibernateValidationProviderResolver. The snippet below demonstrates this approach. Keep in mind that you can use HibernateValidationProviderResolver starting from the Camel 2.13.0.

Using HibernateValidationProviderResolver 

from("direct:test").
  to("bean-validator://ValidationProviderResolverTest?validationProviderResolver=#myValidationProviderResolver");

...

<bean id="myValidationProviderResolver" class="org.apache.camel.component.bean.validator.HibernateValidationProviderResolver"/>
Copy to Clipboard Toggle word wrap

If no custom ValidationProviderResolver is defined and the validator component has been deployed into the OSGi environment, the HibernateValidationProviderResolver will be automatically used.

46.4. Example
Copy link

Assumed we have a java bean with the following annotations

Car.java 

public class Car {

    @NotNull
    private String manufacturer;

    @NotNull
    @Size(min = 5, max = 14, groups = OptionalChecks.class)
    private String licensePlate;

    // getter and setter
}
Copy to Clipboard Toggle word wrap

and an interface definition for our custom validation group

OptionalChecks.java 

public interface OptionalChecks {
}
Copy to Clipboard Toggle word wrap

with the following Camel route, only the @NotNull constraints on the attributes manufacturer and licensePlate will be validated (Camel uses the default group javax.validation.groups.Default). 

from("direct:start")
.to("bean-validator://x")
.to("mock:end")
Copy to Clipboard Toggle word wrap

If you want to check the constraints from the group OptionalChecks, you have to define the route like this 

from("direct:start")
.to("bean-validator://x?group=OptionalChecks")
.to("mock:end")
Copy to Clipboard Toggle word wrap

If you want to check the constraints from both groups, you have to define a new interface first

AllChecks.java 

@GroupSequence({Default.class, OptionalChecks.class})
public interface AllChecks {
}
Copy to Clipboard Toggle word wrap

and then your route definition should looks like this 

from("direct:start")
.to("bean-validator://x?group=AllChecks")
.to("mock:end")
Copy to Clipboard Toggle word wrap

And if you have to provide your own message interpolator, traversable resolver and constraint validator factory, you have to write a route like this 

<bean id="myMessageInterpolator" class="my.ConstraintValidatorFactory" />
<bean id="myTraversableResolver" class="my.TraversableResolver" />
<bean id="myConstraintValidatorFactory" class="my.ConstraintValidatorFactory" />

from("direct:start")
.to("bean-validator://x?group=AllChecks&messageInterpolator=#myMessageInterpolator
&traversableResolver=#myTraversableResolver&constraintValidatorFactory=#myConstraintValidatorFactory")
.to("mock:end")
Copy to Clipboard Toggle word wrap

It’s also possible to describe your constraints as XML and not as Java annotations. In this case, you have to provide the file META-INF/validation.xml which could looks like this

validation.xml 

<?xml version="1.0" encoding="UTF-8"?>
<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.engine.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>
</validation-config>
Copy to Clipboard Toggle word wrap

and the constraints-car.xml file

constraints-car.xml 

<?xml version="1.0" encoding="UTF-8"?>
<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.apache.camel.component.bean.validator</default-package>

    <bean class="CarWithoutAnnotations" ignore-annotations="true">
        <field name="manufacturer">
            <constraint annotation="javax.validation.constraints.NotNull" />
        </field>

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

            <constraint annotation="javax.validation.constraints.Size">
                <groups>
                    <value>org.apache.camel.component.bean.validator.OptionalChecks</value>
                </groups>
                <element name="min">5</element>
                <element name="max">14</element>
            </constraint>
        </field>
    </bean>
</constraint-mappings>
Copy to Clipboard Toggle word wrap

Here is the XML syntax for the example route definition where OrderedChecks can be https://github.com/apache/camel/blob/master/components/camel-bean-validator/src/test/java/org/apache/camel/component/bean/validator/OrderedChecks.java

Note that the body should include an instance of a class to validate. 

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

    <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="direct:start"/>
            <to uri="bean-validator://x?group=org.apache.camel.component.bean.validator.OrderedChecks"/>
        </route>
    </camelContext>
</beans>
Copy to Clipboard Toggle word wrap

46.5. See Also
Copy link

  • Configuring Camel
  • Component
  • Endpoint
  • Getting Started
Back to top
Red Hat logoGithubredditYoutubeTwitter

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

We help Red Hat users innovate and achieve their goals with our products and services with content they can trust. Explore our recent updates.

Making open source more inclusive

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. For more details, see the Red Hat Blog.

About Red Hat

We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.

Theme

© 2025 Red Hat