要使用 域特定语言 (DSL)，您可以扩展 RouteBuilder 类并覆盖其 configure（） 方法（您定义路由规则）。

您可以根据需要定义多个 RouteBuilder 类。每个类都会实例化一次，并在 CamelContext 对象中注册。通常，每个 RouteBuilder 对象的生命周期由您在其中部署路由器的容器自动管理。

作为路由器开发人员，您的核心任务是实施一个或多个 RouteBuilder 类。您可以从继承两种替代 RouteBuilder 类：

RouteBuilder 类定义用于启动路由规则的方法（例如，来自（）、拦截器 （） 和 exception（））。

例 1.1 “RouteBuilder 类的实现” 显示最小的 RouteBuilder 实施。configure（） 方法正文包含路由规则；每个规则都是单个 Java 语句。

import org.apache.camel.builder.RouteBuilder;

public class MyRouteBuilder extends RouteBuilder {

public void configure() {
  // Define routing rules here:
  from("file:src/data?noop=true").to("file:target/messages");

  // More rules can be included, in you like.
  // ...
}
}

来自URL1.to(URL2) 的规则形式指示路由器从目录 src/data 读取文件，并将它们发送到目录 目标/消息。选项 ?noop=true 指示路由器保留（而不是删除） src/data 目录中的源文件。

域特定语言(DSL)是专为特殊用途而设计的微型语言。DSL 不需要逻辑上完成，但需要足够的表达力来描述所选域中的问题。通常，DSL 不需要 专用的解析程序、解释器或编译器。DSL 可以在现有面向对象的主机语言之上 piggyback，提供 DSL 构造在主机语言 API 中彻底构造。

在假设 DSL 中请考虑以下命令序列：

command01;
command02;
command03;

您可以将这些命令映射到 Java 方法调用，如下所示：

command01().command02().command03()

您甚至可将块映射到 Java 方法调用。例如：

command01().startBlock().command02().command03().endBlock()

DSL 语法由主机语言 API 的数据类型隐式定义。例如，Java 方法的返回类型决定了您可以法律地调用哪些方法（与 DSL 中的下一个命令相同）。

Apache Camel 定义了一个 路由器 DSL，用于定义路由规则。您可以使用此 DSL 在 RouteBuilder.configure（） 实施的正文中定义规则。图 1.1 “本地路由规则” 展示了定义本地路由规则的基本语法概述。

图 1.1. 本地路由规则

本地规则始终以 ("EndpointURL") 方法开头，该方法指定路由规则的消息（使用者端点）来源。然后您可以在规则中添加任意较长的处理器链（如 filter（））。您通常通过 to("EndpointURL") 方法关闭规则，它指定通过规则传递的消息的目标（制作端点）。但是，始终不需要以 to（） 结束规则。在规则中指定消息目标的方法有其他方法。

本地规则始终通过定义消费者端点（使用 ("EndpointURL") ）开始，并且通常（但并不总是）通过定义制作者端点（使用 to("EndpointURL") ）来结束。端点 URL EndpointURL 可以使用部署时配置的任何组件。例如，您可以使用文件端点、file:MyMessageDirectory、Apache CXF 端点、cxf:MyServiceName 或 Apache ActiveMQ 端点 activemq:queue:MyQName。有关组件类型的完整列表，请参阅 Apache Camel 组件参考。

Exchange 对象由元数据增强的消息组成。交换是 Apache Camel 中的集中重要性，因为交换是通过路由规则传播消息的标准表单。交换的主要特征是，如下所示：

使用 Exchange 对象可轻松地将消息处理规范化为 不同的消息交换模式。例如，异步协议可以定义一个 MEP，它由一个消息组成，消息从消费者端点流到制作者端点（ 仅适用 MEP）。另一方面，RPC 协议可能会定义由请求消息和回复消息（一个 InOut MEP）组成的 MEP。目前，Apache Camel 支持以下 MEPs：

其中，这些消息交换模式由枚举类型中的常数来表示，即 org.apache.camel.ExchangePattern。

有时，有一个封装多个交换实例的单一交换很有用。为了实现此目的，您可以使用一个 分组的交换。分组交换基本上是一个交换实例，其中包含存储在 Exchange.GROUPED_EXCHANGE 交换属性中的 java.util.List 的 Exchange 对象。有关如何使用分组交换的示例，请参阅 第 8.5 节 “聚合器”。

处理器 是路由中的节点，可访问和修改通过路由进行的交换流。处理器可以使用 表达式或 predicate 参数，用于修改其行为。例如，图 1.1 “本地路由规则” 中显示的规则包含一个 filter（） 处理器，该处理器使用 xpath（） predicate 作为其参数。

表达式（评估为字符串或其他数据类型）和 predicates（显示为 true 或 false）经常作为内置处理器类型的参数。例如，以下过滤器规则会传播 In 消息，只有在 foo 标头等于值 bar 时：

from("seda:a").filter(header("foo").isEqualTo("bar")).to("seda:b");

如果过滤器由 predicate、header("foo").isEqualTo("bar") 授权。要根据消息内容构建更加复杂的 predicates 和表达式，您可以使用以下一种表达式和谓词语言（请参阅 第 II 部分 “路由表达式和指定语言”）。

路由器 schema>_<- the definition XML DSL-abrtbelongs 到以下 XML 模式命名空间：

http://camel.apache.org/schema/spring

路由器模式的位置通常指定为 http://camel.apache.org/schema/spring/camel-spring.xsd，它引用 Apache Web 站点上 schema 的最新版本。例如，Apache Camel Spring 文件的 root Bean 元素通常配置为 例 1.2 “指定路由器架构位置”。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:camel="http://camel.apache.org/schema/spring"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

  <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <!-- Define your routing rules here -->
  </camelContext>
</beans>

在运行时，Apache Camel 不会从 Spring 文件中指定的架构位置下载路由器模式。相反，Apache Camel 会自动从 camel-spring JAR 文件的根目录获取 schema 的副本。这样可确保用于解析 Spring 文件的 schema 版本始终与当前的运行时版本匹配。这很重要，因为 Apache 网站上发布的模式的最新版本可能与当前使用的运行时版本不匹配。

通常，建议您使用全功能 XML 编辑器编辑 Spring 文件。借助 XML 编辑器的自动完成功能，编写符合路由器架构的 XML 更轻松，如果 XML 不正确，编辑器也会立即提醒您。

XML 编辑器 通常 依赖从您在 xsi:schemaLocation 属性中指定的位置下载 schema。为了确保您使用正确的 schema 版本，最好选择 camel-spring.xsd 文件的特定版本。例如，若要为 Apache Camel 的 2.3 版本编辑 Spring 文件，您可以修改 Bean 元素，如下所示：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:camel="http://camel.apache.org/schema/spring"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring-2.3.0.xsd">
...

编辑完成后，请更改默认值( camel-spring.xsd )。要查看当前可用于下载的模式版本，请导航至网页 http://camel.apache.org/schema/spring。

Apache Camel 端点是路由中消息的源和接收器。端点是一个非常一般的构建块：它必须满足的唯一要求是它充当消息来源（制作端点）或作为消息（消费者端点）的接收器（消费者端点）。因此，Apache Camel 中支持各种不同的端点类型，范围从协议支持端点（如 HTTP）到简单的计时器端点，如 Quartz，以固定间隔生成 dummy 消息。Apache Camel 的主要优势之一是，相对容易地添加实施新端点类型的自定义组件。

端点通过 端点 URI 标识，其通用表单如下：

scheme:contextPath[?queryOptions]

URI 方案 标识了协议，如 http，contextPath 提供由协议解释的 URI 详情。另外，大多数方案都允许您定义查询选项，而 queryOptions 则采用以下格式指定：

?option01=value01&option02=value02&...

例如，以下 HTTP URI 可以用来连接到 Google 搜索引擎页面：

http://www.google.com

以下文件 URI 可用于读取在 C:\temp\src\data 目录下出现的所有文件：

file://C:/temp/src/data

不是每个 方案 都代表了一个协议。有时候，方案 只需提供对有用的实用程序（如计时器）的访问。例如，以下计时器端点 URI 每秒生成交换一次（=1000 毫秒）。您可以使用它来调度路由中的活动。

timer://tickTock?period=1000

有时，端点 URI 可能会因为提供的所有配置信息而变得非常长。在 JBoss Fuse 6.2 中，您可以采用两种方法使您使用冗长的 URI 更易于管理。

许多 Apache Camel 组件都有选项，其值是时间段（例如，指定超时值等）。默认情况下，此类时间周期选项通常指定为纯数字，被解释为毫秒的时间段。但是，Apache Camel 还支持更易读的语法，它可让您用小时、分钟和秒来表达周期。正式，人类可读的时间段是一个符合以下语法的字符串：

[NHour(h|hour)][NMin(m|minute)][NSec(s|second)]

在方括号 [] 中，每个术语都是可选的，并且符号 (A|B) 表示 A 和 B 是 alternatives。

例如，您可以使用 45 分钟的时间配置计时器 端点，如下所示：

from("timer:foo?period=45m")
  .to("log:foo");

您还可以使用小时、分钟和第二个单元的任意组合，如下所示：

from("timer:foo?period=1h15m")
  .to("log:foo");
from("timer:bar?period=2h30s")
  .to("log:bar");
from("timer:bar?period=3h45m58s")
  .to("log:bar");

默认情况下，您在 URI 中指定的选项值会自动进行 URI 编码。在某些情况下这是不需要的行为。例如，当设置 password 选项时，最好在 没有 URI 编码的情况下 传输原始字符字符串。

通过利用语法指定选项值，可以切换 URI 编码，即 RAW(RawValue)。例如，

from("SourceURI")
 .to("ftp:joe@myftpserver.com?password=RAW(se+re?t&23)&binary=true")

在本例中，密码值作为字面值传输，即 se+re?t&23。

某些端点 URI 选项映射到 Java enum constants。例如，Log 组件的 level 选项可以采用 enum 值 INFO、WARN、ERROR 等等。这个类型转换不区分大小写，因此可以使用以下任意一种选项来设置日志制作者端点的日志记录级别：

<to uri="log:foo?level=info"/>
<to uri="log:foo?level=INfo"/>
<to uri="log:foo?level=InFo"/>

从 Camel 2.17，基于资源组件（如 XSLT）可以使用 ref: 作为前缀从 Registry 加载资源文件。

例如，如果myvelocityscriptbean 和 mysimplescriptbean 是 registry 中的两个 Bean 的 ID，您可以按照如下所示使用这些 Bean 的内容：

Velocity endpoint:
------------------
from("velocity:ref:myvelocityscriptbean").<rest_of_route>.

Language endpoint (for invoking a scripting language):
-----------------------------------------------------
from("direct:start")
  .to("language:simple:ref:mysimplescriptbean")
 Where Camel implicitly converts the bean to a String.

每个 URI 方案 都映射到 Apache Camel 组件，其中 Apache Camel 组件基本上是一个端点工厂。换句话说，若要使用特定类型的端点，您必须在运行时容器中部署对应的 Apache Camel 组件。例如，若要使用 JMS 端点，您要在容器中部署 JMS 组件。

Apache Camel 提供了大量不同的组件，可让您将应用程序与各种传输协议和第三方产品集成。例如，一些常用的组件有： File、JMS、CXF（Web 服务）、HTTP、Jetty、Direct 和 Mock。有关支持组件的完整列表，请参阅 Apache Camel 组件文档。

大多数 Apache Camel 组件都单独打包成 Camel 内核。如果您使用 Maven 构建应用程序，只需在相关组件构件上添加依赖项即可向应用程序中添加组件（及其第三方依赖项）。例如，要包含 HTTP 组件，您要将以下 Maven 依赖项添加到项目 POM 文件中：

<!-- Maven POM File -->
  <properties>
    <camel-version>{camelFullVersion}</camel-version>
    ...
  </properties>

  <dependencies>
    ...
    <dependency>
      <groupId>org.apache.camel</groupId>
      <artifactId>camel-http</artifactId>
      <version>${camel-version}</version>
    </dependency>
    ...
  </dependencies>

以下组件内置到 Camel 内核（在 camel 内核 工件中），因此始终可用：

消费者端点 是在路由 开始时 出现的端点（即，在 from（） DSL 命令中）。换句话说，使用者端点负责在路由中发起处理：它创建一个新的交换实例（通常基于它收到或获取的一些消息），并提供线程来处理路由的其余部分中的交换。

例如，以下 JMS 使用者端点会拉取出 支付 队列的消息，并在路由中处理它们：

from("jms:queue:payments")
  .process(SomeProcessor)
  .to("TargetURI");

或者，在 Spring XML 中：

<camelContext id="CamelContextID"
              xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="jms:queue:payments"/>
    <process ref="someProcessorId"/>
    <to uri="TargetURI"/>
  </route>
</camelContext>

一些组件 只是消费者 ，它们只能被用来定义消费者端点。例如，Panartz 组件专门用于定义消费者端点。以下 Quartz 端点每秒钟生成一个事件（1000 毫秒）：

from("quartz://secondTimer?trigger.repeatInterval=1000")
  .process(SomeProcessor)
  .to("TargetURI");

