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.
  // ...
}
}

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

域特定语言(DSL)是设计用于特殊用途的小型语言。DSL 不必以逻辑方式完成，但需要足够的能力来描述在所选域中充分描述问题。通常，DSL 不需要 专用的解析程序、解释器或编译器。DSL 可在现有面向对象的主机语言的顶部 piggyback，提供的 DSL 构造图完全用于在主机语言 API 中进行构造。

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

command01;
command02;
command03;

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

command01().command02().command03()

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

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

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

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

图 1.1. 本地路由规则

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

本地规则始终首先定义消费者端点，使用 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，它由请求消息和回复消息(an InOut MEP)组成。目前，Apache Camel 支持以下 MEP：

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

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

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

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

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

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

路由器 schema并查看 XML DSL DSL-youbelongs 到以下 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 文件中指定的 schema 位置下载路由器模式。相反，Apache Camel 会自动从 camel-spring JAR 文件的根目录获取 schema 副本。这样可确保解析 Spring 文件的 schema 版本始终与当前运行时版本匹配。这很重要，因为 Apache Web 站点上发布的 schema 的最新版本可能不与您当前使用的运行时版本不匹配。

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

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

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

编辑完成后，将改回到默认的 camel-spring.xsd。要查看当前可以下载的 schema 版本，请导航至网页 http://camel.apache.org/schema/spring。

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

端点 URI 识别 端点，它有以下常规形式：

scheme:contextPath[?queryOptions]

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

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

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

http://www.google.com

以下文件 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 是 alternatives。

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

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

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

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

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

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

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

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

某些端点 URI 选项会映射到 Java 枚举常量。例如，Log 组件的 level 选项，该选项可取 enum 值、INFO、WARN、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: 作为前缀，从注册表加载资源文件。

例如，如果myvelocityscriptbean 和 mysimplescriptbean 是注册表中两个 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 提供各种不同组件，允许您将应用程序与各种传输协议和第三方产品集成。例如，一些常用的组件有：文件、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 consumer 端点从 支付 队列拉取消息，并在路由中处理消息：

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

在 Spring XML 中，或等效于 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 命令中）。换句话说，生产者端点接收现有的 Exchange 对象，并将交换的内容发送到指定的端点。

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

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

在 Spring XML 中，或等效于 Spring XML 中：

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

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

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

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

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

其中，出现的 %s 会被您的自定义查询字符串 myGoogleQuery 替换。详情请查看 java.util.Formatter。

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

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

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

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

在 Spring XML 中，或等效于 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 中，或等效于 Spring XML 中：

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

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

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

在 Spring XML 中，或等效于 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 实用程序，更多。管道的基本概念是，一个命令的输出 会附带到下一个命令 的输入 中。路由的自然相似之处在于，从一个处理器的 Out 消息转到下一个处理器的 In 消息。

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

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

图 2.1. 处理器修改 In 消息

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

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

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

图 2.2. 处理器创建内存不足消息

以下路由显示了一个 转换（） 命令，它会创建一个 Out 消息，其消息正文包含字符串 DummyBody ：

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

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

图 2.3 “InOnly Exchange 的 Pipeline 示例” 显示用于 InOnly 交换的处理器管道示例。处理器 A 通过修改 In 消息来运作，而处理器 B 和 C 创建 Out 消息。路由构建器将处理器链接在一起，如下所示。特别是，处理器 B 和 C 以 管道 的形式链接：即，处理器 B 的 Out 消息会在将交换馈送到处理器 C 之前移到 In 消息，然后将处理器 C 的 Out 消息放到制作者端点之前。因此，处理器的输出和输入被加入到持续管道中，如 图 2.3 “InOnly Exchange 的 Pipeline 示例” 所示。

图 2.3. InOnly Exchange 的 Pipeline 示例

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

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

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

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

图 2.4. InOut Exchanges 的管道示例

请注意，为了支持 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:bean:getCreditRating、cxf:bean:processTransaction 对其进行处理。最终的 Web 服务 processTransaction 会生成通过 JETTY 端点发回的响应(Out 消息)。

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

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

In optional Out 交换的管道基本与 图 2.4 “InOut Exchanges 的管道示例” 中的管道相同。InOut 和 In optionalOut 的区别在于，In optional Out Exchange 模式的一个交换被允许将 null Out 消息作为回复。也就是说，如果 In optional Out Exchange，则 null Out 消息被复制到管道中下一节点的 In 消息。相反，在 InOut 交换的情况下，将丢弃一个 null Out 消息，来自当前节点的原始 In 信息将被复制到下一个节点的 In 消息。

