Apache Camel 开发指南

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

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

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

RouteBuilder 类定义用于启动路由规则的方法（例如，from （）、intercept （） 和 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 可以在面向对象的现有对象的主机语言上得到缓解，提供的 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. 本地路由规则

本地规则始终以 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，它由一个消息组成，从消费者端点流到生成者端点( InOnly MEP)。另一方面，RPC 协议可能会定义一个 MEP，它由请求消息和一个回复消息( InOut MEP)。目前，Apache Camel 支持以下 MEP：

其中，这些消息交换模式由枚举类型 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 和表达式，您可以使用表达式和 predicate 语言之一（请参阅 第 II 部分 “路由表达式和 predicates 语言”）。

路由器模式都包括在以下 XML 模式命名空间中：

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

路由器模式的位置通常指定为 http://camel.apache.org/schema/spring/camel-spring.xsd，它引用 Apache 网站中的模式的最新版本。例如，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 文件的模式版本始终与当前的运行时版本匹配。这一点很重要，因为发布在 Apache Web 站点上的架构的最新版本可能与您当前使用的运行时版本不匹配。

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

XML 编辑器 通常 依赖从 xsi:schemaLocation 属性中指定的位置下载模式。为了确保您使用正确的模式版本 whilst 编辑，最好选择 camel-spring.xsd 文件的特定版本。例如，要为 Apache Camel 的 2.3 版本编辑 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，而 contextPath 提供协议解释的 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 组件都有选项，其值是一个时间段（例如，指定超时值等）。默认情况下，此类时间段选项通常指定为纯数字，它被解释为毫秒的时间段。但是 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 编码。在某些情况下，这是不必要的行为。例如，在设置 password 选项时，最好在 没有 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）可以使用 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 被 username 字符串的值替换，第二个出现的 %s 将被密码字符串替代。这个字符串格式化机制通过 String.format （） 实施，它与 C printf （） 函数提供的格式类似。详情请参阅 java.util.Formatter。

producer 端点 是出现在 中间 或路由 末尾的 端点（例如，在 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、 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 | more 是将目录列表 ls 传送到 page-scrolling 实用程序的命令示例，更多。管道的基本理念是，其中一个 命令的输出 被引入到下一个命令 的输入 中。路由时的自然模拟是，从一个处理器中要复制到下一处理器的 In 消息中的 Out 消息。

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

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

图 2.1. 处理器修改消息

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

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

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

图 2.2. 处理器创建注销消息

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

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

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

图 2.3 “InOnly Exchanges 的管道示例” 显示了用于 InOnly 交换的处理器管道示例。处理器 A 通过修改 In 消息来的行为，而处理器 B 和 C 则创建 Out 消息。路由构建器将处理器连接在一起，如下所示。特别是，处理器 B 和 C 以 管道 的形式链接在一起：也就是说，处理器 B 的 Out 消息会在将交换发送到处理器 C 之前移到 In 消息，处理器 C's Out 消息会移到 In 消息，然后再将交换进入生成者端点。因此，处理器的输出和输入加入到持续管道中，如 图 2.3 “InOnly Exchanges 的管道示例” 所示。

图 2.3. InOnly Exchanges 的管道示例

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

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

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

图 2.4 “InOut Exchange 的管道示例” 显示 InOut Exchanges 的处理器管道示例，您通常使用它来支持远程过程调用(RPC)语义。处理器 A、B 和 C 以管道的形式连接在一起，以及下一个处理器的输入信息。producer 端点生成的最终 Out 消息将以所有方式发回给消费者端点，其中提供了对原始请求的回复。

图 2.4. InOut Exchange 的管道示例

请注意，为了支持 InOut Exchange 模式，路由（无论是生成者端点还是某种其他类型的处理器）中的最后一个节点都会创建 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:cxf:bean:getCreditRating, 和 cxf:bean:processTransaction。最后的 Web 服务处理 事务 生成通过 JETTY 端点发回的响应(出 消息)。

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

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

