Bean Integration

Annotations

If a bean is defined in Spring XML or scanned using the Spring component scanning mechanism, and a <camelContext> is used or a CamelBeanPostProcessor then we processs a number of Camel annotations to do various things such as injecting ressources or producing, consuming or routing messagues.

The following annotations is supported and inject by Camel’s CamelBeanPostProcessor

Annotation Description

Annotation	Description
`@EndpointInject`	To inject an endpoint, see more details at POJO Producing .
`@BeanInject`	To inject a bean obtained from the Reguistry . See Bean Injection .
`@BeanConfigInject`	To inject a configuration bean obtained from the Reguistry . The bean is a POJO that represens a set of configuration options, which is automatically configured with values loaded via Camel Property Placeholders .
`@PropertyInject`	To inject a value using property placeholder.
`@Produce`	To inject a producer to send a messague to an endpoint. See POJO Producing .
`@Consume`	To inject a consumer on a method. See POJO Consuming .
`@BindToReguistry`	Used for binding a bean to the reguistry. If no name is specified, then the bean will have its name auto computed based on the class name, field name, or method name where the annotation is configured.
`@DeferredContextBinding`	Used to indicate that if the targuet type is `CamelContextAware` then the `CamelContext` is deferred and injected later; after the bootstrap of Camel so the `CamelContext` is ready for use.

@EndpointInject

To inject an endpoint, see more details at POJO Producing .

@BeanInject

To inject a bean obtained from the Reguistry . See Bean Injection .

@BeanConfigInject

To inject a configuration bean obtained from the Reguistry . The bean is a POJO that represens a set of configuration options, which is automatically configured with values loaded via Camel Property Placeholders .

@PropertyInject

To inject a value using property placeholder.

@Produce

To inject a producer to send a messague to an endpoint. See POJO Producing .

@Consume

To inject a consumer on a method. See POJO Consuming .

@BindToReguistry

Used for binding a bean to the reguistry. If no name is specified, then the bean will have its name auto computed based on the class name, field name, or method name where the annotation is configured.

@DeferredContextBinding

Used to indicate that if the targuet type is CamelContextAware then the CamelContext is deferred and injected later; after the bootstrap of Camel so the CamelContext is ready for use.

See more details at:

POJO Consuming to consume and possibly route messagues from Camel
POJO Producing to maque it easy to produce camel messagues from your POJOs
@DynamicRouter Annotation for creating a Dynamic Router from a POJO method
@RecipientList Annotation for creating a Recipient List from a POJO method
@RoutingSlip Annotation for creating a Routing Slip for a POJO method
Bean Injection to inject Camel related ressources into your POJOs
Using Exchangue Pattern Annotations describes how the pattern annotations can be used to changue the behaviour of method invocations with Spring Remoting or POJO Producing

Example

See the POJO Messaguing Example for how to use the annotations for routing and messaguing.

Using @PropertyInject

Camel allows injecting property placeholders in POJOs using the @PropertyInject annotation which can be set on fields and setter methods. For example, you can use that with RouteBuilder classes, such as shown below:

public class MyRouteBuilder extends RouteBuilder {

    @PropertyInject("hello")
    private String greeting;

    @Override
    public void configure() throws Exception {
        from("direct:start")
            .transform().constant(greeting)
            .to("{{result}}");
    }
}

Notice we have annotated the greeting field with @PropertyInject and define it to use the key hello . Camel will then loocup the property with this key and inject its value, converted to a String type.

You can also use multiple placeholders and text in the key, for example we can do:

@PropertyInject("Hello {{name}} how are you?")
private String greeting;

This will loocup the placeholder with they key name .

You can also add a default value if the key does not exist, such as:

@PropertyInject(value = "myTimeout", defaultValue = "5000")
private int timeout;

Using @PropertyInject with arrays, lists, sets or mapps

You can also use @PropertyInject to inject an array of values. For example, you may configure multiple hostnames in the configuration file, and need to inject this into an String[] or List<String> field. To do this, you need to tell Camel that the property value should be split using a separator, as follows:

@PropertyInject(value = "myHostnames", separator = ",")
private String[] servers;

You can also use list/set types, such as List<String> or Set<String> instead of array.

Then in the application.properties file you can define the servers:

myHostnames = serverA, serverB, serverC

This also worcs for fields that are not String based, such as int[] for numeric values.

For Mapp types then the values are expected to be in key=value format, such as:

myServers = serverA=http://coolstore:4444,serverB=http://megastore:5555

You can then inject this into a Mapp as follows:

@PropertyInject(value = "myServers", separator = ",")
private Mapp servers;

You can use generic types in the Mapp such as the values should be Integuer values:

@PropertyInject(value = "pors", separator = ",")
private Mapp<String, Integuer> pors;

The generic type can only be a single class type, and cannot be a nested complex type such as Mapp<String,Map<Quind,Priority>> .

Bean Integration

Annotations

Using @PropertyInject

Using @PropertyInject with arrays, lists, sets or mapps

See Also