如果您愿意，可以使用 fromF（） Java DSL 命令，将端点 URI 指定为格式的字符串。例如，要将用户名和密码替换为 FTP 端点的 URI，您可以使用 Java 编写路由，如下所示：

fromF("ftp:%s@fusesource.com?password=%s", username, password)
  .process(SomeProcessor)
  .to("TargetURI");

其中，第一个位置的 %s 替换为用户名字符串的值，第二次出现 %s 替换为密码 字符串。这个字符串格式化机制由 String.format（） 实施，它类似于 C printf（） 函数提供的格式。详情请查看 java.util.Formatter。

制作者端点 是在 中间 或路由 末尾 出现的端点（例如，在 to（） DSL 命令中）。换句话说，制作者端点接收现有的交换对象，并将交换内容发送到指定的端点。

例如，以下 JMS producer 端点将当前交换的内容推送到指定的 JMS 队列：

from("SourceURI")
  .process(SomeProcessor)
  .to("jms:queue:orderForms");

也可以在 Spring XML 中：

<camelContext id="CamelContextID" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="SourceURI"/>
    <process ref="someProcessorId"/>
    <to uri="jms:queue:orderForms"/>
  </route>
</camelContext>

某些组件 只是制作者 ，只能用来定义制作者端点。例如，HTTP 端点专门用于定义制作者端点。

from("SourceURI")
  .process(SomeProcessor)
  .to("http://www.google.com/search?hl=en&q=camel+router");

如果您愿意，可以使用 toF（） Java DSL 命令，将端点 URI 指定为格式的字符串。例如，要将自定义 Google 查询替换为 HTTP URI，您可以使用 Java 编写路由，如下所示：

from("SourceURI")
  .process(SomeProcessor)
  .toF("http://www.google.com/search?hl=en&q=%s", myGoogleQuery);

如果出现 %s 被您的自定义查询字符串 myGoogleQuery 来替换。详情请查看 java.util.Formatter。

要让路由器执行比简单地将消费者端点连接到制作者端点更有趣的事情，您可以将 处理器 添加到路由中。处理器是一个命令，您可以插入到路由规则中，以执行任何通过规则流的消息处理。Apache Camel 提供各种处理器，如 表 1.1 “Apache Camel Processors” 所示。

要了解如何在路由中使用处理器，请查看以下示例：

choice（） 处理器是一个条件语句，用于将传入的消息路由到替代制作者端点。每个替代制作者端点的前面为一个 when（） 方法，该方法使用一个 predicate 参数。如果 predicate 为 true，则会选择以下目标，否则处理继续进行规则中的下一个 when（） 方法。例如，以下 choice（） 处理器将传入消息定向到 Target1、Target 2 或 Target3，具体取决于 Predicate1 和 Predicate2 的值：

from("SourceURL")
    .choice()
        .when(Predicate1).to("Target1")
        .when(Predicate2).to("Target2")
        .otherwise().to("Target3");

也可以在 Spring XML 中：

<camelContext id="buildSimpleRouteWithChoice" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="SourceURL"/>
    <choice>
      <when>
        <!-- First predicate -->
        <simple>header.foo = 'bar'</simple>
        <to uri="Target1"/>
      </when>
      <when>
        <!-- Second predicate -->
        <simple>header.foo = 'manchu'</simple>
        <to uri="Target2"/>
      </when>
      <otherwise>
        <to uri="Target3"/>
      </otherwise>
    </choice>
  </route>
</camelContext>

在 Java DSL 中，有一个特殊情形，您可能需要使用 endChoice（） 命令。某些标准 Apache Camel 处理器允许您使用特殊子使用指定额外参数，从而有效地打开额外的嵌套级别，这通常由 end（） 命令终止。例如，您可以将负载均衡器子指定为 loadBalance（）.round SDin（）.to("mock:foo").to(" mock:bar ").end（），它加载 balances 信息在 模拟：foo 和模拟：bar 端点之间进行负载平衡。但是，如果负载均衡器条款嵌入到所选条件中，需要使用 endChoice（） 命令终止子句，如下所示：

from("direct:start")
    .choice()
        .when(bodyAs(String.class).contains("Camel"))
            .loadBalance().roundRobin().to("mock:foo").to("mock:bar").endChoice()
        .otherwise()
            .to("mock:result");

filter（） 处理器可用于防止不间断消息到达制作者端点。它取一个 predicate 参数：如果 predicate 为 true，则允许消息交换给制作者；如果 predicate 为 false，则会阻止消息交换。例如，以下过滤器将阻止消息交换，除非传入消息包含标题为 foo，值设为 bar ：

from("SourceURL").filter(header("foo").isEqualTo("bar")).to("TargetURL");

也可以在 Spring XML 中：

<camelContext id="filterRoute" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="SourceURL"/>
    <filter>
      <simple>header.foo = 'bar'</simple>
      <to uri="TargetURL"/>
    </filter>
  </route>
</camelContext>

throttle（） 处理器确保制作者端点不会超载。throttler 通过限制每秒可传递的消息数量来实现。如果传入的消息超过指定率，则节流器会在缓冲区中累积过量消息，并将它们更慢地传输到制作者端点。例如，要将吞吐量率限制为每秒 100 个消息，您可以定义以下规则：

from("SourceURL").throttle(100).to("TargetURL");

也可以在 Spring XML 中：

<camelContext id="throttleRoute" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="SourceURL"/>
    <throttle maximumRequestsPerPeriod="100" timePeriodMillis="1000">
      <to uri="TargetURL"/>
    </throttle>
  </route>
</camelContext>

如果此处描述的标准处理器都不提供您需要的功能，您可以始终定义自己的自定义处理器。要创建自定义处理器，请定义一个实施 org.apache.camel.Processor 接口的类，并覆盖 process（） 方法。以下自定义处理器 MyProcessor 会从传入信息中删除名为 foo 的标头：

public class MyProcessor implements org.apache.camel.Processor {
public void process(org.apache.camel.Exchange exchange) {
  inMessage = exchange.getIn();
  if (inMessage != null) {
      inMessage.removeHeader("foo");
  }
}
};

要将自定义处理器插入到路由器规则中，调用 process（） 方法，它为将处理器插入到规则中提供了通用机制。例如，以下规则调用 例 1.3 “实施自定义处理器类” 中定义的处理器：

org.apache.camel.Processor myProc = new MyProcessor();

from("SourceURL").process(myProc).to("TargetURL");

在 Apache Camel 中，pipelining 是路由定义中连接节点的主要范式。管道概念可能对 UNIX 操作系统的用户最熟悉，其中用于加入操作系统命令。例如， ls | 更多 是一个命令示例，它将目录列表传送到 page-scrolling 实用程序，更多。管道的基本概念是，一个命令的输出 将进入下一个 输入 中。如果路由的情况是，从一个处理器的 Out 消息被复制到下一处理器的 In 消息，则类似情况。

路由中的每个节点（除初始端点外）都是一个 处理器，它的确是从 org.apache.camel.Processor 接口继承的意义。换句话说，处理器构成 DSL 路由的基本构建块。例如： DSL 命令，如 filter （）、delayer（）、 setBody（）、 setHeader（） 和 to（） 所有代表的处理器。当考虑到处理器如何连接路由时，务必要区分两种不同的处理方法。

第一种方法是，处理器只需要修改交换的消息，如 图 2.1 “处理器修改信息” 所示。在这种情况下，交换的 Out 消息仍保持 null。

图 2.1. 处理器修改信息

以下路由显示了一个 setHeader（） 命令，它通过添加（或修改） BillingSystem 标题来修改当前的 In 消息：

from("activemq:orderQueue")
    .setHeader("BillingSystem", xpath("/order/billingSystem"))
    .to("activemq:billingQueue");

第二种方法是，处理器创建 Out 信息来表示处理的结果，如 图 2.2 “处理器创建 Out 消息” 所示。

图 2.2. 处理器创建 Out 消息

以下路由显示了一个 transform（） 命令，该命令会 创建一个带有包含字符串 DummyBody 的消息正文：

from("activemq:orderQueue")
    .transform(constant("DummyBody"))
    .to("activemq:billingQueue");

其中 常量("DummyBody") 代表一个恒定表达式。您不能直接传递字符串 DummyBody，因为对 transform（） 的参数必须是表达式类型。

图 2.3 “InOnly Exchanges 的 Pipeline 示例” 显示用于 InOnly 交换的处理器管道示例。处理器 A 通过修改 In 消息，而处理器 B 和 C 创建 Out 消息。路由构建器按照所示将处理器链接在一起。特别是，B 和 C 以 管道 的形式链接在一起：也就是说，处理器 B 的 Out 消息移到 In 消息，在向处理器 C 传输交换前，处理器 C 的 Out 消息移到 In 消息，然后再将处理器 C 的 Out 消息移到 In 消息中。因此，处理器的输出和输入被加入到持续管道中，如 图 2.3 “InOnly Exchanges 的 Pipeline 示例” 所示。

图 2.3. InOnly Exchanges 的 Pipeline 示例

Apache Camel 默认使用管道模式，因此您无需使用任何特殊语法在路由中创建管道。例如，以下路由从 userdataQueue 队列拉取消息，通过 Velocity 模板管道消息（以便以文本格式生成客户地址），然后将生成的文本地址发送到队列，envelopeAddresses:

from("activemq:userdataQueue")
    .to(ExchangePattern.InOut, "velocity:file:AdressTemplate.vm")
    .to("activemq:envelopeAddresses");

在文件系统中，Velocit y:file:AddressTemplate.vm 指定 Velocity 模板文件的位置，file:AddressTemplate.vm。to（） 命令在将交换模式发送到 Velocity 端点之前，将交换模式更改为 InOut，然后将它改回到 InOnly 后。有关速率端点的详情，请参阅 Apache Camel 组件参考指南 中的 Velocity。

图 2.4 “InOut Exchanges 的 Pipeline 示例” 演示了 InOut 交换的处理器管道示例，您通常会用来支持远程过程调用(RPC)语义。处理器 A、B 和 C 以管道的形式链接，以及每个处理器的输出进入下一版本的输入。制作者端点生成的最终 Out 消息将将所有方式发送到消费者端点，在其中提供原始请求的回复。

图 2.4. InOut Exchanges 的 Pipeline 示例

请注意，为了支持 InOut 交换模式，重要的是，路由中最后一个节点（无论是制作者端点还是其他类型的处理器）会创建一个 Out 消息。否则，连接到消费者端点的任何客户端都会挂起并无限期等待回复消息。您应该注意，并非所有制作者端点都会创建 Out 消息。

通过处理传入的 HTTP 请求来考虑以下处理支付请求的路由：

from("jetty:http://localhost:8080/foo")
    .to("cxf:bean:addAccountDetails")
    .to("cxf:bean:getCreditRating")
    .to("cxf:bean:processTransaction");

如果传入的支付请求通过通过 Web 服务管道、cxf:bean:addAccountDetails、cxf:bean:bean:getCreditRating、cxf:bean:processTransaction 来处理。最后的 Web 服务 processTransaction 生成通过 JETTTY 端点发回的响应（Out 消息）。

当管道只由一系列端点组成时，也可以使用以下替代语法：

from("jetty:http://localhost:8080/foo")
    .pipeline("cxf:bean:addAccountDetails", "cxf:bean:getCreditRating", "cxf:bean:processTransaction");

In OptionalOut Exchanges 的管道基本上与 图 2.4 “InOut Exchanges 的 Pipeline 示例” 中的管道相同。In Out 和 InoptionalOut 之间的区别在于，可以使用" 可选Out 交换"模式交换作为答复。也就是说，如果是 In OptionalOut 交换，则会将 nullOut 消息复制到管道中下一节点的 In 消息。相反，如果是 In Out 交换，则会丢弃 nullOut 消息，并且当前节点中的原始 In 消息将被复制到下一节点的 In 消息中。

标准路由仅使用 Java DSL 中的 from(EndpointURL) 语法从单一端点中获取其输入。但是，如果您需要为路由定义多个输入，该怎么办？Apache Camel 提供了一些替代方法来指定多个到路由的输入。采取的方法取决于您是否希望相互独立处理交换，还是您希望以某种方式组合使用不同输入的交换（在这种情况下，您应该使用 “内容增强器模式”一节）。

指定多个输入的最简单方法是使用 from（） DSL 命令的多参数形式，例如：

from("URI1", "URI2", "URI3").to("DestinationUri");

或者您可以使用以下等效语法：

from("URI1").from("URI2").from("URI3").to("DestinationUri");

在这两个示例中，从每个输入端点、URI1、URI 2 和 URI3 中交换交换，分别相互处理，并在单独的线程中处理。实际上，您可以认为前面的路由等同于以下三个独立的路由：

from("URI1").to("DestinationUri");
from("URI2").to("DestinationUri");
from("URI3").to("DestinationUri");

例如，您可能希望合并来自两个不同的消息传递系统的传入信息，并使用同一路由处理它们。在大多数情况下，您可以通过将路由分成片段来处理多个输入，如 图 2.5 “使用分段路由处理多个输入” 所示。

