// spring-boot-auto-configure options: START
:page-partial:
:doctitle: Camel Spring Boot Starter for bean-validator

== Spring Boot Auto-Configuration

When using bean-validator with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-bean-validator-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 9 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.component.bean-validator.autowired-enabled* | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | Boolean
| *camel.component.bean-validator.constraint-validator-factory* | To use a custom ConstraintValidatorFactory. The option is a javax.validation.ConstraintValidatorFactory type. |  | ConstraintValidatorFactory
| *camel.component.bean-validator.enabled* | Whether to enable auto configuration of the bean-validator component. This is enabled by default. |  | Boolean
| *camel.component.bean-validator.ignore-xml-configuration* | Whether to ignore data from the META-INF/validation.xml file. | false | Boolean
| *camel.component.bean-validator.lazy-start-producer* | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | Boolean
| *camel.component.bean-validator.message-interpolator* | To use a custom MessageInterpolator. The option is a javax.validation.MessageInterpolator type. |  | MessageInterpolator
| *camel.component.bean-validator.traversable-resolver* | To use a custom TraversableResolver. The option is a javax.validation.TraversableResolver type. |  | TraversableResolver
| *camel.component.bean-validator.validation-provider-resolver* | To use a a custom ValidationProviderResolver. The option is a javax.validation.ValidationProviderResolver type. |  | ValidationProviderResolver
| *camel.component.bean-validator.validator-factory* | To use a custom ValidatorFactory. The option is a javax.validation.ValidatorFactory type. |  | ValidatorFactory
|===
// spring-boot-auto-configure options: END
