Page History

// lets populate the context with the services we need
// note that we could just use a spring.xml file to avoid this step
JndiContext context = new JndiContext();
context.bind("bye", new SayService("Good Bye!"));

CamelContext camelContext = new DefaultCamelContext(context);

camelContext.addRoutes(new RouteBuilder() {

{snippet:id=route|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/component/pojo/PojoRouteTest.java}

A *bean:* endpoint cannot be defined as the input to the route; i.e. you cannot consume from it, you can only route from some inbound message [Endpoint] to the bean endpoint as output.  So consider using a *direct:* or *queue:* endpoint as the input.  

You can use the {{createProxy()}} methods on [ProxyHelper|http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/component/bean/ProxyHelper.html] to create a proxy that will generate BeanExchanges and send them to any endpoint:

{snippet:id=invoke|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/component/pojo/PojoRouteTest.java}

And the same route using Spring DSL:
{code:xml}
<route>
      public void configure() {
        from("direct:hello").to("bean:bye");
    }
});

Endpoint endpoint = camelContext.getEndpoint("direct:hello");
ISay proxy = PojoComponent.createProxy(endpoint, ISay.class);
String rc = proxy.say();
assertEquals("Good Bye!", rc);

<route> 
 <from uri="direct:hello">
   <to uri="bean:bye"/>
</route>
{code}

h3. Bean as endpoint
Camel also supports invoking [Bean] as an Endpoint. In the route below:
{snippet:id=e1|lang=xml|url=camel/trunk/components/camel-spring/src/test/resources/org/apache/camel/spring/bind/beanAsEndpoint.xml}
What happens is that when the exchange is routed to the {{myBean}} Camel will use the [Bean Binding] to invoke the bean.
The source for the bean is just a plain POJO:
{snippet:id=e1|lang=java|url=camel/trunk/components/camel-spring/src/test/java/org/apache/camel/spring/bind/ExampleBean.java}
Camel will use [Bean Binding] to invoke the {{sayHello}} method, by converting the Exchange's In body to the {{String}} type and storing the output of the method on the Exchange Out body.

h3. Java DSL bean syntax

Java DSL comes with syntactic sugar for the [Bean] component. Instead of specifying the bean explicitly as the endpoint (i.e. {{

<camelContext xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="direct:start"/>
    <to uri="myBean"/>
    <to uri="mock:results"/>
  </route>
</camelContext>

<bean id="myBean" class="org.apache.camel.spring.bind.ExampleBean"/>

public class ExampleBean {
    public String sayHello(String name) {
        return "Hello " + name + "!";
    }
}

{code:java}
// Send message to the bean endpoint 
// and invoke method resolved using Bean Binding. 
from("direct:start").beanRef("beanName"); 
 
// Send message to the bean endpoint 
// and invoke given method. 
from("direct:start").beanRef("beanName", "methodName");
{code}

Instead of passing name of the reference to the bean (so that Camel will lookup for it in the registry), you can specify the bean itself:

{code:java}

// Send message to the given bean instance. 
from("direct:start").bean(new ExampleBean());

// Explicit selection of bean method to be invoked.
from("direct:start").bean(new ExampleBean(), "methodName");

// Camel will create the instance of bean and cache it for you.
from("direct:start").bean(ExampleBean.class);
{code}

h3. Bean Binding

How bean methods to be invoked are chosen (if they are not specified explicitly through the *method* parameter) and how parameter values are constructed from the [Message] are all defined by the [Bean Binding] mechanism which is used throughout all of the various [Bean Integration] mechanisms in Camel.

{include:Endpoint See Also}
* [Class] component
* [Bean Binding]
* [Bean Integration]