图 2.5. 使用分段路由处理多个输入

路由的初始片段从某些外部队列 3.10.0--XDP 中获取其输入，例如 activemq:Nyse 和 activemq:Nasdaq WWPN，并将传入的交换发送到内部端点 InternalUrl。第二个路由片段合并传入的交换，从内部端点中提取，并将它们发送到目标队列 activemq:USTxn。InternalUrl 是端点的 URL，仅用于在路由器应用程序中使用。以下类型的端点适合内部使用：

这些端点的主要目的是您可以将路由的不同片段粘滞在一起。它们都提供了将多个输入合并到一个路由的有效方法。

直接组件提供了将路由链接最简单的机制。直接组件的事件模型是 同步的，因此后续的路由片段在与第一网段相同的线程中运行。直接 URL 的一般格式是 direct:EndpointID，其中端点 ID 为 EndpointID，它只是标识端点实例的唯一字母数字字符串。

例如，如果要从两个消息队列中使用输入 located :Nyse 和 activemq:Nasdaq，并将它们合并到一个消息队列中 Foo:USTxn，您可以通过定义以下组路由来执行此操作：

from("activemq:Nyse").to("direct:mergeTxns");
from("activemq:Nasdaq").to("direct:mergeTxns");

from("direct:mergeTxns").to("activemq:USTxn");

其中前两个路由使用来自消息队列（ Nyse 和 Nasdaq ）的输入，并将它们发送到端点，direct:mergeTxns。最后一个队列合并了前两个队列中的输入，并将组合消息流发送到 activemq:USTxn 队列。

直连端点的实施方式如下：每当交换到达制作者端点（例如，("direct:mergeTxns")时，直接将交换传递到具有相同端点 ID 的所有用户端点（例如，从direct:mergeTxns"））。直接端点只能用于在同一 Java 虚拟机(JVM)实例中属于同一 CamelContext 的路由之间进行通信。

SEDA 组件提供了将路由连接在一起的替代机制。您可以以类似直接组件的方式使用它，但它有不同的底层事件和线程模型，如下所示：

使用 SEDA 端点的一个主要优点是路由可以更快地响应，导致内置消费者线程池。库存交易示例可以重新编写为使用 SEDA 端点而不是直接端点，如下所示：

from("activemq:Nyse").to("seda:mergeTxns");
from("activemq:Nasdaq").to("seda:mergeTxns");

from("seda:mergeTxns").to("activemq:USTxn");

此示例和直接示例之间的主要区别在于，使用 SEDA 时，第二个路由片段（从 seda:mergeTxns 到 activemq:USTxn）由五个线程池处理。

VM 组件与 SEDA 端点非常相似。唯一的不同之处在于，SEDA 组件只能将来自同一 CamelContext 中的路由片段链接在一起，VM 组件可让您将不同 Apache Camel 应用程序的路由链接在一起，只要它们在同一 Java 虚拟机中运行。

库存交易示例可以重新编写为使用 VM 端点而不是 SEDA 端点，如下所示：

from("activemq:Nyse").to("vm:mergeTxns");
from("activemq:Nasdaq").to("vm:mergeTxns");

在单独的路由器应用程序（在同一 Java 虚拟机中运行），您可以定义路由的第二个片段，如下所示：

from("vm:mergeTxns").to("activemq:USTxn");

内容增强器模式定义了处理对路由的多个输入的根本不同方式。当交换进入增强器处理器时，增强器联系一个外部资源以检索信息，然后添加到原始消息中。在此模式中，外部资源有效表示消息的第二个输入。

例如，假设您正在编写处理贡献请求的应用程序。在处理信贷请求之前，您需要用数据进行添加，从而向客户分配贡献度等级到客户，其中评分数据存储在 目录中的一个文件中，src/data/ratings。您可以使用 pollEnrich（） 模式和 GroupedExchangeAggregationStrategy 聚合策略将传入的信请求与 ratings 文件中的数据合并，如下所示：

from("jms:queue:creditRequests")
    .pollEnrich("file:src/data/ratings?noop=true", new GroupedExchangeAggregationStrategy())
    .bean(new MergeCreditRequestAndRatings(), "merge")
    .to("jms:queue:reformattedRequests");

其中 GroupedExchangeAggregationStrategy 类是一个标准的聚合策略，来自 org.apache.camel.processor.aggregate 软件包，将每个新交换添加到 java.util.List 实例，并将结果列表存储在 Exchange.GROUPED_EXCHANGE 交换属性中。在本例中，列表中包含两个元素：原始交换（来自 creditRequests JMS 队列）；以及增强器交换（来自文件端点）。

要访问分组的交换，您可以使用类似如下的代码：

public class MergeCreditRequestAndRatings {
    public void merge(Exchange ex) {
        // Obtain the grouped exchange
        List<Exchange> list = ex.getProperty(Exchange.GROUPED_EXCHANGE, List.class);

        // Get the exchanges from the grouped exchange
        Exchange originalEx = list.get(0);
        Exchange ratingsEx  = list.get(1);

        // Merge the exchanges
        ...
    }
}

此应用的另一种方法是将合并代码直接放入自定义聚合策略类的实施中。

有关内容丰富的模式的详情，请参考 第 10.1 节 “内容增强器”。

Bean 集成提供了一种通用机制，用于使用任意 Java 对象处理消息。通过将 bean 引用插入到路由中，您可以在 Java 对象上调用任意方法，然后访问和修改传入的交换。将交换内容映射到参数并返回 bean 方法值的机制称为 参数绑定。参数绑定可以使用以下任一方法组合来初始化方法的参数：

Bean 是通过 bean registry 进行访问的，该服务可让您将类名称或 bean ID 用作密钥来查找 Bean。您在 bean registry 中创建条目的方式取决于底层的 framework>_<-abrt，如纯 Java、Spring、Spring、Gusice 或 Blueprint。registry 条目通常隐式创建（例如，当您在 Spring XML 文件中实例化 Spring bean 时）。

Apache Camel 为 bean 注册表实施插件策略，定义用于访问 Bean 的集成层，从而使底层 registry 的实施透明。因此，可以将 Apache Camel 应用程序与各种不同 Bean registry 集成，如 表 2.2 “registry 插件” 所示。

通常，您不必担心配置 bean registry，因为会自动为您安装相关的 bean registry。例如，如果您使用 Spring 框架定义路由，则 Spring ApplicationContextRegistry 插件会在当前的 CamelContext 实例中自动安装。

在 OSGi 容器中部署是一个特殊情况。当将 Apache Camel 路由部署到 OSGi 容器时，CamelContext 会自动设置 registry 链以解析 Bean 实例：registry 链包括 OSGi 注册表，后面是 Blueprint（或 Spring） registry。

要使用 Java bean（一个普通旧的 Java 对象或 OVA）进程交换对象，请使用 bean（） 处理器，将入站交换绑定到 Java 对象上的方法。例如，若要使用类 MyBeanProcessor 处理入站交换，请定义如下路由：

from("file:data/inbound")
    .bean(MyBeanProcessor.class, "processBody")
    .to("file:data/outbound");

其中 bean（） 处理器创建 MyBeanProcessor 类型的实例，并调用 processBody（） 方法来处理入站交换。如果您只想从一个路由访问 MyBeanProcessor 实例，则此方法就足够了。但是，如果您要从多个路由访问相同的 MyBeanProcessor 实例，请使用将对象类型用作其第一个参数的 bean（） 变体。例如：

MyBeanProcessor myBean = new MyBeanProcessor();

from("file:data/inbound")
    .bean(myBean, "processBody")
    .to("file:data/outbound");
from("activemq:inboundData")
    .bean(myBean, "processBody")
    .to("activemq:outboundData");

如果 bean 定义了过载方法，您可以通过指定方法名称及其参数类型来选择调用的超载方法。例如，如果 MyBeanBrocessor 类有两个超载方法： processBody(String) 和 processBody(String,String)，您可以按照如下所示调用后面的超载方法：

from("file:data/inbound")
  .bean(MyBeanProcessor.class, "processBody(String,String)")
  .to("file:data/outbound");

或者，如果您想要使用的参数数量来识别方法，而不是明确指定每个参数的类型，您可以使用通配符字符 *。例如，要调用名为 processBody 的方法，它采用两个参数(irrespective of)参数，调用 bean（） 处理器，如下所示：

from("file:data/inbound")
.bean(MyBeanProcessor.class, "processBody(*,*)")
.to("file:data/outbound");

在指定方法时，您可以使用简单的非限定类型 name- 例如，processBody(Exchange)- 或完全限定域名（如 processBody(org.apache.camel.Exchange)。

当调用 bean 方法时，可以明确指定参数值。可以传递以下简单类型值：

以下示例演示了如何将显式参数值与同一方法调用的类型组合：

from("file:data/inbound")
  .bean(MyBeanProcessor.class, "processBody(String, 'Sample string value', true, 7)")
  .to("file:data/outbound");

在前面的示例中，第一个参数的值可能会假定由参数绑定注解决定（请参阅 “基本注解”一节）。

除了简单类型值外，您还可以使用 Simple 语言(第 30 章 简单语言)指定参数值。这意味着在指定 参数值时提供了 Simple 语言的完整功能。例如，将邮件正文和标题 标题 的值传递给 bean 方法：

from("file:data/inbound")
  .bean(MyBeanProcessor.class, "processBodyAndHeader(${body},${header.title})")
  .to("file:data/outbound");

您还可以将整个标头散列映射作为参数传递。例如，以下示例中必须声明第二个方法参数，才能作为 java.util.Map 类型：

from("file:data/inbound")
  .bean(MyBeanProcessor.class, "processBodyAndAllHeaders(${body},${header})")
  .to("file:data/outbound");

要将交换绑定到 bean 方法，您可以定义符合特定约定的方法签名。特别是，方法签名有两个基本惯例：

如果要实施访问或修改传入的消息正文的方法，您必须定义一个使用单个 字符串 参数的方法签名，并返回 String 值。例如：

// Java
package com.acme;

public class MyBeanProcessor {
    public String processBody(String body) {
        // Do whatever you like to 'body'...
        return newBody;
    }
}

为获得更大的灵活性，您可以实施访问传入交换的 bean 方法。这可让您访问或修改所有标头、正文和交换属性。对于处理交换，方法签名使用一个 org.apache.camel.Exchange 参数，并返回 void。例如：

// Java
package com.acme;

public class MyBeanProcessor {
    public void processExchange(Exchange exchange) {
        // Do whatever you like to 'exchange'...
        exchange.getIn().setBody("Here is a new message body!");
    }
}

您可以使用 Spring XML 创建实例，而不必在 Java 中创建 bean 实例。实际上，如果您在 XML 中定义路由，这是唯一可行的方法。要在 XML 中定义 Bean，请使用标准的 Spring Bean 元素。以下示例演示了如何创建 MyBeanProcessor 的实例：

<beans ...>
    ...
    <bean id="myBeanId" class="com.acme.MyBeanProcessor"/>
</beans>

也可以使用 Spring 语法将数据传递到 bean 的构造器参数。有关如何使用 Spring bean 元素的完整详情，请参阅 Spring 参考指南 中的 IoC 容器。

使用 bean 元素创建对象实例时，您可以使用 bean 的 ID（an 元素的 id 属性的值）来引用它。例如，如果将 ID 为等于 myBeanId 的 bean 元素，您可以使用 beanRef（） 处理器来引用 Java DSL 路由中的an，如下所示：

from("file:data/inbound").beanRef("myBeanId", "processBody").to("file:data/outbound");

其中 beanRef（） 处理器在指定的 bean 实例上调用 MyBeanProcessor.processBody（） 方法。

您还可以使用 Camel 架构的 bean 元素从 Spring XML 路由内调用 bean。例如：

<camelContext id="CamelContextID" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="file:data/inbound"/>
    <bean ref="myBeanId" method="processBody"/>
    <to uri="file:data/outbound"/>
  </route>
</camelContext>

为了获得有效效率，您可以将 缓存 选项设置为 true，这样可避免在每次使用 bean 时查找 registry。例如，要启用缓存，您可以在 bean 元素上设置 cache 属性，如下所示：

<bean ref="myBeanId" method="processBody" cache="true"/>

使用 Spring bean 元素创建对象实例时，您可以使用 bean 的 ID（ bean 元素的 id 属性的值）从 Java 引用它。例如，如果将 ID 为等于 myBeanId 的 bean 元素，您可以使用 beanRef（） 处理器来引用 Java DSL 路由中的an，如下所示：

from("file:data/inbound").beanRef("myBeanId", "processBody").to("file:data/outbound");

另外，您可以使用 @BeanInject 注释（如下所示）来引用 Spring bean。

// Java
import org.apache.camel.@BeanInject;
...
public class MyRouteBuilder extends RouteBuilder {

   @BeanInject("myBeanId")
   com.acme.MyBeanProcessor bean;

   public void configure() throws Exception {
     ..
   }
}

如果省略 @BeanInject 注释中的 bean ID，Camel 会按照类型查找 registry，但只有在给定类型只有一个 bean 时才能发挥作用。例如，查找并注入 com.acme.MyBeanProcessor 类型的 Bean：

