camel docs java

akka-docs/java/code/docs/camel/ActivationTestBase.java

@@ -0,0 +1,49 @@
+package docs.camel;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import akka.camel.javaapi.UntypedConsumerActor;
+import akka.dispatch.Future;
+import akka.util.Duration;
+import akka.util.FiniteDuration;
+import org.junit.Test;
+
+import java.util.concurrent.TimeUnit;
+
+public class ActivationTestBase {
+
+  @Test
+  public void testActivation() {
+    //#CamelActivation
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = new Props(MyConsumer.class);
+    ActorRef producer = system.actorOf(props,"myproducer");
+    Camel camel = CamelExtension.get(system);
+    // get a future reference to the activation of the endpoint of the Consumer Actor
+    FiniteDuration duration = Duration.create(10, TimeUnit.SECONDS);
+    Future<ActorRef> activationFuture = camel.activationFutureFor(producer, duration);
+    // or, block wait on the activation
+    camel.awaitActivation(producer, duration);
+    //#CamelActivation
+    //#CamelDeactivation
+    system.stop(producer);
+    // get a future reference to the deactivation of the endpoint of the Consumer Actor
+    Future<ActorRef> deactivationFuture = camel.activationFutureFor(producer, duration);
+    // or, block wait on the deactivation
+    camel.awaitDeactivation(producer, duration);
+    //#CamelDeactivation
+    system.shutdown();
+  }
+
+  public static class MyConsumer extends UntypedConsumerActor {
+    public String getEndpointUri() {
+      return "direct:test";
+    }
+
+    public void onReceive(Object message) {
+    }
+  }
+}

akka-docs/java/code/docs/camel/CamelExtensionDocTest.scala

@@ -0,0 +1,5 @@
+package docs.camel
+
+import org.scalatest.junit.JUnitSuite
+
+class CamelExtensionDocTest extends CamelExtensionTestBase with JUnitSuite

akka-docs/java/code/docs/camel/CamelExtensionTestBase.java

@@ -0,0 +1,31 @@
+package docs.camel;
+
+import akka.actor.ActorSystem;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.junit.Test;
+
+public class CamelExtensionTestBase {
+  @Test
+  public void getCamelExtension() {
+    //#CamelExtension
+    ActorSystem system = ActorSystem.create("some-system");
+    Camel camel = CamelExtension.get(system);
+    CamelContext camelContext= camel.context();
+    ProducerTemplate producerTemplate = camel.template();
+    //#CamelExtension
+    system.shutdown();
+  }
+  public void addActiveMQComponent() {
+    //#CamelExtensionAddComponent
+    ActorSystem system = ActorSystem.create("some-system");
+    Camel camel = CamelExtension.get(system);
+    CamelContext camelContext= camel.context();
+    // camelContext.addComponent("activemq", ActiveMQComponent.activeMQComponent("vm://localhost?broker.persistent=false"))
+    //#CamelExtensionAddComponent
+    system.shutdown();
+  }
+
+}

akka-docs/java/code/docs/camel/Consumer1.java