标准路由只从单一端点获取输入，使用 Java DSL 中的 (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 nmstate-TIMEOUT，并将传入的交换发送到内部端点 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 的输入，并将其发送到端点 直接：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 虚拟机中运行。

库存事务示例可以重新编写为使用 VM 端点而不是 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 注册表中创建条目的方式取决于底层框架的结束，如普通 Java、Spring、Gusice 或 Blueprint。通常会创建 registry 条目（例如，当您在 Spring XML 文件中实例化 Spring bean 时）。

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

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

OSGi 容器中部署是一项特殊情形。当 Apache Camel 路由部署到 OSGi 容器中时，CamelContext 会自动设置用于解析 bean 实例的 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");

在指定方法时，您可以使用一个简单的非限定类型名称-例如 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");

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

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

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

您也可以将整个标头散列映射作为参数传递。例如，在以下示例中，必须声明第二个方法参数为 type java.util.Map:

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

要将交换绑定到 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>

对于略微效率，您可以将 缓存 选项设置为 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 起的默认设置。

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

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

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

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

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

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

请注意如何将注解与默认惯例混合。除了注入注解的参数外，参数绑定也会自动将交换对象注入 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 调用会返回调用 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");

请注意，虽然这种语法与调用 正常 功能的调用相同，但这种集成利用 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 会设置一个 registry 链。首先，它会在 OSGi 服务注册表中查找指定的类名称；如果此查找失败，它将回退到本地 Spring DM 或蓝图 registry。

使用 Java 代码处理消息时（例如，在类或处理器类中），通常会需要创建新的交换实例。如果您需要创建 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 文件示例” 所示。

# 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 属性文件，您可以使用以下位置字符串：

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

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

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

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

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

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

在开始使用属性占位符前，您必须配置 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 中，您可以使用专用属性 Placholder 元素配置属性组件，如下所示：

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

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

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

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

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

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

默认情况下，占位符解析器在注册表中查找 属性 bean ID 以查找属性组件。您可以根据偏好在端点 URI 中明确指定该方案。例如，通过前缀 properties: 到每个端点 URI，您可以定义以下等同的路由：

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

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

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

您还可以使用 XML DSL 中的属性占位符来设置 DSL 元素的各种属性。在此上下文中，putholder 语法也使用双花括号 {{ 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 属性值：string typePodsViolating- insufficientfor 例如，< jmxAgent registryPort="{{myjmx.port}}" …​>.但是，对于任何其他类型的属性（例如 xs:int 或 xs：布尔值），您必须使用特殊语法 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 命令时，您可以通过添加表单的 subclause 来设置任何 EIP 选项，方法是使用属性占位符的值，即 占位符(选项名称"，"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。 在简单表达式中用占位符，如下所示：

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} 来覆盖属性文件的位置。例如，要替换 bar。使用 com/mycompany/bar.properties 属性文件中的设置来加引号 占位符，您可以按照如下所示定义简单表达式：

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 提供对 camel.blueprint 持久 ID 下定义的所有属性的访问权限。还可以为某些属性指定默认值（使用嵌套的 cm:property 元素）。

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

如果要对 Apache Camel 属性占位符机制找到其属性有更多控制权，您可以定义 属性Placeholder 元素并明确指定解析器位置。

例如，请考虑以下蓝图配置，它与上一示例有所不同，它创建了显式 propertyPlaceholder 实例：

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

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

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

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

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

    </camelContext>

</blueprint>

在上例中，propertyPlaceholder 元素通过将位置设置为 blueprint:myblueprint.placeholder 明确指定要使用的 cm:property-placeholder。也就是说，蓝图： 解析器明确引用 cm:property-placeholder bean 的 ID myblueprint.placeholder。

如果蓝图文件定义了多个 cm:property-placeholder，且您需要指定要使用哪个配置，则这种配置很有用。通过指定以逗号分隔的位置列表，也可以从多个位置提供属性。例如，如果您要从 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 类型的 Spring bean type, org.apache.camel.spring.spi.BridgePropertyPlaceholderConfigurer，将 Apache Camel 属性占位符与 Spring 属性占位符机制集成。

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

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

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

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

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

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

</beans>

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

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

一些 Apache Camel 组件在 multi-threaded 等，如 SEDA、JMS 和 Jetty PACKAGE-storageclassare 本质上是多线程。这些组件均使用 Apache Camel 线程模型和线程池 API 实施。

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

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

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

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

parallelProcessing()
executorService()
executorServiceRef()

@parallelProcessing
@executorServiceRef

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

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

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

@executorServiceRef

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

要为其中一个线程感知处理器创建默认线程池，启用 parallelProcessing 选项，使用 Java DSL 中的 parallelProcessing （） 子使用、在 XML DSL 中的 parallelProcessing 属性或 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 中，您可以自定义默认线程池配置集中的 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 选项来直接为线程识别处理器指定线程池（其中使用了这些选项而不是 并行处理 选项）。您可以使用两种方法来自定义处理器的线程池，如下所示：

当您将 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");

除了直接将 beutorService （）选项直接传递给 executorService （） 选项，您可以查询 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 元素创建一个自定义池配置文件（您可让 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-based 组件的灵活性和敏捷性，如 File 和 FTPTOKEN-timer，允许您指定要使用的线程池。这使得不同的组件可以共享同一线程池，从而降低 JVM 中的线程总数。

例如，Apache Camel 组件参考指南 . 和 Apache Camel 组件 参考指南 中的 Ftp2 包括了 调度的ExecutorService 属性，您可以使用它来指定组件的 ExecutorService 对象。https://access.redhat.com/documentation/en-us/red_hat_fuse/7.10/html-single/apache_camel_component_reference/index#file-component

要使应用日志更易阅读，通常最好自定义线程名称（用于识别日志中的线程）。要自定义线程名称，您可以在 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 中，设置 路由 元素的 id 属性，如下所示：

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

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

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

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

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

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

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

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

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

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

默认情况下，Apache Camel 以非确定顺序启动路由。然而，在某些应用程序中，控制启动顺序非常重要。要控制 Java DSL 中的启动顺序，请使用 start Order （） 命令，该命令取正整数值作为其参数。最低整数值的路由首先启动，后跟连续更高的启动顺序值的路由。

例如，以下示例中的第一个路由通过 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 中，您可以通过设置 路由 元素的 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 会使用可插入的关闭策略来控制 关闭 序列。默认关闭策略实现以下关闭序列：

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

例如，在 例 2.5 “Java DSL 中的启动顺序” 中，要关闭的第一个路由部分是 ID 的路由，第一个 路由部分是要关闭的第二个路由部分，其 ID 为 第二个 路由。本例演示了一个常规规则，在关闭路由时应该观察到路由： 公开外部访问使用者端点的路由应关闭第一个，因为这有助于通过路由图形的其余部分调整消息流。

如果路由在关闭启动时仍然处理消息，关闭策略通常会等待当前活跃的交换完成处理，然后再关闭路由。可以使用 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 命令具有以下特性：

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

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

对于 XML 格式，格式如下：

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

要在失败时触发 Completion，可以使用 onFailureOnly 参数。同样，若要在 success 上触发Completion，请使用 CompleteOnly 参数。

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，inFailureOnly 和 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>

为多个路由定义 Completion ：

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

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

要在某些情况下触发 Completion，请使用 onWhen predicate。当消息正文包含文字 Hello:

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

在Completion 可以在两种模式下运行：

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

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

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

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

可从 Camel 2.14 开始

虽然 Camel 提供了大量现有的指标集成，但为 Camel 路由添加了 Codahale 指标。这使得最终用户能够无缝地将 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 中，您定义一个 & 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.routepolicy.MetricsRegistry 的 com.codahale.metrics.MetricsRegistryService 的 com.codahale.metrics.MetricRegistry Registry。

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 将还原为默认命名策略。

默认情况下，COSC Context 部署在 OSGi 捆绑包中的 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 (REST API for RESTful Web Services)是一个将 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 中的以下构建程序表达式：

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

您要在 XML DSL 中使用类似于以下内容的元素（作为 camelContext的子项）：

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

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

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

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

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

在 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 dynamic 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 动态到参数的更多信息，请参阅 “动态到”一节。

在动词参数中，您可以指定一个 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 结尾的 URL 发送 GET HTTP Request，则 HTTP 响应为 Hello Joe。

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

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

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

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

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

如下为 XML DSL 中：

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

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

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

内容类型在 REST DSL 中的 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>

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

一些 HTTP 服务器实施支持额外的 HTTP 方法，它们不是由 REST DSL 中的标准动词集合提供，get （）、 head （）、put （） 、post （）、 delete （）、 patch （）。要访问其他 HTTP 方法，您可以在 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 对象转换。但是 REST DSL 提供了自动执行此转换的便利。特别是，将 JSON 和 JAXB 与 REST DSL 集成提供以下优点：

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

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

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