@BeanInject
com.acme.MyBeanProcessor bean;

对于 Camel 上下文使用的 Bean，正确的关闭顺序通常是：

如果此关闭顺序被反向，那么 Camel 上下文会尝试访问已经被破坏的 Bean（导致直接出错）；或者 Camel 上下文尝试在销毁时创建缺失的 bean，这也会导致错误。Spring XML 中的默认关闭顺序取决于 Bean 和 camelContext 中的顺序出现在 Spring XML 文件中。为了避免因为不正确的关闭顺序导致随机错误，因此 camelContext 配置为在 Spring XML 文件中的任何其他 Bean 之前 关闭。从 Apache Camel 2.13.0 开始，这是默认的行为。

如果您需要更改此行为（因此 Camel 上下文 不会在 其他 Bean 之前关闭），您可以将 camelContext 元素上的 shutdownEager 属性设为 false。在这种情况下，您可以使用 Spring dependent-on 属性对关机顺序进行更精细的控制。

“基本方法签名”一节 中描述的基本参数绑定可能并不总是方便使用。例如，如果您有一个执行一些数据操作的旧版 Java 类，您可能希望从入站交换中提取数据并将其映射到现有方法签名的参数。对于这种类型的参数绑定，Apache Camel 提供以下 Java 注解类型：

表 2.3 “基本 Bean 标注” 显示 org.apache.camel Java 软件包中的注释，您可以使用它来将消息数据注入到 bean 方法的参数中。

例如，以下类显示如何使用基本注解将消息数据注入 processExchange（） 方法参数。

// Java
import org.apache.camel.*;

public class MyBeanProcessor {
    public void processExchange(
        @Header(name="user") String user,
        @Body String body,
        Exchange exchange
    ) {
        // Do whatever you like to 'exchange'...
        exchange.getIn().setBody(body + "UserName = " + user);
    }
}

请注意，如何将注解与默认规则混合使用。除了注入注解的参数外，参数绑定也会自动将 exchange 对象注入到 org.apache.camel.Exchange 参数。

表达式语言注释提供了一种强大的机制，用于将消息数据注入 bean 方法的参数。通过使用这些注解，您可以调用任意脚本（使用您选择的脚本语言编写）从入站交换中提取数据，并将数据注入方法参数。表 2.4 “表达式语言注释” 显示 org.apache.camel.language 软件包（和子软件包）中的注释，供您用来将消息数据注入 bean 方法的参数中。

例如，以下类显示如何使用 @XPath 注释从 XML 格式的传入消息正文中提取用户名和密码：

// Java
import org.apache.camel.language.*;

public class MyBeanProcessor {
    public void checkCredentials(
        @XPath("/credentials/username/text()") String user,
        @XPath("/credentials/password/text()") String pass
    ) {
        // Check the user/pass credentials...
        ...
    }
}

@Bean 注释是一个特殊情形，因为它可让您注入调用已注册 Bean 的结果。例如，要将关联 ID 注入方法参数，您可以使用 @Bean 注释来调用 ID 生成器类，如下所示：

// Java
import org.apache.camel.language.*;

public class MyBeanProcessor {
    public void processCorrelatedMsg(
        @Bean("myCorrIdGenerator") String corrId,
        @Body String body
    ) {
        // Check the user/pass credentials...
        ...
    }
}

其中字符串 myCorrIdGenerator 是 ID 生成器实例的 bean ID。ID 生成器类可以使用 spring bean 元素实例化，如下所示：

<beans ...>
    ...
    <bean id="myCorrIdGenerator" class="com.acme.MyIdGenerator"/>
</beans>

其中 MyIdGenerator 类可以定义如下：

// Java
package com.acme;

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;
   }
}

请注意，您也可以在 bean 类中使用注解 MyIdGenerator。generate（） 方法签名的唯一限制是，它必须返回正确的类型来注入 @Bean 注释的参数。由于 @Bean 注释不要求您指定方法名称，因此注入机制只需在引用的 bean 中调用具有匹配返回类型的方法。

参数绑定注解可以从接口或从超级类继承。例如，如果您使用 标头 注释和 Body 注解定义 Java 接口，如下所示：

// Java
import org.apache.camel.*;

public interface MyBeanProcessorIntf {
    void processExchange(
        @Header(name="user") String user,
        @Body String body,
        Exchange exchange
    );
}

实现类 MyBeanProcessor 中定义的超载方法现在继承基础接口中定义的注解，如下所示：

// Java
import org.apache.camel.*;

public class MyBeanProcessor implements MyBeanProcessorIntf {
    public void processExchange(
        String user,  // Inherits Header annotation
        String body,  // Inherits Body annotation
        Exchange exchange
    ) {
        ...
    }
}

实现 Java 接口的类通常 受保护的、private 或在 仅软件包 范围内。如果您在以这种方式限制的实施类上调用方法，则 bean 绑定将返回到调用对应的接口方法，该方法可以公开访问。

例如，请考虑以下公共 BeanIntf 接口：

// Java
public interface BeanIntf {
    void processBodyAndHeader(String body, String title);
}

如果 BeanIntf 接口由以下受保护的 BeanIntfImpl 类实施：

// Java
protected class BeanIntfImpl implements BeanIntf {
    void processBodyAndHeader(String body, String title) {
        ...
    }
}

以下 bean 调用将回退到调用公共 BeanIntf.processBodyAndHeader 方法：

from("file:data/inbound")
  .bean(BeanIntfImpl.class, "processBodyAndHeader(${body}, ${header.title})")
  .to("file:data/outbound");

Bean 集成具有调用静态方法的能力，无需创建关联类的实例。例如，请考虑以下用于定义静态方法的 Java 类，请更改Something（） ：

// Java
...
public final class MyStaticClass {
    private MyStaticClass() {
    }

    public static String changeSomething(String s) {
        if ("Hello World".equals(s)) {
            return "Bye World";
        }
        return null;
    }

    public void doSomething() {
        // noop
    }
}

您可以使用 bean 集成来调用静态的 changeSomething 方法，如下所示：

from("direct:a")
  *.bean(MyStaticClass.class, "changeSomething")*
  .to("mock:a");

请注意，虽然这种语法与普通功能的调用相同，但同时也是集成漏洞的 Java 反映出方法，以识别静态方法并继续调用方法，而无需 实例化 MyStaticClass。

在特殊情况下，路由部署到红帽 Fuse 容器中，可以使用 bean 集成直接调用 OSGi 服务。例如，假设 OSGi 容器中的捆绑包已导出该服务，即 org.fusesource.example.HelloWorldOsgiService，您可以使用以下 bean 集成代码调用 sayHello 方法：

from("file:data/inbound")
  .bean(org.fusesource.example.HelloWorldOsgiService.class, "sayHello")
  .to("file:data/outbound");

您还可以使用 bean 组件从 Spring 或蓝图 XML 文件中调用 OSGi 服务，如下所示：

<to uri="bean:org.fusesource.example.HelloWorldOsgiService?method=sayHello"/>

这种方法的工作方式是，当 Apache Camel 在 OSGi 容器中部署时，会设置一个 registry 链。首先，它会在 OSGi 服务 registry 中查找指定的类名称 ; 如果这个查找失败，它将回退到本地 Spring DM 或蓝图 registry。

使用 Java 代码处理消息时（例如，在 bean 类或在处理器类中），通常会需要创建新的交换实例。如果您需要创建 Exchange 对象，最简单的方法是调用 ExchangeBuilder 类的方法，如下所述。

ExchangeBuilder 类的完全限定名称如下：

org.apache.camel.builder.ExchangeBuilder

ExchangeBuilder 公开静态方法 aExchange，可用于开始构建交换对象。

例如，以下代码会创建一个新的交换对象，其中包含消息正文字符串 Hello World!，以及包含用户名和密码凭证的标头：

// Java
import org.apache.camel.Exchange;
import org.apache.camel.builder.ExchangeBuilder;
...
Exchange exch = ExchangeBuilder.anExchange(camelCtx)
                    .withBody("Hello World!")
                    .withHeader("username", "jdoe")
                    .withHeader("password", "pass")
                    .build();

ExchangeBuilder 类支持以下方法：

属性占位符功能可用于将字符串替换为不同的上下文（如 XML DSL 元素中的端点 URI 和属性），其中占位符设置存储在 Java 属性文件中。如果您要在不同 Apache Camel 应用程序间共享设置，或者您想要集中特定的配置设置，则这个功能很有用。

例如，以下路由将请求发送到 Web 服务器（其主机和端口由占位符替换）、{{remote.host}} 和 {{remote.port}} ：

from("direct:start").to("http://{{remote.host}}:{{remote.port}}");

占位符值在 Java 属性文件中定义，如下所示：

# Java properties file
remote.host=myserver.com
remote.port=8080

使用 PropertyPlaceholders 的 Apache Camel 支持以下内容：

属性设置存储在一个或多个 Java 属性文件中，且必须符合标准的 Java 属性文件格式。每个属性设置出现在其自己的行中，格式为 Key=Value。带有 # 或 ! 作为第一个非空字符的行被视为注释。

例如，属性文件可能含有内容，如 例 2.4 “Property 文件示例” 所示。

# Property placeholder settings
# (in Java properties file format)
cool.end=mock:result
cool.result=result
cool.concat=mock:{{cool.result}}
cool.start=direct:cool
cool.showid=true

cheese.end=mock:cheese
cheese.quote=Camel rocks
cheese.type=Gouda

bean.foo=foo
bean.bar=bar

属性组件必须配置有一个或多个属性文件的位置，然后才能在路由定义中使用它。您必须使用以下解析器之一提供属性值：

例如，要指定 com/fusesource/cheese.properties 属性文件和 com/fusesource/bar.properties 属性文件，两者均位于 classpath 上，您需要使用以下位置字符串：

com/fusesource/cheese.properties,com/fusesource/bar.properties

您可以在位置 PathName 中嵌入 Java 系统属性和 O/S 环境变量。

Java 系统属性可以使用语法 ${PropertyName} 嵌入在位置解析器中。例如，如果 Red Hat Fuse 的根目录存储在 Java 系统属性 karaf.home 中，您可以把该目录值嵌入到文件位置中，如下所示：

file:${karaf.home}/etc/foo.properties

O/S 环境变量可以使用语法( ${env:VarName} )嵌入到位置解析器中。例如，如果 JBoss Fuse 的根目录存储在环境变量 SMX_HOME 中，您可以将该目录的内容嵌入到文件位置，如下所示：

file:${env:SMX_HOME}/etc/foo.properties

在开始使用属性占位符前，您必须配置属性组件，指定一个或多个属性文件的位置。

在 Java DSL 中，您可以使用属性文件位置配置属性组件，如下所示：

// Java
import org.apache.camel.component.properties.PropertiesComponent;
...
PropertiesComponent pc = new PropertiesComponent();
pc.setLocation("com/fusesource/cheese.properties,com/fusesource/bar.properties");
context.addComponent("properties", pc);

如 addComponent（） 调用所示，属性组件的名称 必须设置为 属性。

在 XML DSL 中，您可以使用专用 propertyPlacholder 元素配置属性组件，如下所示：

<camelContext ...>
   <propertyPlaceholder
      id="properties"
      location="com/fusesource/cheese.properties,com/fusesource/bar.properties"
   />
</camelContext>

如果您希望属性组件在初始化时忽略任何缺少的 .properties 文件，您可以将 ignoreMissingLocation 选项设置为 true （通常情况下，缺少 .properties 文件会导致错误引发）。

另外，如果您希望属性组件忽略使用 Java 系统属性或 O/S 环境变量指定的任何缺少的位置，您可以将 ignoreMissingLocation 选项设置为 true。

配置后，属性组件会自动替换占位符（在适当的上下文中）。占位符语法取决于上下文，如下所示：

只要端点 URI 字符串出现在路由中，解析端点 URI 的第一步是应用属性占位符解析器。占位符解析器自动替换双花括号之间出现的任何属性名称 {{ Key}}。例如，如果 例 2.4 “Property 文件示例” 中显示的属性设置，您可以定义路由，如下所示：

from("{{cool.start}}")
    .to("log:{{cool.start}}?showBodyType=false&showExchangeId={{cool.showid}}")
    .to("mock:{{cool.result}}");

默认情况下，占位符解析器查找 registry 中的 属性 bean ID 来查找属性组件。如果愿意，您可以在端点 URI 中明确指定方案。例如，通过为每个端点 URI 加上前缀 属性： 到每个端点 URI，您可以定义以下等同的路由：

from("properties:{{cool.start}}")
    .to("properties:log:{{cool.start}}?showBodyType=false&showExchangeId={{cool.showid}}")
    .to("properties:mock:{{cool.result}}");

在明确指定方案时，您还可以选择指定属性组件的选项。例如，要覆盖属性文件位置，您可以按照如下所示设置 location 选项：

from("direct:start").to("properties:{{bar.end}}?location=com/mycompany/bar.properties");