InOptionalOut Exchanges 的管道与 图 2.4 “InOut Exchange 的管道示例” 中的管道基本相同。InOut 和 InOptionalOut 之间的区别在于，使用 InOptionalOut 交换模式的交换允许将 null Out 消息作为回复。也就是说，如果 In OptionalOut 交换，则会将 nullOut 消息复制到管道中下一节点的 In 消息。相反，如果 InOut Exchange，将丢弃 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. 使用分段路由处理多个输入

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

这些端点的主要目的是使您能够将不同的部分绑定到路由的不同部分。它们都提供了一种将多个输入合并为一个路由的有效方法。

直接组件提供将连接在一起的路由的最简单机制。直接组件的事件模型是 同步的，因此后续的路由片段在与第一个网段相同的线程中运行。直接 URL 的一般格式是 direct: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 队列。

直接端点的实现的行为如下：每当交换到达生成者端点时（例如，to ("direct:mergeTxns")），直接端点将交换直接传递给具有相同端点 ID （例如，from ("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");

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

例如，假设您正在编写处理信用请求的应用。在处理信用请求之前，您需要使用为客户分配信用评级的数据对其进行补充，其中评级数据存储在目录 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 registry 中创建条目的方式取决于底层的框架是是 plain Java、Spring、Guice 或 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 实例的注册表链：注册表链由 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");

在指定方法时，您可以使用简单的非限定类型名称，如 processBody (Exchange)- 或完全限定类型 name- 例如 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 类型值外，您还可以使用 Simple 语言(第 30 章 简单语言)指定参数值。这意味着，在指定 参数值时，可以使用 Simple 语言的完整功能。例如，将消息正文和 title 标头的值传递给 bean 方法：

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

您还可以将整个标头哈希映射作为参数传递。例如，在以下示例中，必须将第二个 method 参数声明为 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 容器。

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

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>

对于 slight 效率，您可以将 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");

或者，您可以使用 @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 起的行为。

如果您需要更改此行为（因此，在其他 Bean 之前，Camel 上下文 不会被 强制关闭），您可以将 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);
    }
}

请注意，如何将注解与默认约定混合在一起。除了注入注解的参数外，参数绑定也会自动将交换对象注入 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 中调用具有匹配返回类型的第一个方法。

参数绑定注解可以从接口或超级类继承。例如，如果您使用 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 调用会返回调用公共 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 集成来调用静态 更改Something 方法，如下所示：

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

请注意，虽然这种语法与调用普通函数相同，但 bean 集成利用 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 容器中部署时，Apache Camel 设置注册表链。首先，它会在 OSGi 服务注册表中查找指定的类名称；如果查询失败，它将返回到本地 Spring DM 或蓝图注册表。

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

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

org.apache.camel.builder.ExchangeBuilder

ExchangeBuilder 会公开静态方法 anExchange，您可以使用它来开始构建交换对象。

例如，以下代码会创建一个包含消息正文字符串 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 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

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

可以使用语法 ${PropertyName} 将 Java 系统属性嵌入到位置解析器中。例如，如果 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 中，您可以使用 dedicated 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 中明确指定方案。例如，通过为每个端点 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 swig-5-4 等属性值，例如 < 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 选项，方法是添加表单的子使用，占位符("OptionName", "Key")。

例如，如果属性文件定义了 stop.flag 属性为值 true，您可以使用此属性设置 multicast 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>

如果您将路由部署到红帽 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 bean 初始化。在前面的示例中，cm:property-placeholder bean 与 camel.blueprint 持久 ID 关联，其中持久 ID 是引用 OSGi 配置管理员 服务中一组相关属性的标准方法。换句话说，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，且您需要指定要使用的配置，则这种配置很有用。您还可以通过指定以逗号分隔的位置列表，从多个位置的源属性。例如，如果要从 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 bean 类型 org.apache.camel.spring.spi.BridgePropertyPlaceholderConfigurer 将 Apache Camel 属性占位符机制集成。

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

例如，定义一个 bridge 属性占位符，从 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 接口，代表线程池。使用 concurrency API，您可以创建许多不同类型的线程池，覆盖各种场景。

Apache Camel 线程池 API 通过为 Apache Camel 应用程序中的所有线程池提供中央工厂( org.apache.camel.spi.ExecutorServiceManager 类型)。以这种方式创建线程池提供了几个优点，包括：

