Apache Camel 开发指南

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

您可以根据需要定义任意数量的 RouteBuilder 类。每个类实例化一次，并使用 CamelContext 对象注册。通常，每个 RouteBuilder 对象的生命周期由部署路由器的容器自动管理。

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

RouteBuilder 类定义用于启动路由规则的方法（例如，from （）、拦截器 （） 和 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.
  // ...
}
}

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

域特定语言(DSL)是一种专为特殊目的设计的微语言。DSL 不必以逻辑方式完成，但需要足够的表达能力来描述所选域中的问题。通常，DSL 不需要 专用的解析器、解释器或编译器。DSL 可以在现有对象导向型主机语言之上进行 piggyback，只要提供的 DSL 结构被完全映射到主机语言 API 中的结构。

在 hypothetical 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. 本地路由规则

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

本地规则始终首先定义消费者端点，使用 from ("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 支持以下 MEP：

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

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

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

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

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

其中，过滤器由 predicate, header ("foo").isEqualTo ("bar")。要根据消息内容构建更复杂的 predicates 和 表达式，您可以使用表达式和 predicate 语言之一（请参阅 第 II 部分 “路由表达式和 predicates 语言”）。

路由器 schema iwl-busybox，它定义了 XML DSL iwl-wagonbelongs 到以下 XML 模式命名空间：

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

路由器模式的位置通常指定为 http://camel.apache.org/schema/spring/camel-spring.xsd，它引用 Apache 网站上模式的最新版本。例如，Apache Camel Spring 文件的 root beans 元素通常会配置，如 例 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 文件的根目录中获取模式的副本。这样可确保用于解析 Spring 文件的 schema 版本始终与当前的运行时版本匹配。这很重要，因为在 Apache 网站上发布的最新版本的模式可能与您当前使用的运行时版本不匹配。

通常，建议您使用功能齐全的 XML 编辑器编辑 Spring 文件。XML 编辑器的自动完成功能使编写 XML 更容易编写，该模式符合路由器模式，编辑器会立即警告，如果 XML 不正确。

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

<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，context Path 提供了由协议解释的 URI 详情。另外，大多数方案都允许您定义查询选项 queryOptions，它们以以下格式指定：

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

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

http://www.google.com

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

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

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

timer://tickTock?period=1000

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

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

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

其中每个术语在方括号 [] 中都是可选的，且表示法是 (A|B)，表示 A 和 B 是替代方案。

例如，您可以使用 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 编码。在某些情况下，这是不必要的行为。例如，在设置密码选项时，最好在 没有 URI 编码的情况下 传输原始字符字符串。

可以通过使用语法 RAW (RawValue) 指定选项值来关闭 URI 编码。例如，

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

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

有些端点 URI 选项映射到 Java enum 常数。例如，Log 组件的 level 选项可以取 enum 值、INFO、WARN、ERROR 等。这个类型转换是区分大小写的，因此以下任何备选方法都可用于设置 Log producer 端点的日志级别：

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

在 Camel 2.17 中，基于资源的组件（如 XSLT），Velociy 可以使用 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 组件，您可以在项目 POM 文件中添加以下 Maven 依赖项：

<!-- 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-core 工件中），因此它们始终可用：

消费者端点 是在路由 开始 时出现的端点（即，在 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>

有些组件 只能是 消费者的，它只能用于定义消费者端点。例如，Qartz 组件专门用于定义消费者端点。以下 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。

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

例如，以下 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、 Target2 或 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 （）.roundRobin （）.to (" mock:foo ").to ("mock:bar").end （），它会在 mock:foo 和 mock: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 的工作原理是通过限制每秒可传递的消息数量。如果传入的消息超过指定率，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 路由的基本构建块组成。例如，contextctl 命令（如 filter （）、delayer （）、setBody （）、setHeader （） 和 to （） ）代表处理器。在考虑处理器如何连接以构建路由时，务必要区分两种不同的处理方法。

第一种方法是处理器只是修改交换的 In 消息的位置，如 图 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 的消息正文的 Out 消息：

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

其中 constant ("DummyBody") 代表一个常量表达式。您无法直接传递字符串 DummyBody，因为参数 to transform （） 必须是表达式类型。

图 2.3 “InOnly Exchanges 的 Pipeline 示例” 显示 InOnly exchanges 的处理器管道示例。处理器 A 通过修改 In 消息来运作，而处理器 B 和 C 创建 Out 消息。路由构建器将处理器链接在一起，如下所示。特别是，处理器 B 和 C 以 管道的形式链接在一起：也就是说，处理器 B 的 Out 消息会在将交换发送到处理器 C 之前移到 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");

其中 Velocity 端点 velocity:file:AddressTemplate.vm，指定文件系统中ociy 模板文件的位置，file:AddressTemplate.vm。to （） 命令将交换模式更改为 InOut，然后将交换发送到 Velocity 端点，然后在之后将其重新更改为 InOnly。有关 Velocity 端点的更多详细信息，请参阅 Apache Camel 组件参考指南 中的 Velocity。

图 2.4 “InOut Exchanges 的 Pipeline 示例” 显示 InOut 交换的处理器管道示例，通常用于支持远程过程调用(RPC)语义。处理器 A、B 和 C 以管道的形式链接在一起，每个处理器的输出被放入下一个输入中。producer 端点生成的最终 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:bean:addAccountDetails ,cxf: bean:bean:getCreditRating, 和 cxf:bean:processTransaction.最终的 Web 服务( 流程交易 )生成通过 JETTY 端点发回的响应（传出消息）。

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

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

InOptionalOut 交换的管道基本与 图 2.4 “InOut Exchanges 的 Pipeline 示例” 中的管道相同。InOut 和 InOptionalOut 之间的区别在于，允许 InOptionalOut 交换模式的交换具有 null 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");

在这两个示例中，来自每个输入端点 URI 1、URI2 和 URI3 的交换都会相互独立处理，并在单独的线程中独立处理。实际上，您可以将前面的路由视为与以下三个独立路由相等：

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

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

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

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

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

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

例如，如果要从两个消息队列获取输入，activemq:Nyse 和 activemq:Nasdaq，并将它们合并到单个消息队列 activemq: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）由五个线程池处理。

虚拟机组件与 SEDA 端点非常相似。唯一的区别是，而 SEDA 组件仅限于将路由段与同一 CamelContext 内的连接在一起，虚拟机组件使您能够将来自不同 Apache Camel 应用程序的路由链接在一起，只要它们在同一 Java 虚拟机中运行。

库存事务示例可以重新写入使用虚拟机端点而不是 SEDA 端点，如下所示：

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

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

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

内容增强模式定义了处理路由的多个输入的基本方式。当交换进入增强器处理器时，增强器会联系外部资源来检索信息，然后添加到原始消息中。在此模式中，外部资源实际上代表消息的第二个输入。

例如，假设您正在编写处理信用请求的应用。在处理信用请求前，您需要为客户分配信用评级的数据，其中 ratings 数据存储在 目录中的一个文件中( 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 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 注册表 访问，该服务是一种服务，允许您将类名称或 Bean ID 用作密钥来查找 Bean。在 bean 注册表中创建条目的方式取决于底层的 framework，即 Java、Spring、Gusice 或 Blueprint。通常，registry 条目会被隐式创建（例如，当您在 Spring XML 文件中实例化 Spring bean 时）。

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

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

在 OSGi 容器中部署是一个特殊情况。当 Apache Camel 路由部署到 OSGi 容器中时，CamelContext 会自动设置用于解析 bean 实例的 registry 链：registry 链由 OSGi 注册表组成，后跟 Blueprint （或 Spring）注册表。

要使用 Java bean （即普通旧 Java 对象或 POJO）处理对象，请使用 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 的方法，它采用两个参数，无论参数的确切类型，请按如下所示调用 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");

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

除了简单类型值外，您还可以使用简单语言(第 30 章 简单语言)指定参数值。这意味着，在指定 参数值时，可以使用简单语言的完整功能。例如，将消息正文和标题标头的值传递给 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 方法，您可以定义符合某些约定的方法签名。特别是，方法签名有两个基本惯例：

如果要实施访问或修改传入的消息正文的 bean 方法，您必须定义一个使用单个 String 参数的方法签名并返回 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 容器。

其中 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>

为了提高效率，您可以将 cache 选项设置为 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 路由中引用 bean，如下所示：

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

或者，您可以通过注入引用 Spring bean，使用 @BeanInject 注释，如下所示：

// 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 depends-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);
    }
}