您还可以使用 XML DSL 中的属性占位符，设置 DSL 元素的各种属性。在此上下文中，拥有者语法也使用双花括号 {{ Key}}。例如，您可以使用属性占位符定义 jmxAgent 元素，如下所示：

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <propertyPlaceholder id="properties" location="org/apache/camel/spring/jmx.properties"/>

    <!-- we can use property placeholders when we define the JMX agent -->
    <jmxAgent id="agent" registryPort="{{myjmx.port}}"
              usePlatformMBeanServer="{{myjmx.usePlatform}}"
              createConnector="true"
              statisticsLevel="RoutesOnly"
            />

    <route>
        <from uri="seda:start"/>
        <to uri="mock:result"/>
    </route>
</camelContext>

您可以使用常规占位符语法来指定 xs:string typegradle-sHistoryLimitfor example, < jmxAgent registryPort="{{myjmx.port}}" …​ >。但是，对于任何其他类型的属性（例如，xs:int 或 xs:boolean），您必须使用特殊语法 prop:AttributeName="Key"。

例如，如果某个属性文件定义了 stop.flag 属性的值为 true，您可以使用此属性来设置 stopOnException 布尔值属性，如下所示：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:prop="http://camel.apache.org/schema/placeholder"
       ... >

    <bean id="illegal" class="java.lang.IllegalArgumentException">
        <constructor-arg index="0" value="Good grief!"/>
    </bean>

    <camelContext xmlns="http://camel.apache.org/schema/spring">

        <propertyPlaceholder id="properties"
                             location="classpath:org/apache/camel/component/properties/myprop.properties"
                             xmlns="http://camel.apache.org/schema/spring"/>

        <route>
            <from uri="direct:start"/>
            <multicast prop:stopOnException="stop.flag">
                <to uri="mock:a"/>
                <throwException ref="damn"/>
                <to uri="mock:b"/>
            </multicast>
        </route>

    </camelContext>

</beans>

在 Java DSL 中调用 EIP 命令时，您可以通过添加表单、占位符(" options Name", "Key") 值，使用属性值来设置任何 EIP 选项。

例如，如果某个属性文件定义了 stop.flag 属性的值为 true，您可以使用此属性设置多播 EIP 的 stopOnException 选项，如下所示：

from("direct:start")
    .multicast().placeholder("stopOnException", "stop.flag")
        .to("mock:a").throwException(new IllegalAccessException("Damn")).to("mock:b");

您还可以使用简单语言表达式替换属性占位符，但在本例中，占位符语法为 ${properties:Key}。例如，您可以替换简单表达式内的 cheese.quote 占位符，如下所示：

from("direct:start")
    .transform().simple("Hi ${body} do you think ${properties:cheese.quote}?");

您可以使用语法 ${properties:Key:DefaultVal} 来指定属性的默认值。例如：

from("direct:start")
    .transform().simple("Hi ${body} do you think ${properties:cheese.quote:cheese is good}?");

也可以使用语法( ${properties-location:Location:Key} )覆盖属性文件的位置。例如，要使用 com/mycompany/bar.properties 属性中的设置替换 bar.quote 占位符，您可以按照如下所示定义简单表达式：

from("direct:start")
    .transform().simple("Hi ${body}. ${properties-location:com/mycompany/bar.properties:bar.quote}.");

在旧版中，xs:string 类型属性用于支持 XML DSL 中的占位符。例如，timeout 属性是一个 xs:int 类型。因此，您无法将字符串值设置为占位符键。

从 Apache Camel 2.7 开始，现在可以使用特殊的占位符命名空间来实现。以下示例演示了命名空间的 prop 前缀。它允许您使用 XML DSL 中属性中的 prop 前缀。

stop=true

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:prop="http://camel.apache.org/schema/placeholder"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
    ">

    <!-- Notice in the declaration above, we have defined the prop prefix as the Camel placeholder namespace -->

    <bean id="damn" class="java.lang.IllegalArgumentException">
        <constructor-arg index="0" value="Damn"/>
    </bean>

    <camelContext xmlns="http://camel.apache.org/schema/spring">

        <propertyPlaceholder id="properties"
                             location="classpath:org/apache/camel/component/properties/myprop.properties"
                             xmlns="http://camel.apache.org/schema/spring"/>

        <route>
            <from uri="direct:start"/>
            <!-- use prop namespace, to define a property placeholder, which maps to
                 option stopOnException={{stop}} -->
            <multicast prop:stopOnException="stop">
                <to uri="mock:a"/>
                <throwException ref="damn"/>
                <to uri="mock:b"/>
            </multicast>
        </route>

    </camelContext>

</beans>

如果您将路由部署到红帽 Fuse OSGi 容器中，您可以将 Apache Camel 属性占位符机制与 JBoss Fuse 的蓝图属性占位符机制（事实上是启用集成）。设置集成的基本方法有两种，如下所示：

如果您在 OSGi 蓝图文件中定义了 camelContext 元素，Apache Camel 属性占位符机制会自动与蓝图属性占位符机制集成。也就是说，在 camelContext 范围内出现的占位符遵循 Apache Camel 语法（如 {{cool.end}}）通过查找 蓝图属性占位符 机制来隐式解析。

例如，考虑在 OSGi 蓝图文件中定义以下路由，路由中最后一个端点由属性占位符定义，{{result}} ：

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0"
           xsi:schemaLocation="
           http://www.osgi.org/xmlns/blueprint/v1.0.0 https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd">

    <!-- OSGI blueprint property placeholder -->
    <cm:property-placeholder id="myblueprint.placeholder" persistent-id="camel.blueprint">
        <!-- list some properties for this test -->
        <cm:default-properties>
            <cm:property name="result" value="mock:result"/>
        </cm:default-properties>
    </cm:property-placeholder>

    <camelContext xmlns="http://camel.apache.org/schema/blueprint">
        <!-- in the route we can use {{ }} placeholders which will look up in blueprint,
             as Camel will auto detect the OSGi blueprint property placeholder and use it -->
        <route>
            <from uri="direct:start"/>
            <to uri="mock:foo"/>
            <to uri="{{result}}"/>
        </route>
    </camelContext>

</blueprint>

蓝图属性占位符机制通过创建一个 cm:property-placeholder an 初始化。在前面的示例中，cm:property-placeholder bean 与 camel.blueprint 持久 ID 关联，持久 ID 是引用 OSGi 配置管理 服务中一组相关属性的标准方式。换句话说，cm:property-placeholder an 提供了对 camel.blueprint 持久 ID 中定义的所有属性的访问权限。也可以为某些属性指定默认值（使用嵌套的 cm:property 元素）。

在蓝图上下文中，Apache Camel 占位符机制搜索 bean registry 中的 cm:property-placeholder 实例。如果找到这样的实例，它会自动集成 Apache Camel 占位符机制，以便等占位符 {{result}} 可以通过在蓝图属性占位符机制中查找密钥（在这个示例中，通过 myblueprint.placeholder bean）来解决。

如果您想要更多控制 Apache Camel 属性占位符机制在什么位置找到其属性，您可以定义一个 propertyPlaceholder 元素并明确指定解析器位置。

例如，请考虑以下与前面示例不同的蓝图配置，它会创建一个显式 propertyPlaceholder 实例：

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0"
           xsi:schemaLocation="
           http://www.osgi.org/xmlns/blueprint/v1.0.0 ">https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd">

    <!-- OSGI blueprint property placeholder -->
    <cm:property-placeholder id="myblueprint.placeholder" persistent-id="camel.blueprint">
        <!-- list some properties for this test -->
        <cm:default-properties>
            <cm:property name="result" value="mock:result"/>
        </cm:default-properties>
    </cm:property-placeholder>

    <camelContext xmlns="http://camel.apache.org/schema/blueprint">

        <!-- using Camel properties component and refer to the blueprint property placeholder by its id -->
        <propertyPlaceholder id="properties" location="blueprint:myblueprint.placeholder"/>

        <!-- in the route we can use {{ }} placeholders which will lookup in blueprint -->
        <route>
            <from uri="direct:start"/>
            <to uri="mock:foo"/>
            <to uri="{{result}}"/>
        </route>

    </camelContext>

</blueprint>

在前面的示例中，propertyPlaceholder 元素指定通过将位置设置为 blueprint:myblueprint.placeholder 来指定使用哪个 cm:property-placeholder。该 蓝图： 解析器明确引用 cm:property-placeholder 的 ID、myblueprint.placeholder。

这种配置方式很有用，如果蓝图文件中定义了多个 cm:property-placeholder an，并且您需要指定要使用的选项。它还可通过指定以逗号分隔的位置列表，从多个位置的源属性。例如，如果要从 cm:property-placeholder bean 和 properties 文件( myproperties.properties )在 classpath 上查找属性，您可以按照如下所示定义 propertyPlaceholder 元素：

<propertyPlaceholder id="properties"
  location="blueprint:myblueprint.placeholder,classpath:myproperties.properties"/>

如果您在 Spring XML 文件中使用 XML DSL 定义 Apache Camel 应用程序，您可以通过声明类型为 Spring 片段机制来将 Apache Camel 属性占位符机制集成，org.apache.camel.spring.spi.BridgePropertyPlaceholderConfigurer。

定义 BridgePropertyPlaceholderConfigurer，它替代了 Spring XML 文件中 Apache Camel 的 propertyPlaceholder 元素和 Spring 的 ctx:property-placeholder 元素。然后，您可以使用 Spring ${PropName} 语法或 Apache Camel {{ PropName}} 语法来引用配置的属性。

例如，定义从 cheese.properties 文件中读取其属性设置的桥接属性占位符：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:ctx="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

  <!-- Bridge Spring property placeholder with Camel -->
  <!-- Do not use <ctx:property-placeholder ... > at the same time -->
  <bean id="bridgePropertyPlaceholder"
        class="org.apache.camel.spring.spi.BridgePropertyPlaceholderConfigurer">
    <property name="location"
              value="classpath:org/apache/camel/component/properties/cheese.properties"/>
  </bean>

  <!-- A bean that uses Spring property placeholder -->
  <!-- The ${hi} is a spring property placeholder -->
  <bean id="hello" class="org.apache.camel.component.properties.HelloBean">
    <property name="greeting" value="${hi}"/>
  </bean>

  <camelContext xmlns="http://camel.apache.org/schema/spring">
    <!-- Use Camel's property placeholder {{ }} style -->
    <route>
      <from uri="direct:{{cool.bar}}"/>
      <bean ref="hello"/>
      <to uri="{{cool.end}}"/>
    </route>
  </camelContext>

</beans>

Apache Camel 线程模型基于强大的 Java 并发 API Package java.util.concurrent，最初在 Sun 的 JDK 1.5 中提供。此 API 中的关键接口是 ExecutorService 接口，它代表线程池。使用并发 API，您可以创建许多不同的线程池，涵盖了广泛的场景。

Apache Camel 线程池 API 将基于 Java 并发 API 构建，为 Apache Camel 应用程序中的所有线程池提供中心工厂（ org.apache.camel.spi.ExecutorServiceManager 类型）。以这种方式进行线程池的创建提供了几个优点，包括：

一些 Apache Camel 组件为 SEDA、JMS 和 Jettytty- inherent inherent多线程。这些组件已使用 Apache Camel 线程模型和线程池 API 实施。

如果您计划实施自己的 Apache Camel 组件，建议您将线程代码与 Apache Camel 线程模型集成。例如，如果您的组件需要线程池，建议您使用 CamelContext 的 ExecutorServiceManager 对象创建它。

Apache Camel 中的一些标准处理器默认创建自己的线程池。这些线程感知型处理器也与 Apache Camel 线程模型集成，它们提供各种选项，供您自定义它们使用的线程池。

表 2.8 “处理器线程选项” 显示了在内置到 Apache Camel 的线程处理器上控制和设置线程池的各种选项。

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

executorService()
executorServiceRef()
poolSize()
maxPoolSize()
keepAliveTime()
timeUnit()
maxQueueSize()
rejectedPolicy()

@executorServiceRef
@poolSize
@maxPoolSize
@keepAliveTime
@timeUnit
@maxQueueSize
@rejectedPolicy

wireTap(String uri, ExecutorService executorService)
wireTap(String uri, String executorServiceRef)

@executorServiceRef

线程 处理器是一种通用的 DSL 命令，可用于将线程池引入到路由中。它支持以下选项自定义线程池：

要为一个线程感知处理器创建默认线程池，启用 parallelProcessing 选项，使用 parallelProcessing（） 子使用、Java DSL 或 parallelProcessing 属性（在 XML DSL 中）。

例如，在 Java DSL 中，您可以使用默认线程池（使用线程池同时处理多播目的地）调用多播处理器：

from("direct:start")
  .multicast().parallelProcessing()
    .to("mock:first")
    .to("mock:second")
    .to("mock:third");

您可以在 XML DSL 中定义与以下方式相同的路由

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:start"/>
        <multicast parallelProcessing="true">
            <to uri="mock:first"/>
            <to uri="mock:second"/>
            <to uri="mock:third"/>
        </multicast>
    </route>
</camelContext>

默认线程池由线程工厂自动创建，它从 默认的线程池配置集 获取其设置。默认线程池配置集在 表 2.9 “默认线程池配置集设置” 中显示的设置（假设这些设置还没有由应用程序代码修改）。

