| = POJO Consuming |
| |
| To consume a message you use the |
| `org.apache.camel.Consume` |
| annotation to mark a particular method of a bean as being a consumer |
| method. The uri of the annotation defines the Camel |
| xref:endpoint.adoc[Endpoint] to consume from. |
| |
| e.g. lets invoke the `onCheese()` method with the String body of the |
| inbound JMS message from xref:components::activemq-component.adoc[ActiveMQ] on the cheese |
| queue; this will use the xref:type-converter.adoc[Type Converter] to |
| convert the JMS ObjectMessage or BytesMessage to a String - or just use |
| a TextMessage from JMS |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| public class Foo { |
| |
| @Consume(uri="activemq:cheese") |
| public void onCheese(String name) { |
| ... |
| } |
| } |
| ---- |
| |
| The xref:bean-binding.adoc[Bean Binding] is then used to convert the |
| inbound xref:message.adoc[Message] to the parameter list used to invoke |
| the method . |
| |
| What this does is basically create a route that looks kinda like this |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| from(uri).bean(theBean, "methodName"); |
| ---- |
| |
| **When using more than one CamelContext** |
| |
| When you use more than 1 xref:camelcontext.adoc[CamelContext] you might |
| end up with each of them creating a xref:pojo-consuming.adoc[POJO |
| Consuming]; therefore use the option `context` on *@Consume* that allows |
| you to specify which xref:camelcontext.adoc[CamelContext] id/name you |
| want it to apply for. |
| |
| [[POJOConsuming-UsingcontextoptiontoapplyonlyacertainCamelContext]] |
| == Using context option to apply only a certain CamelContext |
| |
| See the warning above. |
| |
| You can use the `context` option to specify which |
| xref:camelcontext.adoc[CamelContext] the consumer should only apply for. |
| For example: |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| @Consume(uri="activemq:cheese", context="camel-1") |
| public void onCheese(String name) { |
| ---- |
| |
| The consumer above will only be created for the |
| xref:camelcontext.adoc[CamelContext] that have the context id = |
| `camel-1`. You set this id in the XML tag: |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| <camelContext id="camel-1" ...> |
| ---- |
| |
| [[POJOConsuming-Usinganexplicitroute]] |
| == Using an explicit route |
| |
| If you want to invoke a bean method from many different endpoints or |
| within different complex routes in different circumstances you can just |
| use the normal routing xref:dsl.adoc[DSL] or the |
| xref:spring.adoc[Spring] XML configuration file. |
| |
| For example |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| from(uri).beanRef("myBean", "methodName"); |
| ---- |
| |
| which will then look up in the xref:registry.adoc[Registry] and find the |
| bean and invoke the given bean name. (You can omit the method name and |
| have Camel figure out the right method based on the method annotations |
| and body type). |
| |
| [[POJOConsuming-UsetheBeanendpoint]] |
| == Use the Bean endpoint |
| |
| You can always use the bean endpoint |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| from(uri).to("bean:myBean?method=methodName"); |
| ---- |
| |
| [[POJOConsuming-Usingapropertytodefinetheendpoint]] |
| == Using a property to define the endpoint |
| |
| *Since Camel 2.11* |
| |
| The following annotations @Consume, @Produce, @EndpointInject, now |
| offers a `property` attribute you can use to define the endpoint as a |
| property on the bean. Then Camel will use the getter method to access |
| the property. |
| |
| **This applies for them all** |
| |
| The explanation below applies for all the three annotations, eg |
| @Consume, @Produce, and @EndpointInject |
| |
| For example |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| public class MyService { |
| private String serviceEndpoint; |
| |
| public void setServiceEndpoint(String uri) { |
| this.serviceEndpoint = uri; |
| } |
| |
| public String getServiceEndpoint() { |
| return serviceEndpoint |
| } |
| |
| @Consume(property = "serviceEndpoint") |
| public void onService(String input) { |
| ... |
| } |
| } |
| ---- |
| |
| The bean `MyService` has a property named `serviceEndpoint` which has |
| getter/setter for the property. Now we want to use the bean for |
| xref:pojo-consuming.adoc[POJO Consuming], and hence why we use @Consume |
| in the onService method. Notice how we use the |
| `property = "serviceEndpoint` to configure the property that has the |
| endpoint url. |
| |
| If you define the bean in Spring XML or Blueprint, then you can |
| configure the property as follows: |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| <bean id="myService" class="com.foo.MyService"> |
| <property name="serviceEndpoint" value="activemq:queue:foo"/> |
| </bean> |
| ---- |
| |
| This allows you to configure the bean using any standard IoC style. |
| |
| Camel offers a naming convention which allows you to not have to |
| explicit name the property. + |
| Camel uses this algorithm to find the getter method. The method must be |
| a getXXX method. |
| |
| 1. Use the property name if explicit given |
| 2. If no property name was configured, then use the method name + |
| 3. Try to get the property with name*Endpoint* (eg with Endpoint as |
| postfix) |
| 4. Try to get the property with the name as is (eg no postfix or |
| postfix) |
| 5. If the property name starts with *on* then omit that, and try step 3 |
| and 4 again. |
| |
| So in the example above, we could have defined the @Consume annotation |
| as |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| @Consume(property = "service") |
| public void onService(String input) { |
| ---- |
| |
| Now the property is named 'service' which then would match step 3 from |
| the algorithm, and have Camel invoke the getServiceEndpoint method. |
| |
| We could also have omitted the property attribute, to make it implicit |
| |
| [source,syntaxhighlighter-pre] |
| ---- |
| @Consume |
| public void onService(String input) { |
| ---- |
| |
| Now Camel matches step 5, and loses the prefix *on* in the name, and |
| looks for 'service' as the property. And because there is a |
| getServiceEndpoint method, Camel will use that. |
| |
| [[POJOConsuming-Whichapproachtouse?]] |
| == Which approach to use? |
| |
| Using the @Consume annotations are simpler when you are creating a |
| simple route with a single well defined input URI. |
| |
| However if you require more complex routes or the same bean method needs |
| to be invoked from many places then please use the routing |
| xref:dsl.adoc[DSL] as shown above. |