请注意，您如何将注解与默认约定混合。除了注入注释的参数外，参数绑定也会自动将交换对象注入 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 中的第一个方法。

参数绑定注解可以从接口或从 superclass 继承。例如，如果您使用 Header 注解和 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 接口的类通常 受到保护、私有 或仅软件包 的范围。如果您试图调用以这种方式限制的实施类的方法，则 bean 绑定会返回调用对应的接口方法，该方法可以被公开访问。

例如，请考虑以下 public 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 调用将回退到调用 public BeanIntf.processBodyAndHeader 方法：

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

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

// 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");

请注意，虽然此语法与调用普通函数看起来相同，但 bean 集成利用 Java 反映将方法识别为静态，并继续 在不 实例化 MyStaticClass 的情况下调用方法。

在将路由部署到红帽 JBoss 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 容器中部署时设置一个注册表链。首先，它会在 OSGi 服务 registry 中查找指定的类名称；如果此查找失败，它将回退到本地 Spring DM 或蓝图注册表。

在使用 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 类支持以下方法：

属性占位符功能可用于将字符串替换为不同的上下文（如端点 URI 和 XML DSL 元素中的属性），其中占位符设置存储在 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 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

您可以将 Java 系统属性和 O/S 环境变量嵌入到 路径Name 中。