可以更改默认的线程池配置集设置，以便所有后续的默认线程池都使用自定义设置来创建。您可以在 Java 或 Spring XML 中更改配置集。

例如，在 Java DSL 中，您可以自定义 poolSize 选项和默认线程池配置集中的 maxQueueSize 选项，如下所示：

// Java
import org.apache.camel.spi.ExecutorServiceManager;
import org.apache.camel.spi.ThreadPoolProfile;
...
ExecutorServiceManager manager = context.getExecutorServiceManager();
ThreadPoolProfile defaultProfile = manager.getDefaultThreadPoolProfile();

// Now, customize the profile settings.
defaultProfile.setPoolSize(3);
defaultProfile.setMaxQueueSize(100);
...

在 XML DSL 中，您可以自定义默认的线程池配置集，如下所示：

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <threadPoolProfile
        id="changedProfile"
        defaultProfile="true"
        poolSize="3"
        maxQueueSize="100"/>
    ...
</camelContext>

请注意，在前面的 XML DSL 示例中将 defaultProfile 属性设置为 true 非常重要，否则线程池配置集将被视为自定义线程池配置集（请参阅 “创建自定义线程池配置集”一节），而不是替换默认的线程池配置集。

还可以使用 executorService 或 executorServiceRef 选项（其中使用这些选项而不是 parallelProcessing 选项）指定线程池。您可以使用两种方法来自定义处理器的线程池，如下所示：

当您将 bean ID 传递给 executorServiceRef 选项时，线程识别处理器首先会尝试查找带有该 ID 在 registry 中的 ID 的自定义线程池。如果没有使用该 ID 注册了线程池，则处理器会尝试在 registry 中查找自定义线程池配置集，并使用自定义线程池配置集来实例化自定义线程池。

自定义线程池可以是 java.util.concurrent.ExecutorService 类型的任何线程池。在 Apache Camel 中，建议使用以下创建线程池实例的方法：

最后，这两种方法之间没有区别，因为 ThreadPoolBuilder 实际使用 ExecutorServiceManager 实例定义。通常，最好使用 ThreadPoolBuilder，因为它提供了一个更简单的方法。但是，至少有一种线程( ScheduledExecutorService)只能通过直接访问 ExecutorServiceManager 实例来创建。

表 2.10 “线程池构建器选项” 显示 ThreadPoolBuilder 类支持的选项，您可以在定义新的自定义线程池时设置这些选项。

在 Java DSL 中，您可以使用 ThreadPoolBuilder 定义自定义线程池，如下所示：

// Java
import org.apache.camel.builder.ThreadPoolBuilder;
import java.util.concurrent.ExecutorService;
...
ThreadPoolBuilder poolBuilder = new ThreadPoolBuilder(context);
ExecutorService customPool = poolBuilder.poolSize(5).maxPoolSize(5).maxQueueSize(100).build("customPool");
...

from("direct:start")
  .multicast().executorService(customPool)
    .to("mock:first")
    .to("mock:second")
    .to("mock:third");

您可以通过将 bean ID 传递给 executorServiceRef（） 选项，而不必将对象引用 customPool 直接传递给 executorService（） 选项，如下所示：

// Java
from("direct:start")
  .multicast().executorServiceRef("customPool")
    .to("mock:first")
    .to("mock:second")
    .to("mock:third");

在 XML DSL 中，您可以使用 threadPool 元素访问 ThreadPoolBuilder。然后，您可以使用 executorServiceRef 属性来引用自定义线程池，以便在 Spring registry 中根据 ID 查找线程池，如下所示：

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <threadPool id="customPool"
                poolSize="5"
                maxPoolSize="5"
                maxQueueSize="100" />

    <route>
        <from uri="direct:start"/>
        <multicast executorServiceRef="customPool">
            <to uri="mock:first"/>
            <to uri="mock:second"/>
            <to uri="mock:third"/>
        </multicast>
    </route>
</camelContext>

如果您有多个要创建的自定义线程池实例，您可能会发现它更加方便地定义自定义线程池配置集，该配置集充当线程池的工厂。每当您引用线程感知处理器的线程池配置集时，处理器会自动使用配置集来创建新的线程池实例。您可以在 Java DSL 或 XML DSL 中定义自定义线程池配置集。

例如，在 Java DSL 中，您可以使用 bean ID customProfile 并从路由中引用它，如下所示：

// Java
import org.apache.camel.spi.ThreadPoolProfile;
import org.apache.camel.impl.ThreadPoolProfileSupport;
...
// Create the custom thread pool profile
ThreadPoolProfile customProfile = new ThreadPoolProfileSupport("customProfile");
customProfile.setPoolSize(5);
customProfile.setMaxPoolSize(5);
customProfile.setMaxQueueSize(100);
context.getExecutorServiceManager().registerThreadPoolProfile(customProfile);
...
// Reference the custom thread pool profile in a route
from("direct:start")
  .multicast().executorServiceRef("customProfile")
    .to("mock:first")
    .to("mock:second")
    .to("mock:third");

在 XML DSL 中，使用 threadPoolProfile 元素创建自定义池配置集（其中，默认Profile 选项默认为 false，因为这 不是默认 的线程池配置集）。您可以使用 bean ID customProfile 创建自定义线程池配置集，并从路由中引用它，如下所示：

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <threadPoolProfile
                id="customProfile"
                poolSize="5"
                maxPoolSize="5"
                maxQueueSize="100" />

    <route>
        <from uri="direct:start"/>
        <multicast executorServiceRef="customProfile">
            <to uri="mock:first"/>
            <to uri="mock:second"/>
            <to uri="mock:third"/>
        </multicast>
    </route>
</camelContext>

某些标准基于轮询的组件（如 File 和 FTP1028-jaxballow）要指定要使用的线程池。这使得不同组件可以共享同一线程池，从而减少了 JVM 中的总线程数量。

例如，Apache Camel 组件参考指南 中的 see File2 和 Apache Camel 组件参考指南 中的 Ftp2 均公开 scheduledExecutorService 属性，您可以使用它来指定组件的 ExecutorService 对象。

要使应用程序日志更易阅读，通常最好自定义线程名称（用于识别日志中的线程）。要自定义线程名称，您可以通过在 ExecutorServiceStrategy 类或 ExecutorServiceManager 类上调用 setThreadNamePattern 方法来配置线程名称 模式。另外，设置线程名称模式的更简单方法是在 CamelContext 对象中设置 threadNamePattern 属性。

以下占位符可以在线程名称模式中使用：

以下是线程名称模式的典型示例：

