Parameter Binding Annotations

camel-core
The annotations below are all part of camel-core and thus does not require camel-spring or Spring. These annotations can be used with the Bean component or when invoking beans in the DSL

Annotations can be used to define an Expression or to extract various headers, properties or payloads from a Message when invoking a bean method (see Bean Integration for more detail of how to invoke bean methods) together with being useful to help disambiguate which method to invoke.

If no annotations are used then Camel assumes that a single parameter is the body of the message. Camel will then use the Type Converter mechanism to convert from the expression value to the actual type of the parameter.

The core annotations are as follows

Annotation Meaning Parameter
@Body To bind to an inbound message body  
@ExchangeException To bind to an Exception set on the exchange (Camel 2.0)  
@Header To bind to an inbound message header String name of the header
@Headers To bind to the Map of the inbound message headers  
@OutHeaders To bind to the Map of the outbound message headers  
@Property To bind to a named property on the exchange String name of the property
@Properties To bind to the property map on the exchange  
@Handler Camel 2.0: Not part as a type parameter but stated in this table anyway to spread the good word that we have this annotation in Camel now. See more at Bean Binding.  

The follow annotations @Headers, @OutHeaders and @Properties binds to the backing java.util.Map so you can alter the content of these maps directly, for instance using the put method to add a new entry. See the OrderService class at Exception Clause for such an example.

Since Camel 2.0, you can use @Header("myHeader") and @Property("myProperty") instead of @Header(name="myHeader") and @Property(name="myProperty") as Camel 1.x does.

Example

In this example below we have a @Consume consumer (like message driven) that consumes JMS messages from the activemq queue. We use the @Header and @Body parameter binding annotations to bind from the JMSMessage to the method parameters.

public class Foo {
	
    @Consume(uri = "activemq:my.queue")
    public void doSomething(@Header("JMSCorrelationID") String correlationID, @Body String body) {
		// process the inbound message here
    }

}

In the above Camel will extract the value of Message.getJMSCorrelationID(), then using the Type Converter to adapt the value to the type of the parameter if required - it will inject the parameter value for the correlationID parameter. Then the payload of the message will be converted to a String and injected into the body parameter.

You don't need to use the @Consume annotation; as you could use the Camel DSL to route to the beans method

Using the DSL to invoke the bean method

Here is another example which does not use POJO Consuming annotations but instead uses the DSL to route messages to the bean method

public class Foo {
    public void doSomething(@Header("JMSCorrelationID") String correlationID, @Body String body) {
		// process the inbound message here
    }

}

The routing DSL then looks like this

from("activemq:someQueue").
  to("bean:myBean");

Here myBean would be looked up in the Registry (such as JNDI or the Spring ApplicationContext), then the body of the message would be used to try figure out what method to call.

If you want to be explicit you can use

from("activemq:someQueue").
  to("bean:myBean?methodName=doSomething");

And here we have a nifty example for you to show some great power in Camel. You can mix and match the annotations with the normal parameters, so we can have this example with annotations and the Exchange also:

    public void doSomething(@Header("user") String user, @Body String body, Exchange exchange) {
        exchange.getIn().setBody(body + "MyBean");
    }

Annotation Based Expression Language

You can also use any of the Languages supported in Camel to bind expressions to method parameters when using Bean Integration. For example you can use any of these annotations:

AnnotationDescription
@Bean Inject a Bean expression
@BeanShell Inject a BeanShell expression
@Constant Inject a Constant expression
@EL Inject an EL expression
@Groovy Inject a Groovy expression
@Header Inject a Header expression
@JavaScript Inject a JavaScript expression
@MVEL Inject a Mvel expression
@OGNL Inject an OGNL expression
@PHP Inject a PHP expression
@Python Inject a Python expression
@Ruby Inject a Ruby expression
@Simple Inject an Simple expression
@XPath Inject an XPath expression
@XQuery Inject an XQuery expression

Example:

public class Foo {
	
    @MessageDriven(uri = "activemq:my.queue")
    public void doSomething(@XPath("/foo/bar/text()") String correlationID, @Body String body) {
		// process the inbound message here
    }
}

Advanced example using @Bean

And an example of using the the @Bean binding annotation, where you can use a Pojo where you can do whatever java code you like:

public class Foo {
	
    @MessageDriven(uri = "activemq:my.queue")
    public void doSomething(@Bean("myCorrelationIdGenerator") String correlationID, @Body String body) {
		// process the inbound message here
    }
}

And then we can have a spring bean with the id myCorrelationIdGenerator where we can compute the id.

public class MyIdGenerator {

    private UserManager userManager;

    public String generate(@Header(name = "user") String user, @Body String payload) throws Exception {
       User user = userManager.lookupUser(user);
       String userId = user.getPrimaryId();
       String id = userId + generateHashCodeForPayload(payload);
       return id;
   }
}

The Pojo MyIdGenerator has one public method that accepts two parameters. However we have also annotated this one with the @Header and @Body annotation to help Camel know what to bind here from the Message from the Exchange being processed.

Of course this could be simplified a lot if you for instance just have a simple id generator. But we wanted to demonstrate that you can use the Bean Binding annotations anywhere.

public class MySimpleIdGenerator {

    public static int generate()  {
       // generate a unique id
       return 123;
   }
}

And finally we just need to remember to have our bean registered in the Spring Registry:

   <bean id="myCorrelationIdGenerator" class="com.mycompany.MySimpleIdGenerator"/>

Example using Groovy

In this example we have an Exchange that has a User object stored in the in header. This User object has methods to get some user information. We want to use Groovy to inject an expression that extracts and concats the fullname of the user into the fullName parameter.

    public void doSomething(@Groovy("$request.header['user'].firstName $request.header['user'].familyName) String fullName, @Body String body) {
		// process the inbound message here
    }

Groovy supports GStrings that is like a template where we can insert $ placeholders that will be evaluated by Groovy.

© 2004-2011 The Apache Software Foundation.
Apache Camel, Camel, Apache, the Apache feather logo, and the Apache Camel project logo are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.
Graphic Design By Hiram