@@ -0,0 +1,24 @@
+package docs.camel;
+//#Consumer1
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class Consumer1 extends UntypedConsumerActor {
+  LoggingAdapter log = Logging.getLogger(getContext().system(), this);
+
+  public String getEndpointUri() {
+    return "file:data/input/actor";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      log.info("Received message: {}", body);
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer1

akka-docs/java/code/docs/camel/Consumer2.java

@@ -0,0 +1,20 @@
+package docs.camel;
+//#Consumer2
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class Consumer2 extends UntypedConsumerActor {
+  public String getEndpointUri() {
+    return "jetty:http://localhost:8877/camel/default";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      getSender().tell(String.format("Received message: %s",body));
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer2

akka-docs/java/code/docs/camel/Consumer3.java

@@ -0,0 +1,31 @@
+package docs.camel;
+//#Consumer3
+import akka.actor.Status;
+import akka.camel.Ack;
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class Consumer3 extends UntypedConsumerActor{
+
+  @Override
+  public boolean autoack() {
+    return false;
+  }
+
+  public String getEndpointUri() {
+    return "jms:queue:test";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      getSender().tell(Ack.getInstance());
+      // on success
+      // ..
+      Exception someException = new Exception("e1");
+      // on failure
+      getSender().tell(new Status.Failure(someException));
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer3

akka-docs/java/code/docs/camel/Consumer4.java

@@ -0,0 +1,31 @@
+package docs.camel;
+//#Consumer4
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+import akka.util.Duration;
+import akka.util.FiniteDuration;
+
+import java.util.concurrent.TimeUnit;
+
+public class Consumer4 extends UntypedConsumerActor {
+  private final static FiniteDuration timeout = Duration.create(500, TimeUnit.MILLISECONDS);
+
+  @Override
+  public Duration replyTimeout() {
+    return timeout;
+  }
+
+  public String getEndpointUri() {
+    return "jetty:http://localhost:8877/camel/default";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      getSender().tell(String.format("Hello %s",body));
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer4

akka-docs/java/code/docs/camel/CustomRouteBuilder.java

@@ -0,0 +1,18 @@
+package docs.camel;
+//#CustomRoute
+import akka.actor.ActorRef;
+import akka.camel.internal.component.CamelPath;
+import org.apache.camel.builder.RouteBuilder;
+
+public class CustomRouteBuilder extends RouteBuilder{
+  private ActorRef responder;
+
+  public CustomRouteBuilder(ActorRef responder) {
+    this.responder = responder;
+  }
+
+  public void configure() throws Exception {
+    from("jetty:http://localhost:8877/camel/custom").to(CamelPath.toCamelUri(responder));
+  }
+}
+//#CustomRoute

akka-docs/java/code/docs/camel/CustomRouteTestBase.java

@@ -0,0 +1,20 @@
+package docs.camel;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+
+public class CustomRouteTestBase {
+  public void customRoute() throws Exception{
+    //#CustomRoute
+    ActorSystem system = ActorSystem.create("some-system");
+    Camel camel = CamelExtension.get(system);
+    ActorRef responder = system.actorOf(new Props(Responder.class), "TestResponder");
+    camel.context().addRoutes(new CustomRouteBuilder(responder));
+    //#CustomRoute
+    system.stop(responder);
+    system.shutdown();
+  }
+}

akka-docs/java/code/docs/camel/ErrorThrowingConsumer.java

@@ -0,0 +1,42 @@
+package docs.camel;
+//#ErrorThrowingConsumer
+import akka.actor.Status;
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+import org.apache.camel.builder.Builder;
+import org.apache.camel.model.ProcessorDefinition;
+import org.apache.camel.model.RouteDefinition;
+import scala.Option;
+
+public class ErrorThrowingConsumer extends UntypedConsumerActor{
+  private String uri;
+
+  public ErrorThrowingConsumer(String uri){
+    this.uri = uri;
+  }
+
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  public void onReceive(Object message) throws Exception{
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      throw new Exception(String.format("error: %s",body));
+    } else
+      unhandled(message);
+  }
+
+  @Override
+  public ProcessorDefinition<?> onRouteDefinition(RouteDefinition rd) {
+    // Catch any exception and handle it by returning the exception message as response
+    return rd.onException(Exception.class).handled(true).transform(Builder.exceptionMessage()).end();
+  }
+
+  @Override
+  public void preRestart(Throwable reason, Option<Object> message) {
+    getSender().tell(new Status.Failure(reason));
+  }
+}
+//#ErrorThrowingConsumer

akka-docs/java/code/docs/camel/FirstProducer.java

@@ -0,0 +1,10 @@
+package docs.camel;
+
+//#Producer1
+import akka.camel.javaapi.UntypedProducerActor;
+public class FirstProducer extends UntypedProducerActor {
+  public String getEndpointUri() {
+    return "http://localhost:8080/news";
+  }
+}
+//#Producer1

akka-docs/java/code/docs/camel/Forwarder.java

@@ -0,0 +1,23 @@
+package docs.camel;
+//#RouteResponse
+import akka.actor.ActorRef;
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class Forwarder extends UntypedProducerActor {
+  private String uri;
+  private ActorRef target;
+
+  public Forwarder(String uri, ActorRef target) {
+    this.uri = uri;
+    this.target = target;
+  }
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  @Override
+  public void onRouteResponse(Object message) {
+    target.forward(message,getContext());
+  }
+}
+//#RouteResponse

akka-docs/java/code/docs/camel/MyActor.java

@@ -0,0 +1,15 @@
+package docs.camel;
+//#ProducerTemplate
+import akka.actor.UntypedActor;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import org.apache.camel.ProducerTemplate;
+
+public class MyActor extends UntypedActor{
+  public void onReceive(Object message) {
+    Camel camel = CamelExtension.get(getContext().system());
+    ProducerTemplate template = camel.template();
+    template.sendBody("direct:news", message);
+  }
+}
+//#ProducerTemplate

akka-docs/java/code/docs/camel/MyEndpoint.java

@@ -0,0 +1,31 @@
+package docs.camel;
+
+//#Consumer-mina
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class MyEndpoint extends UntypedConsumerActor{
+  private String uri = "mina:tcp://localhost:6200?textline=true";
+
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  public void onReceive(Object message) throws Exception {
+    if (message instanceof CamelMessage) {
+      /* ... */
+    } else {
+      /* ... */
+    }
+  }
+
+  // Extra constructor to change the default uri,
+  // for instance to "jetty:http://localhost:8877/example"
+  public MyEndpoint(String uri) {
+    this.uri = uri;
+  }
+
+  public MyEndpoint() {
+  }
+}
+//#Consumer-mina

akka-docs/java/code/docs/camel/OnRouteResponseTestBase.java

@@ -0,0 +1,27 @@
+package docs.camel;
+
+import akka.actor.*;
+import org.junit.Test;
+
+public class OnRouteResponseTestBase {
+
+  public void onRouteResponse(){
+    //#RouteResponse
+    ActorSystem system = ActorSystem.create("some-system");
+    Props receiverProps = new Props(ResponseReceiver.class);
+    final ActorRef receiver = system.actorOf(receiverProps,"responseReceiver");
+    UntypedActorFactory factory = new UntypedActorFactory() {
+      public Actor create() {
+        return new Forwarder("http://localhost:8080/news/akka", receiver);
+      }
+    };
+    ActorRef forwardResponse = system.actorOf(new Props(factory));
+    // the Forwarder sends out a request to the web page and forwards the response to
+    // the ResponseReceiver
+    forwardResponse.tell("some request");
+    //#RouteResponse
+    system.stop(receiver);
+    system.stop(forwardResponse);
+    system.shutdown();
+  }
+}

akka-docs/java/code/docs/camel/OnewaySender.java

@@ -0,0 +1,20 @@
+package docs.camel;
+//#Oneway
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class OnewaySender extends UntypedProducerActor{
+  private String uri;
+
+  public OnewaySender(String uri) {
+    this.uri = uri;
+  }
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  @Override
+  public boolean isOneway() {
+    return true;
+  }
+}
+//#Oneway

akka-docs/java/code/docs/camel/Orders.java

@@ -0,0 +1,10 @@
+package docs.camel;
+//#Producer
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class Orders extends UntypedProducerActor{
+  public String getEndpointUri() {
+    return "jms:queue:Orders";
+  }
+}
+//#Producer

akka-docs/java/code/docs/camel/Producer1.java

@@ -0,0 +1,10 @@
+package docs.camel;
+//#Producer1
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class Producer1 extends UntypedProducerActor{
+  public String getEndpointUri() {
+    return "http://localhost:8080/news";
+  }
+}
+//#Producer1

akka-docs/java/code/docs/camel/ProducerTestBase.java

@@ -0,0 +1,53 @@
+package docs.camel;
+
+import akka.actor.*;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import akka.camel.CamelMessage;
+import akka.dispatch.Future;
+import akka.pattern.Patterns;
+import akka.util.Duration;
+import akka.util.FiniteDuration;
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+public class ProducerTestBase {
+  public void tellJmsProducer() {
+    //#TellProducer
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = new Props(Orders.class);
+    ActorRef producer = system.actorOf(props, "jmsproducer");
+    producer.tell("<order amount=\"100\" currency=\"PLN\" itemId=\"12345\"/>");
+    //#TellProducer
+    system.shutdown();
+  }
+
+  public void askProducer() {
+    //#AskProducer
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = new Props(FirstProducer.class);
+    ActorRef producer = system.actorOf(props,"myproducer");
+    Future<Object> future = Patterns.ask(producer, "some request", 1000);
+    //#AskProducer
+    system.stop(producer);
+    system.shutdown();
+  }
+
+  public void correlate(){
+    //#Correlate
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = new Props(Orders.class);
+    ActorRef producer = system.actorOf(props,"jmsproducer");
+    Map<String,Object> headers = new HashMap<String, Object>();
+    headers.put(CamelMessage.MessageExchangeId(),"123");
+    producer.tell(new CamelMessage("<order amount=\"100\" currency=\"PLN\" itemId=\"12345\"/>",headers));
+    //#Correlate
+    system.stop(producer);
+    system.shutdown();
+  }
+}

akka-docs/java/code/docs/camel/RequestBodyActor.java

@@ -0,0 +1,15 @@
+package docs.camel;
+//#RequestProducerTemplate
+import akka.actor.UntypedActor;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import org.apache.camel.ProducerTemplate;
+
+public class RequestBodyActor extends UntypedActor {
+  public void onReceive(Object message) {
+    Camel camel = CamelExtension.get(getContext().system());
+    ProducerTemplate template = camel.template();
+    getSender().tell(template.requestBody("direct:news", message));
+  }
+}
+//#RequestProducerTemplate

akka-docs/java/code/docs/camel/Responder.java

@@ -0,0 +1,25 @@
+package docs.camel;
+//#CustomRoute
+import akka.actor.UntypedActor;
+import akka.camel.CamelMessage;
+import akka.japi.Function;
+
+public class Responder extends UntypedActor{
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      getSender().tell(createResponse(camelMessage));
+    } else
+      unhandled(message);
+  }
+
+  private CamelMessage createResponse(CamelMessage msg) {
+    return msg.mapBody(new Function<String,String>() {
+      public String apply(String body) {
+        return String.format("received %s", body);
+      }
+    });
+  }
+}
+//#CustomRoute

akka-docs/java/code/docs/camel/ResponseReceiver.java

@@ -0,0 +1,13 @@
+package docs.camel;
+//#RouteResponse
+import akka.actor.UntypedActor;
+import akka.camel.CamelMessage;
+
+public class ResponseReceiver extends UntypedActor{
+  public void onReceive(Object message) {
+     if(message instanceof CamelMessage) {
+       // do something with the forwarded response
+     }
+  }
+}
+//#RouteResponse

akka-docs/java/code/docs/camel/Transformer.java

@@ -0,0 +1,36 @@
+package docs.camel;
+//#TransformOutgoingMessage
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedProducerActor;
+import akka.japi.Function;
+
+public class Transformer extends UntypedProducerActor{
+  private String uri;
+
+  public Transformer(String uri) {
+    this.uri = uri;
+  }
+
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  private CamelMessage upperCase(CamelMessage msg) {
+    return msg.mapBody(new Function<String,String>() {
+      public String apply(String body) {
+        return body.toUpperCase();
+      }
+    });
+  }
+
+  @Override
+  public Object onTransformOutgoingMessage(Object message) {
+    if(message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      return upperCase(camelMessage);
+    } else {
+      return message;
+    }
+  }
+}
+//#TransformOutgoingMessage

akka-docs/java/code/docs/camel/sample/http/HttpConsumer.java

@@ -0,0 +1,23 @@
+package docs.camel.sample.http;
+
+import akka.actor.ActorRef;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+//#HttpExample
+public class HttpConsumer extends UntypedConsumerActor{
+
+  private ActorRef producer;
+
+  public HttpConsumer(ActorRef producer){
+    this.producer = producer;
+  }
+
+  public String getEndpointUri() {
+    return "jetty:http://0.0.0.0:8875/";
+  }
+
+  public void onReceive(Object message) {
+    producer.forward(message, getContext());
+  }
+}
+//#HttpExample

akka-docs/java/code/docs/camel/sample/http/HttpProducer.java

@@ -0,0 +1,38 @@
+package docs.camel.sample.http;
+
+import akka.actor.ActorRef;
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedProducerActor;
+import org.apache.camel.Exchange;
+
+import java.util.HashSet;
+import java.util.Set;
+
+//#HttpExample
+public class HttpProducer extends UntypedProducerActor{
+  private ActorRef transformer;
+
+  public HttpProducer(ActorRef transformer) {
+    this.transformer = transformer;
+  }
+
+  public String getEndpointUri() {
+    return "jetty://http://akka.io/?bridgeEndpoint=true";
+  }
+
+  @Override
+  public Object onTransformOutgoingMessage(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      Set<String> httpPath = new HashSet<String>();
+      httpPath.add(Exchange.HTTP_PATH);
+      return camelMessage.addHeaders(camelMessage.getHeaders(httpPath));
+    } else return super.onTransformOutgoingMessage(message);
+  }
+
+  @Override
+  public void onRouteResponse(Object message) {
+    transformer.forward(message, getContext());
+  }
+}
+//#HttpExample

akka-docs/java/code/docs/camel/sample/http/HttpSample.java

@@ -0,0 +1,26 @@
+package docs.camel.sample.http;
+
+import akka.actor.*;
+
+public class HttpSample {
+  public static void main(String[] args) {
+    //#HttpExample
+    // Create the actors. this can be done in a Boot class so you can
+    // run the example in the MicroKernel. just add the below three lines to your boot class.
+    ActorSystem system = ActorSystem.create("some-system");
+    final ActorRef httpTransformer = system.actorOf(new Props(HttpTransformer.class));
+
+    final ActorRef httpProducer = system.actorOf(new Props(new UntypedActorFactory(){
+      public Actor create() {
+        return new HttpProducer(httpTransformer);
+      }
+    }));
+
+    ActorRef httpConsumer = system.actorOf(new Props(new UntypedActorFactory(){
+      public Actor create() {
+        return new HttpConsumer(httpProducer);
+      }
+    }));
+    //#HttpExample
+  }
+}

akka-docs/java/code/docs/camel/sample/http/HttpTransformer.java

@@ -0,0 +1,25 @@
+package docs.camel.sample.http;
+
+import akka.actor.Status;
+import akka.actor.UntypedActor;
+import akka.camel.CamelMessage;
+import akka.japi.Function;
+
+//#HttpExample
+public class HttpTransformer extends UntypedActor{
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      CamelMessage replacedMessage = camelMessage.mapBody(new Function<String, String>(){
+        public String apply(String body) {
+          return body.replaceAll("Akka ", "AKKA ");
+        }
+      });
+      getSender().tell(replacedMessage);
+    } else if (message instanceof Status.Failure) {
+      getSender().tell(message);
+    } else
+      unhandled(message);
+  }
+}
+//#HttpExample

akka-docs/java/code/docs/camel/sample/quartz/MyQuartzActor.java

@@ -0,0 +1,20 @@
+package docs.camel.sample.quartz;
+//#QuartzExample
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class MyQuartzActor extends UntypedConsumerActor{
+  public String getEndpointUri() {
+    return "quartz://example?cron=0/2+*+*+*+*+?";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      System.out.println(String.format("==============> received %s ", body));
+    } else
+      unhandled(message);
+  }
+}
+//#QuartzExample

akka-docs/java/code/docs/camel/sample/quartz/QuartzSample.java

@@ -0,0 +1,12 @@
+package docs.camel.sample.quartz;
+//#QuartzExample
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+
+public class QuartzSample {
+  public static void main(String[] args) {
+    ActorSystem system = ActorSystem.create("my-quartz-system");
+    system.actorOf(new Props(MyQuartzActor.class));
+  }
+}
+//#QuartzExample

akka-docs/java/code/docs/camel/sample/route/Consumer3.java

@@ -0,0 +1,27 @@
+package docs.camel.sample.route;
+
+//#CustomRouteExample
+import akka.actor.ActorRef;
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class Consumer3 extends UntypedConsumerActor{
+  private ActorRef transformer;
+
+  public Consumer3(ActorRef transformer){
+    this.transformer = transformer;
+  }
+
+  public String getEndpointUri() {
+    return "jetty:http://0.0.0.0:8877/camel/welcome";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      transformer.forward(camelMessage.getBodyAs(String.class, getCamelContext()),getContext());
+    } else
+      unhandled(message);
+  }
+}
+//#CustomRouteExample

