camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
Subject camel git commit: Added camel-scala docs to Gitbook
Date Mon, 23 May 2016 14:52:26 GMT
Repository: camel
Updated Branches:
  refs/heads/master 50da69dca -> df3083f63

Added camel-scala docs to Gitbook


Branch: refs/heads/master
Commit: df3083f63b3f5767c885f3579deeb039348bd8d0
Parents: 50da69d
Author: Andrea Cosentino <>
Authored: Mon May 23 16:51:04 2016 +0200
Committer: Andrea Cosentino <>
Committed: Mon May 23 16:51:25 2016 +0200

 .../src/main/docs/scala-dsl-eip.adoc            | 224 +++++++++++++++++++
 .../main/docs/scala-dsl-getting-started.adoc    |  59 +++++
 .../docs/scala-dsl-supported-languages.adoc     |  30 +++
 .../camel-scala/src/main/docs/scala-dsl.adoc    |  76 +++++++
 docs/user-manual/en/                  |   1 +
 5 files changed, 390 insertions(+)
diff --git a/components/camel-scala/src/main/docs/scala-dsl-eip.adoc b/components/camel-scala/src/main/docs/scala-dsl-eip.adoc
new file mode 100644
index 0000000..f8d52e6
--- /dev/null
+++ b/components/camel-scala/src/main/docs/scala-dsl-eip.adoc
@@ -0,0 +1,224 @@
+Scala Supported DSL
+The link:scala-dsl.html[Scala DSL] supports *every* DSL from the
+link:dsl.html[Java DSL].
+On this page we have examples for a number of the link:eip.html[EIP]s. +
+ You can check the
+test source code] for the Scala Component to find more examples.
+* 1 link:#ScalaDSL-EIP-Messagingsystems[Messaging systems]
+** 1.1 link:#ScalaDSL-EIP-Pipelinepipeline[Pipeline]
+** 1.2 link:#ScalaDSL-EIP-Filterfilter[Filter]
+* 2 link:#ScalaDSL-EIP-Messagingchannels[Messaging channels]
+** 2.1 link:#ScalaDSL-EIP-Deadletterchannel[Dead letter channel]
+* 3 link:#ScalaDSL-EIP-Messagerouting[Message routing]
+** 3.1 link:#ScalaDSL-EIP-Aggregator[Aggregator]
+** 3.2 link:#ScalaDSL-EIP-Contentbasedrouter[Content based router]
+** 3.3 link:#ScalaDSL-EIP-Delayer[Delayer]
+** 3.4 link:#ScalaDSL-EIP-Loadbalancer[Load balancer]
+** 3.5 link:#ScalaDSL-EIP-Multicast[Multicast]
+** 3.6 link:#ScalaDSL-EIP-Recipientlist[Recipient list]
+** 3.7 link:#ScalaDSL-EIP-Resequencer[Resequencer]
+** 3.8 link:#ScalaDSL-EIP-Splitter[Splitter]
+** 3.9 link:#ScalaDSL-EIP-Throttler[Throttler]
+* 4 link:#ScalaDSL-EIP-Messagetransformation[Message transformation]
+** 4.1 link:#ScalaDSL-EIP-Contentenricher[Content enricher]
+Messaging systems
+There is a simple syntax available for specifying pipeline, by simple
+putting `to` or `→` between the different steps in the pipeline.
+For more advanced use cases, you can also use a block-based syntax,
+where every step in the pipeline starts with either `to` or `→`.
+For a message filter, use the `when()` method with a parameter of type
+The `Exchange ⇒ Boolean`. In the example below, we use a Scala
+convenience method named `in` to access the 'in' message body; only
+messages where the 'in' message is `<hello/>` will arrive at the
+`mock:a` endpoint.
+Once again, if you need to specify a more advanced route, you can use
+the more elaborate syntax.
+Messaging channels
+Dead letter channel
+The[dead letter
+channel] can be created with the syntax similar to the one used in
+[Java DSL].
+"jms:in" errorHandler(deadLetterChannel("jms:error")) to "jms:out"
+You can also use different error handler available for the
+[Java DSL]. In particular
+Scala DSL supports
+// DefaultErrorHandler
+"jms:in" errorHandler(defaultErrorHandler) to "jms:out"
+// LoggingErrorHandler
+"jms:in" errorHandler(loggingErrorHandler.level(LoggingLevel.INFO).logName("com.example.MyLogger"))
to "jms:out"
+Message routing
+The aggregator EIP aggregates messages based on some message correlation
+criteria. In the Scala DSL, the `aggregate` method takes a function
+`Exchange ⇒ Any` to determine the correlation value for the exchange. In
+the sample below, message are being aggregated if the first 7 letters in
+the message body are the same.
+Content based router
+Similar to the link:scala-dsl-eip.html[Filter], the content based router
+uses `when` methods with `Exchange ⇒ Boolean` function literals and an
+optional `otherwise`. The function literal can contain plain Scala code
+as well as any of the link:scala-dsl-supported-languages.html[supported
+languages]. The example below routes a given message based on the
+language of the message body.
+Unlike a throttler, which only slows down messages if the rate exceeds a
+treshold, a delayer delays every messages with a fixed amount of time.
+An example: to delay every message going from `seda:a` to `mock:a` with
+1 second, you write...
+Our second example will delay the entire block (containing `mock:c`)
+without doing anything to `mock:b`
+Load balancer
+To distribute the message handling load over multiple endpoints, we add
+a `loadbalance` to our route definition. You can optionally specify a
+load balancer strategy, like `roundrobin`
+Multicast allows you to send a message to multiple endpoints at the same
+time. In a simple route, you can specify multiple targets in the `to` or
+`→` method call:
+Recipient list
+You can handle a static recipient list with a multicast or
+link:scala-dsl-eip.html[pipeline], but this EIP is usually applied when
+you want to dynamically determine the name(s) of the next endpoint(s) to
+route to. Use the `recipients()` method with a function literal
+(`Exchange => Any`) that returns the endpoint name(s). In the example
+below, the target endpoint name can be found in the String message
+starting at position 21.
+Because the `recipients()` method just takes a function literal, you can
+basically use any kind of valid Scala code to determine the endpoint
+name. Have a look at the next example which uses pattern matching to
+figure out where to send the message:
+Again, we can also use the same thing in a more block-like syntax. For
+this example, we use the Scala DSL's
+link:scala-dsl-supported-languages.html[support for JXPath] to determine
+the target.
+Use the `resequence` method to add a resequencer to the RouteBuilder.
+The method takes a function (`Exchange ⇒ Unit`) that determines the
+value to resequence on. In this example, we resequence messages based on
+the 'in' message body.
+The same EIP can also be used with a block-like syntax...
+... and with configurable batch size. In this last example, messages
+will be send to `mock:e` whenever a batch of 5 messages is available.
+To handle large message in smaller chunks, you can write a Scala
+`Exchange ⇒ Any*` method and add it to your route with the `splitter`
+method. As with many other EIPs, we support a short, in-line version as
+well as a more elaborate block based one.
+The above examples also show you how
+link:scala-dsl-supported-languages.html[other languages] like XPath can
+be within the Scala DSL.
+The throttler allows you to slow down messages before sending them
+along. The `throttle` methods allows you to specify the maximum
+throughput rate of message:
+It can also be used in front of block to throttle messages at that
+point. In the example below, message are passed on to `mock:b` in a
+normal rate (i.e. as fast as possible), but a maximum 3 messages/2
+seconds will arrive at the `mock:c` endpoint.
+Message transformation
+Content enricher
+Using a processor function (`Exchange → Unit`), you can alter/enrich the
+message content. This example uses a simple function literal to append
+`" says Hello"` to the message content:
+However, you can also define a separate method/function to handle the
+transformation and pass that to the `process` method instead. The
+example below uses pattern matching to enrich the message content:
+Off course, you can also use any other Camel component (e.g.
+link:velocity.html[Velocity]) to enrich the content and add it to a
diff --git a/components/camel-scala/src/main/docs/scala-dsl-getting-started.adoc b/components/camel-scala/src/main/docs/scala-dsl-getting-started.adoc
new file mode 100644
index 0000000..21cc41d
--- /dev/null
+++ b/components/camel-scala/src/main/docs/scala-dsl-getting-started.adoc
@@ -0,0 +1,59 @@
+Scala DSL Getting Started
+Just like the link:dsl.html[Java DSL], the Scala DSL has a RouteBuilder
+class (`org.apache.camel.scala.dsl.builder.RouteBuilder`) that you can
+extend to implement your own routes. This example shows two very simple
+INFO: From *Camel 2.15* onwards use
+org.apache.camel.scala.dsl.builder.ScalaRouteBuilder and pass in the
+CamelContext in the constructor, which will be used by the builder. The
+old class RouteBuilder is deprecated.
+If you compare this to the Java link:dsl.html[DSL], you notice:
+* there is no configure() method to override
+* a route starts directly with a URI instead of `from(uri)`
+* `→` is just an alias for `to`
+Setting the route ID
+To assign the unique ID to the Scala route, insert the `routeId` method
+invocation after the "from" part of the DSL.
+ "direct:a" routeId "route-b" to "mock:b"
+Creating a new Camel Scala project
+Camel offers link:camel-maven-archetypes.html[Maven archetypes] that
+allow you to quickly setup a new project.
+To do this, you can execute the following Maven goal from the command
+line (using Maven 3.0.3 or better):
+mvn archetype:generate
+This runs Maven interactively - just type `camel` and press <Enter> to
+filter for Camel-related archetypes. +
+ From the list, pick the number for `camel-archetype-scala`, then fill
+in the remaining details (such as the Camel version, _et cetera_).
+The generated project has a "readme" file with more instructions, and is
+ready to compile and run from Maven using:
+mvn compile exec:java
diff --git a/components/camel-scala/src/main/docs/scala-dsl-supported-languages.adoc b/components/camel-scala/src/main/docs/scala-dsl-supported-languages.adoc
new file mode 100644
index 0000000..bbdb72a
--- /dev/null
+++ b/components/camel-scala/src/main/docs/scala-dsl-supported-languages.adoc
@@ -0,0 +1,30 @@
+Scala DSL Supported Languages
+Support for link:languages.html[other languages] inside the Scala DSL
+routes is delivered through traits. The
+`org.apache.camel.scala.dsl.languages` package currently offers traits
+to support XPath. To use any given language, you can mix-in the trait
+when creating your `RouteBuilder`.
+You can use any of the supported Camel link:languages.html[Languages] in
+the link:scala-dsl.html[Scala DSL]; see below for a couple of examples:
+Using link:xpath.html[XPath]
+With the XPath trait, you have an additional method available on an
+`Exchange` to do XPath queries against the message. Just look at this
+Splitter example, where the `xpath` method is used in a
+`Exchange ⇒ Any*` function literal
+Using link:jxpath.html[JXPath]
+With the `org.apache.camel.scala.dsl.languages.JXPath` trait, you can an
+additional `jxpath` method on the `Exchange`. In the Recipient List
+example below, JXPath is used for getting the next endpoint's name out
+of the message body.
diff --git a/components/camel-scala/src/main/docs/scala-dsl.adoc b/components/camel-scala/src/main/docs/scala-dsl.adoc
new file mode 100644
index 0000000..7c2b54a
--- /dev/null
+++ b/components/camel-scala/src/main/docs/scala-dsl.adoc
@@ -0,0 +1,76 @@
+About the Scala DSL
+[Scala] is a general purpose programming
+language designed to express common programming patterns in a concise,
+elegant, and type-safe way. It integrates very well with the Java
+platform. Our Scala DSL implementation is built on top of the existing
+Java-based link:dsl.html[DSL], but it adds Scala syntax sugar to make
+building routes even more convenient.
+* link:scala-dsl-getting-started.html[Scala DSL - Getting Started] gives
+you basic information on how to use the Scala DSL.
+* link:scala-dsl-eip.html[Scala DSL - EIP] shows you the Scala DSL
+syntax for every EIP supported. link:scala-dsl.html[Scala DSL] supports
+every EIP from the link:dsl.html[Java DSL].
+* link:scala-dsl-supported-languages.html[Scala DSL - Supported
+languages] explains the usage of traits to add support for other
+languages (e.g. XPath)
+* At[ApacheCon Europe 2008] there was a Fast
+Feather talk that introduced some of the basic Scala language concepts
+that are being used for building the Scala DSL.
+[Here are the presentation
+slides] .
+* Here's a
+post] demonstrating the link:message-filter.html[Message Filter] EIP
+within the link:scala-dsl.html[Scala DSL], as well as how to use
+link:camel-test.html[Camel's test kit] to test the example.
+To use the Scala DSL in your camel routes you need to add the a
+dependency on *camel-scala* which implements the Scala DSL.
+If you use maven you could just add the following to your pom.xml,
+substituting the version number for the latest & greatest release (see
+the download page for the latest versions).
+  <groupId>org.apache.camel</groupId>
+  <artifactId>camel-scala</artifactId>
+  <version>x.x.x</version>
+  <!-- use the same version as your Camel core version -->
+Starting from version 2.11 Camel Scala DSL is compiled against Scala
+2.10. If you plan to use Scala 2.9 with Camel 2.11, add the following to
+your pom.xml file instead.
+  <groupId>org.apache.camel</groupId>
+  <artifactId>camel-scala_2.9</artifactId>
+  <version>2.11.x</version>
+  <!-- use the same version as your Camel core version -->
+Support for Scala 2.9 is deprecated and will be removed starting from
+the Camel 2.12 and 3.0.
diff --git a/docs/user-manual/en/ b/docs/user-manual/en/
index 1578c1f..fafc453 100644
--- a/docs/user-manual/en/
+++ b/docs/user-manual/en/
@@ -12,6 +12,7 @@
     * [Exchange Pattern](exchange-pattern.adoc)
     * [Registry](registry.adoc)
     * [RX](rx.adoc)
+    * [Scala DSL](scala-dsl.adoc)
     * [AOP](aop.adoc)

View raw message