Java 系统属性可以使用语法 ${PropertyName} 嵌入到位置解析器中。例如，如果红帽 JBoss 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 “属性文件示例” 中显示的属性设置，您可以定义路由，如下所示：

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

默认情况下，占位符解析器查找 registry 中的 属性 bean ID 来查找属性组件。如果您愿意，您可以在端点 URI 中明确指定方案。例如，通过将 properties: 前缀给每个端点 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 元素的各种属性。在这种情况下，placholder 语法也使用双花括号 {{ 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 type iwl-setuptoolsfor 例如，< 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 命令时，您可以使用属性占位符值设置任何 EIP 选项，方法是添加表单的子clause，占位符("OptionName", "Key")。

例如，如果属性文件定义了 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 DSLs 的属性中使用 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>

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

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

例如，请考虑以下路由，其中路由中的最后一个端点由属性占位符 {{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>

blueprint 属性占位符机制通过创建一个 cm:property-placeholder bean 来初始化。在前面的示例中，cm:property-placeholder bean 与 camel.blueprint 持久 ID 关联，其中持久性 ID 是引用 OSGi Configuration Admin 服务中一组相关属性的标准方法。换句话说，cm:property-placeholder bean 提供对 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 bean。也就是说，蓝图： 解析器明确引用 cm:property-placeholder bean 的 ID、myblueprint.placeholder。

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

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

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

定义 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 软件包 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 和 Jetty iwl-osgi 是以多线程方式本质上是多线程的。这些组件都使用 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 命令，可用于将线程池引入路由。它支持以下选项来自定义线程池：

要为一个线程感知的处理器创建默认线程池，请在 XML DSL 中使用 parallelProcessing （） sub-clause, 或 parallelProcessing 属性启用 parallelProcessing 选项。

例如，在 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 中，您可以自定义 default 线程池配置文件中的 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 选项时，线程感知处理器首先会尝试在 registry 中使用该 ID 查找带有该 ID 的自定义线程池。如果没有使用该 ID 注册线程池，处理器会尝试在 registry 中查找自定义线程池配置集，并使用自定义线程池配置集实例化自定义线程池。

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

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

表 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");

您可以通过将对象 ID 传递给 executorServiceRef （）选项，而不是将对象引用(Custom Pool )传递给 executorService Ref （）选项，而是在 registry 中查找线程池，方法是将其 bean ID 传递给 executorServiceRef （） 选项，如下所示：

// 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 和 FTP iwl-setuptoolsallow，以指定要使用的线程池。这使得不同的组件能够共享同一线程池，从而减少 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 路由是否自动启动，请调用自动启动命令，使用布尔值参数(true 或 false)或 String 参数(true 或 false)。 例如，您可以在 Java DSL 中禁用路由自动启动，如下所示：

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

您可以通过在 route 元素中将 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 （） 方法，随时手动启动或停止路由。例如，要启动路由 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 的任何正整数值。1000 和 over 值是为 Apache Camel 保留的值，它会自动将这些值分配给路由，而无需显式启动值。例如，上例中的最后一个路由将自动分配启动值 1000 （因此在前两个路由后启动）。

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

路由按照启动顺序的反向关闭。也就是说，当使用 startupOrder （） 命令（在 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.ShutdownPrepared 接口来确保自定义代码收到关闭通知。这为组件提供了执行自定义代码以准备关闭的机会。

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

当在交换 上指定了"Completion DSL"时，Camel 会关闭新的线程。这允许原始线程继续，而不会对 onCompletion 任务进行干扰。路由将只在完成时支持 一个。在以下示例中，触发 onle tion，无论交换在成功或失败时是否完成。这是默认操作。

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>

要在失败时触发 onCompletion，可以使用 onFailureOnly 参数。同样，若要触发成功的时间，请使用 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，onFailureOnly 和 onCompleteOnly 在 Completion 标签中以布尔值表示：

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

为 多个路由定义 on letion：

// 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");

要在某些情况下触发 onCompletion，请使用 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 或将 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>>

OnCompletion 可使用两种模式运行：

例如，要将标头 创建的 添加到响应中，请使用 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 中，您定义一个 & lt;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 中，您可以定义一个 < 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.metrics.metrics.MetricsRegistryService 中获取 com.codahale.metrics.MetricRegistry Service，如下所示：

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

MetricsRoutePolicyFactory 和 MetricsRoutePolicy 支持以下选项：

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

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

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

默认情况下，在 OSGi 捆绑包中部署的 CamelContext bean 的 JMX 名称等于捆绑包的 OSGi 符号名称。例如，如果 OSGi 符号名称是 MyCamelBundle，JMX 名称为 MyCamelBundle。如果捆绑包中有多个 CamelContext，通过添加计数器值作为后缀来忽略 JMX 名称。例如，如果 MyCamelBundle 捆绑包中存在多个 Camel 上下文，则对应的 JMX MBeans 被命名，如下所示：

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

默认命名策略的一个缺陷是，您不能保证给定 CamelContext bean 在运行之间具有相同的 JMX 名称。如果要在运行之间具有更大的一致性，您可以通过为 CamelContext 实例定义 JMX 名称 模式来更精确地控制 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 的企业集成模式。

消息传递系统模式（如 表 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：

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 分层。总之，JAX-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 路径片段的 verb 子句。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)允许您定义一个基本路径，然后作为所有 verb 子句中的路径作为前缀。例如，给定以下 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 动态 to 参数。使用此参数指定 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 dynamic to 参数的详情，请参考 “动态到”一节。

在操作动词参数中，您可以指定一个 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} 路径片段的文本，并将这个捕获的文本复制到 名称 消息标头中。如果您通过发送 GET HTTP 请求并使用以 /say/hello/Joe 结尾的 URL 调用该服务，则 HTTP 响应为 Hello Joe。

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

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

其中 endRest （） 关键字（仅限 Java DSL 关键字）是必要的标点标记，使您能够分隔 verb 子句（当 rest （） 构建器中有多个动词子时）。

例如，您可以重构 Hello World 示例以使用嵌入式 Camel 路由，如下所示：

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 组件的默认名称，并使用找到的第一个名称。如果 classpath 中没有 HTTP 组件，且您没有显式配置 HTTP 传输，则默认的 HTTP 组件为 camel-http。

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

内容类型在 REST DSL 中的 verb 子句上作为选项指定。例如，要将 verb 子句限制为仅接受 text/plain HTTP 请求，并且仅发送 text/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>

您还可以将参数指定为 consume （） 或 produce （） 作为以逗号分隔的列表。例如，consume ("text/plain, application/json")。

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

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

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

其中 transformation （） 将 IN 消息的正文复制到 OUT 消息的正文，从而回显 HTTP 请求。

在 XML 中实施 TRACE 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 消息的标头指定默认值。

您可以使用关键字词来指定默认值，如查询参数 详细 等。例如，在下面的代码中，默认值为 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");

在这种情况下，指定的选项仅适用于相关的 verb 子句，覆盖来自基本部分的任何设置。

表 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 目前支持以下数据格式：

要在 REST DSL 中启用对象 marshalling，请观察以下点：

bindingMode 选项默认为 off，因此您必须明确配置它，以便启用 Java 对象的 marshalling。TABLE 显示支持的绑定模式列表。