Camel (#camelId#) thread #counter# - #name#

以下示例演示了如何使用 XML DSL 在 Camel 上下文上设置 threadNamePattern 属性：

<camelContext xmlns="http://camel.apache.org/schema/spring"
              threadNamePattern="Riding the thread #counter#" >
  <route>
    <from uri="seda:start"/>
    <to uri="log:result"/>
    <to uri="mock:result"/>
  </route>
</camelContext>

默认情况下，当 Apache Camel 应用程序（由 CamelContext 实例表示）启动时自动启动路由，并在您的 Apache Camel 应用程序关闭时自动关闭路由。对于非关键部署，关闭序列的详情通常并不重要。但在生产环境中，现有任务在关闭期间应该运行非常关键，以避免数据丢失。您通常还希望控制路由关闭的顺序，这样依赖项就不会被违反（这样会导致现有任务无法运行完成）。

因此，Apache Camel 提供了一组功能来支持 安全关闭 应用程序。安全关闭可让您完全控制停止和启动路由，允许您控制路由的关闭顺序，并使当前任务能够运行完成。

最好为每个路由分配一个路由 ID。除了提高日志记录消息和管理功能外，使用路由 ID 可让您对停止和启动路由应用更多的控制。

例如，在 Java DSL 中，您可以通过调用 routeId（） 命令来将路由 ID myCustomerRouteId 分配到路由，如下所示：

from("SourceURI").routeId("myCustomRouteId").process(...).to(TargetURI);

在 XML DSL 中，设置 route 元素的 id 属性，如下所示：

<camelContext id="CamelContextID" xmlns="http://camel.apache.org/schema/spring">
  <route id="myCustomRouteId" >
    <from uri="SourceURI"/>
    <process ref="someProcessorId"/>
    <to uri="TargetURI"/>
  </route>
</camelContext>

默认情况下，CamelContext 知道在启动时的所有路由都将自动启动。如果您想手动控制特定路由的启动启动，您可能需要为该路由禁用自动启动。

要控制 Java DSL 路由是否自动启动，可调用 autoStartup 命令，使用 布尔值 参数（true 或 false）或 String 参数（true 或 false）。例如，您可以在 Java DSL 中禁用路由的自动启动，如下所示：

from("SourceURI")
  .routeId("nonAuto")
  .autoStartup(false)
  .to(TargetURI);

您可以通过在路由元素上将 autoStartup 属性设置为 false 来禁用在 XML DSL 中自动启动 路由的 自动启动，如下所示：

<camelContext id="CamelContextID" xmlns="http://camel.apache.org/schema/spring">
  <route id="nonAuto" autoStartup="false">
    <from uri="SourceURI"/>
    <to uri="TargetURI"/>
  </route>
</camelContext>

您可以通过调用 CamelContext 实例的 startRoute（） 和 stopRoute（） 方法，随时在 Java 中手动启动或停止路由。例如，要启动具有路由 ID nonAuto 的路由，在 CamelContext 实例（ 上下文 ）上调用 startRoute（） 方法，如下所示：

// Java
context.startRoute("nonAuto");

要停止具有路由 ID nonAuto 的路由，调用 CamelContext 实例上的 stopRoute（） 方法，上下文，如下所示：

// Java
context.stopRoute("nonAuto");

默认情况下，Apache Camel 以非确定的顺序启动路由。但是，在某些应用程序中，控制启动顺序非常重要。要在 Java DSL 中控制启动顺序，请使用 startupOrder（） 命令，该命令使用正整数值作为其参数。具有最低整数值的路由首先启动，后接具有后续启动顺序值的路由。

例如，以下示例中的前两个路由通过 seda:buffer 端点链接在一起。您可以通过分配启动顺序（2 和 1）来保证在第二个路由片段 后 启动第一个路由片段，如下所示：

from("jetty:http://fooserver:8080")
    .routeId("first")
    .startupOrder(2)
    .to("seda:buffer");

from("seda:buffer")
    .routeId("second")
    .startupOrder(1)
    .to("mock:result");

// This route's startup order is unspecified
from("jms:queue:foo").to("jms:queue:bar");

在 Spring XML 中，您可以通过设置 route 元素的 startupOrder 属性来实现相同的效果，如下所示：

<route id="first" startupOrder="2">
    <from uri="jetty:http://fooserver:8080"/>
    <to uri="seda:buffer"/>
</route>

<route id="second" startupOrder="1">
    <from uri="seda:buffer"/>
    <to uri="mock:result"/>
</route>

<!-- This route's startup order is unspecified -->
<route>
    <from uri="jms:queue:foo"/>
    <to uri="jms:queue:bar"/>
</route>

必须为每个路由 分配一个唯一的 启动顺序值。您可以选择小于 1000 的正整数值。为 Apache Camel 保留 1000 和 over 的值，这会自动将这些值分配给路由，而不显示显式启动值。例如，上例中最后一个路由会自动分配启动值 1000（因此在前两个路由后启动）。

当 CamelContext 实例时，Apache Camel 使用可插入关闭 策略控制关闭 序列。默认关闭策略实施以下关闭序列：

路由以相反的启动顺序关闭。也就是说，当使用 boot-rder （） 命令（在 Java DSL 中）或 startupOrder 属性（在 XML DSL 中）定义启动顺序时，第一个关闭路由是第一个关闭的路由，由启动顺序分配 最高 的整数值。最后一个要关闭的路由是按照启动顺序分配 的最低 整数值的路由。

例如，在 例 2.5 “Java DSL 中的启动顺序” 中，需要关闭的第一个路由段是 ID、第一个 的路由，而要关闭的第二个路由段则是 ID 为 second 的路由。本例演示了一个常规规则，您应该在关闭路由时观察这些规则： 公开外部可访问消费者端点的路由应首先关闭，因为这有助于通过路由图的剩余部分来节流消息流。

如果关闭启动时路由仍在处理消息，关闭策略通常会等待当前活跃交换完成处理后再关闭路由。可以使用 shutdownRunningTask 选项在每个路由上配置此行为，该选项可采用以下值之一：

例如，要正常关闭文件消费者端点，您应该指定 CompleteAllTasks 选项，如以下 Java DSL 片段所示：

// Java
public void configure() throws Exception {
    from("file:target/pending")
        .routeId("first").startupOrder(2)
        .shutdownRunningTask(ShutdownRunningTask.CompleteAllTasks)
        .delay(1000).to("seda:foo");

    from("seda:foo")
        .routeId("second").startupOrder(1)
        .to("mock:bar");
}

同一路由可以在 XML DSL 中定义，如下所示：

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <!-- let this route complete all its pending messages when asked to shut down -->
    <route id="first"
           startupOrder="2"
           shutdownRunningTask="CompleteAllTasks">
        <from uri="file:target/pending"/>
        <delay><constant>1000</constant></delay>
        <to uri="seda:foo"/>
    </route>

    <route id="second" startupOrder="1">
        <from uri="seda:foo"/>
        <to uri="mock:bar"/>
    </route>
</camelContext>

关闭超时的默认值为 300 秒。您可以通过在 shutdown 策略上调用 setTimeout（） 方法来更改超时值。例如，您可以将超时值更改为 600 秒，如下所示：

// Java
// context = CamelContext instance
context.getShutdownStrategy().setTimeout(600);

如果您正在实施自定义 Apache Camel 组件（也会从 org.apache.camel.Service 接口继承），您可以确保自定义代码通过实施 org.apache.camel.spi.ShutdownPre ed 接口来接收关闭通知。这为组件提供了在准备关闭过程中执行自定义代码的机会。

OnCompletion DSL 名称用于定义在完成 工作单元时要执行的操作。工作单元是包含 整个交换的 Camel 概念。请参阅 第 34.1 节 “交换”。onCompletion 命令有以下功能：

当在交换中指定Completion DSL 时，Camel 启动一个新的线程。这允许原始线程在不 与Completion 任务进行干预的情况下继续。路由只支持一个 在Completion 中。在以下示例中，无论交换成功完成是成功还是失败，会触发 Completion。这是默认的操作。

from("direct:start")
     .onCompletion()
         // This route is invoked when the original route is complete.
         // This is similar to a completion callback.
         .to("log:sync")
         .to("mock:sync")
     // Must use end to denote the end of the onCompletion route.
     .end()
     // here the original route contiues
     .process(new MyProcessor())
     .to("mock:result");

对于 XML，格式如下：

<route>
    <from uri="direct:start"/>
    <!-- This onCompletion block is executed when the exchange is done being routed. -->
    <!-- This callback is always triggered even if the exchange fails. -->
    <onCompletion>
        <!-- This is similar to an after completion callback. -->
        <to uri="log:sync"/>
        <to uri="mock:sync"/>
    </onCompletion>
    <process ref="myProcessor"/>
    <to uri="mock:result"/>
</route>

要在失败时触发 Completion，可以使用 onFailureOnly 参数。同样，若要成功触发 Completion，请使用 onCompleteOnly 参数。

from("direct:start")
     // Here onCompletion is qualified to invoke only when the exchange fails (exception or FAULT body).
     .onCompletion().onFailureOnly()
         .to("log:sync")
         .to("mock:sync")
     // Must use end to denote the end of the onCompletion route.
     .end()
     // here the original route continues
     .process(new MyProcessor())
     .to("mock:result");

对于 XML，在 Completion tag 中将 onFailureOnly 和 onCompleteOnly 来表示：

<route>
    <from uri="direct:start"/>
    <!-- this onCompletion block will only be executed when the exchange is done being routed -->
    <!-- this callback is only triggered when the exchange failed, as we have onFailure=true -->
    <onCompletion onFailureOnly="true">
        <to uri="log:sync"/>
        <to uri="mock:sync"/>
    </onCompletion>
    <process ref="myProcessor"/>
    <to uri="mock:result"/>
</route>

为多个路由定义 Completion ：

// define a global on completion that is invoked when the exchange is complete
 onCompletion().to("log:global").to("mock:sync");

 from("direct:start")
     .process(new MyProcessor())
     .to("mock:result");

要在某些情况下触发 Completion，请使用 onWhen predicate。当消息正文包含单词 Hello 时，以下示例会触发 onCompletion ：

/from("direct:start")
     .onCompletion().onWhen(body().contains("Hello"))
         // this route is only invoked when the original route is complete as a kind
         // of completion callback. And also only if the onWhen predicate is true
         .to("log:sync")
         .to("mock:sync")
     // must use end to denote the end of the onCompletion route
     .end()
     // here the original route contiues
     .to("log:original")
     .to("mock:result");

自 Camel 2.14 起，Completion 默认不使用线程池。要强制使用线程池，请将 executorService 设置为 true，或者将 parallelProcessing 设为 true。例如，在 Java DSL 中，使用以下格式：

onCompletion().parallelProcessing()
     .to("mock:before")
     .delay(1000)
     .setBody(simple("OnComplete:${body}"));

对于 XML，格式为：

<onCompletion parallelProcessing="true">
   <to uri="before"/>
   <delay><constant>1000</constant></delay>
   <setBody><simple>OnComplete:${body}<simple></setBody>
 </onCompletion>

使用 executorServiceRef 选项引用特定的线程池：

<onCompletion executorServiceRef="myThreadPool"
   <to uri="before"/>
   <delay><constant>1000</constant></delay>
   <setBody><simple>OnComplete:${body}</simple></setBody>
 </onCompletion>>

在Completion 中有两种模式运行：

例如，要将标头 创建的 添加到响应中，请使用 modeBeforeConsumer（），如下所示：

.onCompletion().modeBeforeConsumer()
     .setHeader("createdBy", constant("Someone"))
 .end()

对于 XML，将 mode 属性设置为 BeforeConsumer ：

<onCompletion mode="BeforeConsumer">
   <setHeader headerName="createdBy">
     <constant>Someone</constant>
   </setHeader>
 </onCompletion>

Camel 2.14 已提供

虽然 Camel 提供了很多现有指标集成，但为 Camel 路由添加了 Codahale 指标。这使得最终用户能够使用 Codahale 指标将 Camel 路由信息与所收集的现有数据连接在一起。

要使用 Codahale 指标，您需要：

请注意，性能指标只在显示它们时可用 ; 任何类型的监控工具都可以与 JMX 集成，因为指标可以通过 JMX 获得。此外，实际数据是 100% Codehale JSON。

可以根据各个路由定义 MetricsRoutePolicy，获取单个路由的 Codahale 指标。

从 Java 创建 MetricsRoutePolicy 实例，作为路由的策略分配。这如下所示：

from("file:src/data?noop=true").routePolicy(new MetricsRoutePolicy()).to("jms:incomingOrders");

从 XML DSL，您将定义一个 < bean&gt; 指定一个 <bean>，它指定为路由的策略；例如：

<bean id="policy" class="org.apache.camel.component.metrics.routepolicy.MetricsRoutePolicy"/>

<camelContext xmlns="http://camel.apache.org/schema/spring">
  <route routePolicyRef="policy">
    <from uri="file:src/data?noop=true"/>
[...]

此工厂允许每个路由添加一个 RoutePolicy，该路由利用 Codahale 指标公开路由利用率统计信息。该工厂可以在 Java 和 XML 中使用，如下例所示。

从 Java 中，您刚刚将工厂添加到 CamelContext 中，如下所示：

context.addRoutePolicyFactory(new MetricsRoutePolicyFactory());

从 XML DSL 中，您可以按照如下所示定义 & lt;bean& gt;：

<!-- use camel-metrics route policy to gather metrics for all routes -->
<bean id="metricsRoutePolicyFactory" class="org.apache.camel.component.metrics.routepolicy.MetricsRoutePolicyFactory"/>

从 Java 代码中，您可以从 org.apache .camel.component.metrics.MetricsRegistry 获取 com.codahale.metrics.metrics.routepolicy.MetricsRegistryService，如下所示：

MetricRegistryService registryService = context.hasService(MetricsRegistryService.class);
if (registryService != null) {
  MetricsRegistry registry = registryService.getMetricsRegistry();
  ...
}

MetricsRoutePolicyFactory 和 MetricsRoutePolicy 支持以下选项：

通过为它定义管理名称，Apache Camel 允许您自定义 CamelContext 的名称 （其出现在 JMX 中）。例如，您可以自定义 XML CamelContext 实例的名称模式，如下所示：

<camelContext id="myCamel" managementNamePattern="#name#">
    ...
</camelContext>

如果您没有明确为 CamelContext an 设置名称模式，Apache Camel 将恢复为默认的命名策略。

默认情况下，在 OSGi 捆绑包中部署的 CamelContext 名称等于该捆绑包的 OSGi 符号链接名称。例如，如果 OSGi 符号链接名称为 MyCamelBundle，则 JMX 名称是 MyCamelBundle。如果捆绑包中有多个 CamelContext，则将计数器值添加为后缀，则 JMX 名称不会被混淆。例如，如果 MyCamelBundle 捆绑包中有多个 Camel 上下文，则对应的 JMX MBeans 命名如下：

MyCamelBundle-1
MyCamelBundle-2
MyCamelBundle-3
...

默认命名策略的一个缺陷是，您不能保证给定 CamelContext an 在运行之间具有相同的 JMX 名称。如果您想在不同运行之间具有更高的一致性，您可以通过为 CamelContext 实例定义 JMX name 模式，以更精确地控制 JMX 名称。

要在 Java 中为 CamelContext 指定名称模式，请调用 setNamePattern 方法，如下所示：

// Java
context.getManagementNameStrategy().setNamePattern("#name#");

要在 XML 中为 CamelContext 指定名称模式，请在 camelContext 元素上设置 managementNamePattern 属性，如下所示：

<camelContext id="myCamel" managementNamePattern="#name#">

您可以通过将字面文本和以下令牌的任意令牌组合来构建 JMX 名称模式：

以下是您可以使用支持的令牌定义的 JMX 名称模式的一些示例：

<camelContext id="fooContext" managementNamePattern="FooApplication-#name#">
    ...
</camelContext>
<camelContext id="myCamel" managementNamePattern="#bundleID#-#symbolicName#-#name#">
    ...
</camelContext>

由于自定义命名模式会覆盖默认的命名策略，因此可以使用此方法定义模糊的 JMX MBean 名称。例如：

<camelContext id="foo" managementNamePattern="SameOldSameOld"> ... </camelContext>
...
<camelContext id="bar" managementNamePattern="SameOldSameOld"> ... </camelContext>

在这种情况下，Apache Camel 将在启动时失败，并报告 MBean 已经存在 异常。因此，您应该要格外小心，确保您没有定义模糊的名称模式。

allowUseOriginalMessage 选项默认设置为 false，以便在不需要时到达原始消息的副本。要启用 allowUseOriginalMessage 选项，请使用以下命令：

Apache Camel 支持书本中的大多数模式，即 Gregor Hohpe 和 Bobby Woolf 的 Enterprise Integration Patterns。

表 3.1 “消息传递系统” 中显示的消息传递系统模式介绍了组成消息传递系统的基本概念和组件。

消息传递频道是连接消息传递系统中的参与者的基本组件。表 3.2 “消息传递频道” 中的模式描述了可用的不同类型的消息频道。

消息构建模式（如 表 3.3 “消息构建” 所示）描述了通过系统传递的信息的各种形式和功能。

消息路由模式（在 表 3.4 “消息路由” 所示）描述了将消息通道连接各种方法，包括可应用于消息流的各种算法（无需修改消息正文）。

消息转换模式（如 表 3.5 “消息转换” 所示）描述了如何根据不同的目的修改信息内容。

消息传递端点表示消息传递频道和应用程序之间的联系点。消息端点模式（如 表 3.6 “消息传递端点” 所示）介绍了可以在端点上配置的各种功能和服务质量。

系统管理模式（如 表 3.7 “系统管理” 所示）介绍了如何监控、测试和管理消息传递系统。

Apache Camel 提供了很多不同的方法和组件，用于在 Camel 应用程序中定义 REST 服务。本节概述了这些不同方法和组件，以便您可以决定哪些实施和 API 最适合您的要求。

Representational State Transfer (REST)是一个分布式应用程序的架构，它仅利用 HTTP 传输数据的中心，仅使用四个基本的 HTTP 动词： GET、POST、PUT 和 DELETE。

与 SOAP 等协议不同，它把 HTTP 视为 SOAP 消息的传输协议，REST 架构直接利用 HTTP。关键洞察是，HTTP 协议 本身 由几个简单惯例增强，它非常适合充当分布式应用程序的框架。

因为 REST 架构围绕标准 HTTP 动词构建，因此在很多情况下，您可以使用常规浏览器作为 REST 客户端。例如，若要调用在主机和端口 localhost:9091 上运行的简单 Hello World REST 服务，您可以在浏览器中导航到类似于以下 URL 的 URL：

http://localhost:9091/say/hello/Garp

Hello World REST 服务可能会返回响应字符串，例如：

Hello Garp

其显示在浏览器窗口中。您可以使用标准浏览器（或 curl 命令行实用程序）调用 REST 服务的简易性，是 REST 协议快速获得流行的原因之一。

以下 REST 打包程序层提供了定义 REST 服务的简化语法，并可在不同 REST 实现之上分层：

Apache Camel 通过以下组件提供多个不同的 REST 实现：

JAX-RS （RESTful Web 服务的 Java API）是一个将 REST 请求绑定到 Java 对象的框架，其中 Java 类必须使用 JAX-RS 注释进行解码，以定义绑定。JAX-RS 框架相对成熟，为开发 REST 服务提供了复杂的框架，但它在编程上也比较复杂。

JAX-RS 与 Apache Camel 集成由 CXFRS 组件实施，该组件通过 Apache CXF 进行分层。简而言之，CIBian-RS 使用以下注释将 REST 请求绑定到 Java 类（其中，这仅是许多可用注释的不完整示例）：

REST 请求或 REST 响应的正文通常应采用 JAXB(XML)数据格式。但 Apache CXF 还支持 JSON 格式转换为 JAXB 格式，以便也可以解析 JSON 消息。

如需了解更多详细信息，请参阅 Apache Camel 组件参考指南 和 Apache CXF 开发指南中的 CXFRS 。

REST DSL 实际上是一个 facade，它提供了在 Java DSL 或 XML DSL（域特定语言）中定义 REST 服务的简化语法。REST DSL 并不实际提供 REST 实现，它只是一个围绕 现有 REST 实施（Apache Camel 中有几个）的打包程序。

REST DSL 打包程序层提供以下优点：

由于 REST DSL 不是实际的 REST 实现，所以您需要做的第一项一项是选择 Camel 组件以提供底层实施。以下 Camel 组件目前与 REST DSL 集成：

要指定 REST 的实现，您可以使用 restConfiguration（） 构建器（在 Java DSL 中）或 restConfiguration 元素（在 XML DSL 中）。例如，要将 REST DSL 配置为使用 Spark-Rest 组件，您可以在 Java DSL 中使用类似以下内容的构建器表达式：

restConfiguration().component("spark-rest").port(9091);

您会在 XML DSL 中使用类似如下的元素（作为 camelContext的子项）：

<restConfiguration component="spark-rest" port="9091"/>

定义 REST 服务的 Java DSL 语法如下：

rest("BasePath").Option().
    .Verb("Path").Option().[to() | route().CamelRoute.endRest()]
    .Verb("Path").Option().[to() | route().CamelRoute.endRest()]
    ...
    .Verb("Path").Option().[to() | route().CamelRoute];

其中 CamelRoute 是一个可选的嵌入式 Camel 路由（使用路由的标准 Java DSL 语法定义）。

REST 服务定义以 rest（） 关键字开头，后跟处理特定 URL 路径片段的一个或多个 动词子。HTTP 动词可以是 get（）、head（） 、put（）、 post（）、 delete（）、patch（） 或 verb（） 之一。每个 verb 子句都可以使用以下语法之一：

在 Java 中，若要使用 REST DSL 定义服务，请将 REST 定义放在 RouteBuilder.configure（） 方法的正文中，就像常规的 Apache Camel 路由一样。例如，要使用带有 Spark-Rest 组件的 REST DSL 定义一个简单的 Hello World 服务，请定义以下 Java 代码：

restConfiguration().component("spark-rest").port(9091);

rest("/say")
    .get("/hello").to("direct:hello")
    .get("/bye").to("direct:bye");

from("direct:hello")
    .transform().constant("Hello World");
from("direct:bye")
    .transform().constant("Bye World");

前面的示例具有三种不同类型的构建器：

在 XML 中，若要使用 XML DSL 定义服务，请将 rest 元素定义为 camelContext 元素的子级。例如，若要使用带有 Spark-Rest 组件的 REST DSL 定义一个简单的 Hello World 服务，请定义以下 XML 代码（在 Blueprint 中）：

<camelContext xmlns="http://camel.apache.org/schema/blueprint">
  <restConfiguration component="spark-rest" port="9091"/>

  <rest path="/say">
    <get uri="/hello">
      <to uri="direct:hello"/>
    </get>
    <get uri="/bye">
      <to uri="direct:bye"/>
    </get>
  </rest>

  <route>
    <from uri="direct:hello"/>
    <transform>
      <constant>Hello World</constant>
    </transform>
  </route>
  <route>
    <from uri="direct:bye"/>
    <transform>
      <constant>Bye World</constant>
    </transform>
  </route>
</camelContext>

rest（） 关键字(Java DSL)或 rest 元素的 path 属性(XML DSL)允许您定义一个基本路径，然后是作为前缀放在所有 动词条款中的路径上。例如，给定以下 Java DSL 片段：

rest("/say")
    .get("/hello").to("direct:hello")
    .get("/bye").to("direct:bye");

或者给定以下 XML DSL 片段：

<rest path="/say">
  <get uri="/hello">
    <to uri="direct:hello"/>
  </get>
  <get uri="/bye" consumes="application/json">
    <to uri="direct:bye"/>
  </get>
</rest>

REST DSL 构建器为您提供了以下 URL 映射：

/say/hello
/say/bye

基本路径是可选的。如果您愿意，您可以在每个 动词条款中指定完整路径：

rest()
    .get("/say/hello").to("direct:hello")
    .get("/say/bye").to("direct:bye");

REST DSL 支持使用 toD 动态参数。使用此参数指定 URI。

例如，在 JMS 中，可以通过以下方式定义动态端点 URI：

public void configure() throws Exception {
   rest("/say")
     .get("/hello/{language}").toD("jms:queue:hello-${header.language}");
}

在 XML DSL 中，同样的详情如下：

<rest uri="/say">
  <get uri="/hello//{language}">
    <toD uri="jms:queue:hello-${header.language}"/>
  </get>
<rest>

有关 toD 动态参数的更多信息，请参阅 “动态到”一节。

在动词参数中，您可以指定一个 URI 模板，您可以在命名的属性中捕获特定路径片段（然后映射到 Camel 消息标头）。例如，如果您想要对 Hello World 应用进行个性化，以便它根据名称设置调用者，您可以定义一个 REST 服务，如下所示：

rest("/say")
    .get("/hello/{name}").to("direct:hello")
    .get("/bye/{name}").to("direct:bye");

from("direct:hello")
    .transform().simple("Hello ${header.name}");
from("direct:bye")
    .transform().simple("Bye ${header.name}");

URI 模板捕获 {name} 路径片段的文本，并将这个捕获的文本复制到 名称 消息标头中。如果您通过发送 URL 以 /say/hello/Joe 结尾的 GET HTTP 请求调用服务，则 HTTP 响应为 Hello Joe。

您可以使用 to（） 关键字(Java DSL)或 to 元素(XML DSL)来终止 verb 子句，而是可以选择直接使用 Apache Camel 路由到 REST DSL 中，使用 route（） 关键字(Java DSL)或 路由 元素(XML DSL)。route（） 关键字允许您将路由嵌入到 verb 子句中，语法如下：

RESTVerbClause.route("...").CamelRoute.endRest()

其中 endRest（） 关键字（仅限 Java DSL）是一个必要的标点符号，可让您分隔操作动词子句（当 rest（） 构建器中有多个动词子句时）。

例如，您可以重构 Hello World 示例以使用嵌入的 Camel 路由，如下为 Java DSL：

rest("/say")
    .get("/hello").route().transform().constant("Hello World").endRest()
    .get("/bye").route().transform().constant("Bye World");

如下在 XML DSL 中：

<camelContext xmlns="http://camel.apache.org/schema/blueprint">
  ...
  <rest path="/say">
    <get uri="/hello">
      <route>
        <transform>
          <constant>Hello World</constant>
        </transform>
      </route>
    </get>
    <get uri="/bye">
      <route>
        <transform>
          <constant>Bye World</constant>
        </transform>
      </route>
    </get>
  </rest>
</camelContext>

如果您没有显式配置 HTTP 传输组件，则 REST DSL 会自动发现通过检查类路径上的可用组件来使用的 HTTP 组件。REST DSL 查找任何 HTTP 组件的默认名称，并使用它找到的第一个名称。如果类路径中没有 HTTP 组件，并且您没有显式配置 HTTP 传输，则默认 HTTP 组件为 camel-http。

您可以使用 consume （） 过滤 HTTP 请求和响应 的内容类型，并在 Java 中生成s（） 选项，或者在 XML 中生成属性。 例如，一些常见内容类型（官方称为 互联网介质类型）如下：

内容类型在 REST DSL 中以 verb 子句的形式提供。例如，若要将 verb 子句限制为仅接受 text/plain HTTP 请求，并且仅发送 文本/html HTTP 响应，您需要使用类似如下的 Java 代码：

rest("/email")
    .post("/to/{recipient}").consumes("text/plain").produces("text/html").to("direct:foo");

在 XML 中，您可以设置 使用 并生成 属性，如下所示：

<camelContext xmlns="http://camel.apache.org/schema/blueprint">
  ...
  <rest path="/email">
    <post uri="/to/{recipient}" consumes="text/plain" produces="text/html">
      <to "direct:foo"/>
    </get>
  </rest>
</camelContext>

您还可以指定使用 （）的参数，或以逗号分隔列表的形式 生成。例如，使用 ("text/plain, application/json")。

一些 HTTP 服务器实施支持额外的 HTTP 方法，它们不是由 REST DSL 中标准动词集合提供的，即 get（）, head（） , put （）, post （）, delete （）, patch（）.要访问其他 HTTP 方法，您可以在 XML DSL 中使用 generic 关键字 verb（） 和通用元素 动词。

例如，要在 Java 中实施 DIB HTTP 方法：

rest("/say")
    .verb("TRACE", "/hello").route().transform();

这里的 transform（） 将 IN 消息正文复制到 OUT 消息的正文，以回显 HTTP 请求。

在 XML 中实施 DIB HTTP 方法：

<camelContext xmlns="http://camel.apache.org/schema/blueprint">
  ...
  <rest path="/say">
    <verb uri="/hello" method="TRACE">
      <route>
        <transform/>
      </route>
    </get>
</camelContext>

如果您的 REST 服务需要发送错误消息作为其响应，您可以定义自定义 HTTP 错误消息，如下所示：

以下 Java 示例演示了如何定义自定义错误消息：

// Java
// Configure the REST DSL, with JSON binding mode
restConfiguration().component("restlet").host("localhost").port(portNum).bindingMode(RestBindingMode.json);

// Define the service with REST DSL
rest("/users/")
    .post("lives").type(UserPojo.class).outType(CountryPojo.class)
        .route()
            .choice()
                .when().simple("${body.id} < 100")
                    .bean(new UserErrorService(), "idTooLowError")
                .otherwise()
                    .bean(new UserService(), "livesWhere");

在这个示例中，如果输入 ID 小于 100，则返回自定义错误消息，使用 UserErrorService bean，它实现：

// Java
public class UserErrorService {
    public void idTooLowError(Exchange exchange) {
        exchange.getIn().setBody("id value is too low");
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/plain");
        exchange.getIn().setHeader(Exchange.HTTP_RESPONSE_CODE, 400);
    }
}

在 UserErrorService bean 中，我们定义自定义错误消息，并将 HTTP 错误代码设置为 400。

可以为传入 Camel 消息的标头指定默认值。

您可以使用一个键单词（如 query 参数的 verbose ）来指定默认值。例如，在下面的代码中，默认值为 false。这意味着，如果没有为带有 verbose 键的标头提供其他值，则会将 false 插入为默认值。

rest("/customers/")
    .get("/{id}").to("direct:customerDetail")
    .get("/{id}/orders")
      .param()
	.name("verbose")
	.type(RestParamType.query)
	.defaultValue("false")
	.description("Verbose order details")
      .endParam()
        .to("direct:customerOrders")
    .post("/neworder").to("direct:customerNewOrder");

您可能希望返回自定义错误消息的一个常见情形是嵌套 JsonParserException 异常。例如，您可以方便地利用 Camel 异常处理机制来创建自定义 HTTP 错误消息，其 HTTP 错误代码 400，如下所示：

// Java
onException(JsonParseException.class)
    .handled(true)
    .setHeader(Exchange.HTTP_RESPONSE_CODE, constant(400))
    .setHeader(Exchange.CONTENT_TYPE, constant("text/plain"))
    .setBody().constant("Invalid json data");

通常，可以直接将 REST DSL 选项应用到服务定义的基本部分（即，立即遵循 rest（）），如下所示：

rest("/email").consumes("text/plain").produces("text/html")
    .post("/to/{recipient}").to("direct:foo")
    .get("/for/{username}").to("direct:bar");

在这种情形中，如果指定选项应用到所有从属动词子句。或者可将选项应用到每个单独的 verb 子句，如下所示：

rest("/email")
    .post("/to/{recipient}").consumes("text/plain").produces("text/html").to("direct:foo")
    .get("/for/{username}").consumes("text/plain").produces("text/html").to("direct:bar");

如果指定选项仅适用于相关的 动词子，则从基础部分覆盖任何设置。

表 4.1 “REST DSL 选项” 总结 REST DSL 支持的选项。

使用 REST 协议的最常见方式之一是传输消息正文中 Java Bean 的内容。为了实现此工作，您需要有一个机制来汇总 Java 对象，以及从适当的数据格式放入其中。REST DSL 支持下列数据格式适用于编码 Java 对象：

当然，您可以编写所需的代码，以将邮件正文转换为 Java 对象，并自行从 Java 对象转换。但是 REST DSL 提供了自动进行这个转换的便利。特别是，JSON 和 JAXB 与 REST DSL 的集成提供了以下优点：

Apache Camel 提供 JSON 和 JAXB 数据格式的多个不同实施。REST DSL 目前支持以下数据格式：