akka-docs/java/code/docs/camel/sample/route/CustomRouteBuilder.java

@@ -0,0 +1,17 @@
+package docs.camel.sample.route;
+
+//#CustomRouteExample
+import org.apache.camel.Exchange;
+import org.apache.camel.Processor;
+import org.apache.camel.builder.RouteBuilder;
+
+public class CustomRouteBuilder extends RouteBuilder{
+  public void configure() throws Exception {
+    from("direct:welcome").process(new Processor(){
+      public void process(Exchange exchange) throws Exception {
+        exchange.getOut().setBody(String.format("Welcome %s",exchange.getIn().getBody()));
+      }
+    });
+  }
+}
+//#CustomRouteExample

akka-docs/java/code/docs/camel/sample/route/CustomRouteSample.java

@@ -0,0 +1,31 @@
+package docs.camel.sample.route;
+
+import akka.actor.*;
+import akka.camel.CamelExtension;
+
+public class CustomRouteSample {
+  public static void main(String[] args) {
+    try {
+      //#CustomRouteExample
+      // the below lines can be added to a Boot class, so that you can run the example from a MicroKernel
+      ActorSystem system = ActorSystem.create("some-system");
+      final ActorRef producer = system.actorOf(new Props(Producer1.class));
+      final ActorRef mediator = system.actorOf(new Props(new UntypedActorFactory() {
+        public Actor create() {
+          return new Transformer(producer);
+
+        }
+      }));
+      ActorRef consumer = system.actorOf(new Props(new UntypedActorFactory() {
+        public Actor create() {
+          return new Consumer3(mediator);
+
+        }
+      }));
+      CamelExtension.get(system).context().addRoutes(new CustomRouteBuilder());
+      //#CustomRouteExample
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}

akka-docs/java/code/docs/camel/sample/route/Producer1.java

@@ -0,0 +1,10 @@
+package docs.camel.sample.route;
+//#CustomRouteExample
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class Producer1 extends UntypedProducerActor{
+  public String getEndpointUri() {
+    return "direct:welcome";
+  }
+}
+//#CustomRouteExample

akka-docs/java/code/docs/camel/sample/route/Transformer.java

@@ -0,0 +1,29 @@
+package docs.camel.sample.route;
+//#CustomRouteExample
+import akka.actor.ActorRef;
+import akka.actor.UntypedActor;
+import akka.camel.CamelMessage;
+import akka.japi.Function;
+
+public class Transformer extends UntypedActor {
+  private ActorRef producer;
+
+  public Transformer(ActorRef producer) {
+    this.producer = producer;
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      // example: transform message body "foo" to "- foo -" and forward result to producer
+      CamelMessage camelMessage = (CamelMessage) message;
+      CamelMessage transformedMessage = camelMessage.mapBody(new Function<String, String>(){
+        public String apply(String body) {
+          return String.format("- %s -",body);
+        }
+      });
+      producer.forward(transformedMessage, getContext());
+    } else
+      unhandled(message);
+  }
+}
+//#CustomRouteExample