有些 Apache Camel 组件 swig-wagon （如 SEDA、JMS 和 Jetty）都包括在多线程中。这些组件已使用 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 （） 子类别、Java DSL 或 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 注册线程池，则处理器会尝试在 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 传递给 executorService Ref （） 选项，而不是直接将对象引用传给 executorService （） 选项，而是在 registry 中查找线程池，如下所示：

// 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 元素创建自定义池配置集（您可以在其中让 defaultProfile 选项默认为 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>

某些标准的基于 poll 的组件都基于 poll-wagon，如 File 和 FTP swig-wagonallow，您可以指定要使用的线程池。这使得不同的组件可以共享同一线程池，从而减少 JVM 中线程的整体数量。

例如，Apache Camel 组件参考指南 中的 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 提供了一组功能来支持 安全关闭 应用程序。安全关闭可让您完全控制停止和启动路由，使您能够控制路由的关闭顺序，并使当前任务运行完成。

最好为每个路由分配一个路由 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)调用 autoStartup 命令。例如，您可以在 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 （） 方法，在 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 元素的 start Order 属性来实现相同的效果，如下所示：

<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 使用可插拔关闭 策略来控制关闭 序列。默认关闭策略实现以下关闭序列：

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

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

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

例如，要安全地关闭 File consumer 端点，您应该指定 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 命令具有以下特性：

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

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 参数。同样，若要成功触发 onCompletion，请使用 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 作为布尔值在 onCompletion 标签上表示：

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

要针对 多个路由定义完成 ：

// 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 设置为 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>>

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 指标。这使得最终用户能够无缝地源 Camel 路由信息及其使用 Codahale 指标收集的现有数据。

要使用 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 >，它指定为路由的策略；例如：

<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.routepolicy.MetricsRegistry 的 com.codahale.metrics.MetricRegistry Service，如下所示：

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

MetricsRoutePolicyFactory 和 MetricsRoutePolicy 支持以下选项：

Apache Camel 允许您通过定义 管理名称模式 来自定义 JMX 中显示的 CamelContext bean 的名称。例如，您可以自定义 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 支持来自书中的大多数模式，Greg or Hohpe 和 Bobby Woolf 的企业集成模式。

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

消息传递通道是用于在消息传递系统中连接参与者的基本组件。表 3.2 “消息传递频道” 中的模式描述了各种可用的消息传递频道。

表 3.3 “消息结构” 中显示的消息构造模式描述了通过系统传递的信息的各种形式和功能。

表 3.4 “消息路由” 中显示的消息路由模式描述了将消息频道链接在一起的各种算法，包括可应用到消息流的各种算法（无需修改消息正文）。

表 3.5 “message Transformation” 中显示的消息转换模式描述了如何修改消息的内容，以满足各种用途。

消息传递端点表示消息传递频道和应用程序之间的联系点。消息传递端点模式（如 表 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

显示在浏览器窗口中。易于调用 REST 服务，使用标准浏览器（或 curl 命令行工具）都不多于标准浏览器（或 curl 命令行工具）是为什么 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 有效地是一个 传真，它为在 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 中的 builder 表达式：

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

基本路径是可选的。如果您愿意，可以（不完美）在每个 verb 子句中指定完整路径：

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 参数的详情，请参考 “动态到”一节。

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

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

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

其中 endRest （） 关键字(Java DSL)是一个必要的标点标记，可让您分隔 verb 子句（当 rest （） 构建器中有多个 verb 子句）。

例如，您可以重构 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 会通过检查 classpath 上的可用组件来自动发现要使用的 HTTP 组件。REST DSL 查找任何 HTTP 组件的默认名称，并使用它找到的第一个名称。如果 classpath 上没有 HTTP 组件，且您没有明确配置 HTTP 传输，则默认的 HTTP 组件为 camel-http。

您可以使用 Java 中的 consumes （） 和 generate （） 选项过滤 HTTP 请求和响应 的内容类型，或者在 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>

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

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

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

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

其中 transform （） 将 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 中启用对象整理，请观察以下点：

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