Red Hat Summit 红帽全球峰会支持控制台（Console）开发人员开始试用联系人

Camel Spring Boot 用户指南

Red Hat Integration 2023.q2

Camel Spring Boot 用户指南

摘要

本指南介绍了 Camel Spring Boot，并解释了使用 Camel Spring Boot 创建和部署应用程序的各种方法。

前言
复制链接

使开源包含更多

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始：master、slave、黑名单和白名单。由于此项工作十分艰巨，这些更改将在即将推出的几个发行版本中逐步实施。有关更多详情，请参阅我们的首席技术官 Chris Wright 提供的消息。

第 1 章 对 Apache Camel 扩展使用语言支持
复制链接

重要

Apache Camel 的 VS Code 扩展被列为开发支持。有关 开发支持范围的更多信息，请参阅开发支持覆盖范围

Visual Studio Code 语言支持扩展添加了对 Apache Camel for XML DSL 和 Java DSL 代码的语言支持。

1.1. 关于 Apache Camel 扩展的语言支持
复制链接

此扩展直接在 Visual Studio Code 编辑器中为 Apache Camel URI 元素提供完成、验证和文档功能。它使用 Microsoft 语言服务器协议（与 Camel Language Server 通信）作为客户端，以提供所有功能。

1.2. Apache Camel 扩展的语言支持特性
复制链接

下面列出了语言支持扩展的重要特性：

  • Apache Camel URI 的语言服务支持。
  • 当您将光标悬停在 Camel 组件上时，快速参考文档。
  • Camel URI 的诊断。
  • Java 和 XML langauges 的导航。
  • 使用 Camel JBang 创建通过 Yaml DSL 指定的 Camel 路由。

1.3. 要求
复制链接

在使用 Apache Camel Language Server 时，必须考虑以下点：

  • 目前，需要 Java 11 才能启动 Apache Camel 语言服务器。java.home VS Code 选项用于使用与机器上安装的默认 JDK 不同的 JDK 版本。
  • 对于某些功能，必须在系统命令行中提供 JBang。

  • 对于 XML DSL 文件：

  • 对于 Java DSL 文件：

    • 使用 .java 文件扩展。
    • 指定 Camel 软件包（通常是从导入的软件包），例如 导入 org.apache.camel.builder.RouteBuilder。
    • 要引用 Camel 组件，请使用 from 或 to 字符串，没有空格。字符串不能是一个变量。例如， from ("timer:timerName") 可以正常工作，但来自(timer:timerName")和 (aVariable) 无法正常工作。

1.4. 安装 Apache Camel 扩展的语言支持
复制链接

您可以从 VS Code 扩展 Marketplace 和 Open VSX Registry 下载对 Apache Camel 扩展的语言支持。您还可以直接在 Microsoft VS Code 中安装 Apache Camel 扩展的语言支持。

流程

  1. 打开 VS Code 编辑器。
  2. 在 VS Code 编辑器中，选择 View > Extensions。
  3. 在搜索栏中，键入 Camel。从搜索结果中选择 Apache Camel 选项的语言支持，然后点 Install。

这会在您的编辑器中打开语言支持扩展。

其他资源

重要

Apache Camel 的 VS Code 扩展被列为开发支持。有关 开发支持范围的更多信息，请参阅开发支持覆盖范围

这是 Visual Studio Code 扩展，它通过附加到使用 Java、Yaml 或 XML DSL 编写的正在运行的 Camel 路由来添加 Camel Debugger 电源。

2.1. Debug Adapter 的功能
复制链接

Apache Camel 扩展的 VS Code Debug Adapter 支持以下功能：

  • 仅限 XML 的 Camel Main 模式。
  • 通过将 Camel 调试器附加到使用 Java、Yaml 或 XML 使用 JMX url 编写的正在运行的 Camel 路由，使用 Camel 调试器。
  • 通过将 Camel 调试器的本地使用附加到使用 Java、Yaml 或 XML 使用 PID 编写的正在运行的 Camel 路由。
  • 您可以将它用于单个 Camel 上下文。
  • 添加或删除断点。
  • 使用简单语言的条件断点。
  • 检查暂停断点上的变量值。
  • 恢复单个路由实例并恢复所有路由实例。
  • 路由定义在同一文件中时步骤。
  • 在消息正文中，允许更新范围 Debugger 中的变量，在类型为 String 的消息标头中，以及类型为 String 的交换属性

  • 支持使用 JBang 和 Debug 运行 Camel 应用。

    • 此命令允许在简单情况下一键点击 start 和 Camel debug。这个命令通过以下方式提供：

      • 命令站。它需要在当前编辑器中打开有效的 Camel 文件。
      • File explorer 中的上下文菜单。它对所有 Ice xml、Chef java、Tro elelyaml 和 slirp yml 可见。
      • Codelens 位于 Camel 文件的顶部（代码的 Heuristic），即检查是否有 from 和 a to 或 a log on java、xml 和 yaml 文件。

  • 支持使用 JBang 运行 Camel 应用程序。

    • 它需要在 Yaml DSL (.yaml|.yml)中定义的有效 Camel 文件。
  • Camel debugger 启动配置配置片段
  • 配置片段用于启动 Camel 应用程序，以使用 JBang 接受 Camel 调试器连接，或者带有 Camel maven 插件的 Maven

2.2. 要求
复制链接

将 VS Code Debug Adapter 用于 Apache Camel 扩展时，必须考虑以下点：

  • 必须安装带有 com.sun.tools.attach.VirtualMachine 的 Java Runtime Environment 11 或更高版本（大多数 JVM 中可用，如 Hotspot 和 OpenJDK）。

  • 要调试的 Camel 实例必须满足以下要求：

    • Camel 3.16 或更高版本
    • 在 classpath 上具有 camel-debug。
    • 启用 JMX。
注意

对于某些功能，系统命令行上必须有 JBang。

2.3. 为 Apache Camel 安装 VS Code Debug Adapter
复制链接

您可以从 VS Code Extension Marketplace 和 Open VSX Registry 下载 Apache Camel 扩展的 VS Code Debug Adapter。您还可以直接在 Microsoft VS Code 中安装 Apache Camel 扩展的 Debug Adapter。

流程

  1. 打开 VS Code 编辑器。
  2. 在 VS Code 编辑器中，选择 View > Extensions。
  3. 在搜索栏中，键入 Camel Debug。从搜索结果中选择 Debug Adapter for Apache Camel 选项，然后点 Install。

这会在 VS Code 编辑器中安装 Apache Camel 的 Debug Adapter。

2.4. 使用 Debug Adapter
复制链接

以下流程解释了如何使用 debug 适配器调试 camel 应用程序。

流程

  1. 确保系统命令行上有 jbang 二进制文件。
  2. 打开可通过 Camel JBang 启动的 Camel 路由。
  3. 使用 Ctrl + Shift + P 键调用 命令，然后选择 Run Camel Application with JBang and Debug 命令，或者点在文件顶部出现 JBang 的代码lens Camel Debug。
  4. 等待路由启动并且调试器已连接。
  5. 在 Camel 路由上放置断点。
  6. Debug。

其他资源

第 3 章 使用 Camel JBang
复制链接

Camel Jbang 是一个基于 JBang 的 Camel 应用程序，用于运行 Camel 路由。

3.1. 安装 Camel JBang
复制链接

先决条件

  1. JBang 必须安装到您的机器上。请参阅有关如何下载并安装 JBang 的说明。

安装 JBang 后，您可以从命令 shell 中执行以下命令来验证 JBang 是否正常工作： 

jbang version
Copy to Clipboard Toggle word wrap

这将输出已安装的 JBang 版本。

流程

  1. 运行以下命令来安装 Camel JBang 应用程序： 
jbang app install camel@apache/camel
Copy to Clipboard Toggle word wrap

这会在 JBang 中将 Apache Camel 作为 camel 命令安装。这意味着，您可以通过执行 camel 命令从命令行运行 Camel。

3.2. 使用 Camel JBang
复制链接

Camel JBang 支持多个命令。camel help 命令显示所有可用的命令。 

camel --help
Copy to Clipboard Toggle word wrap
注意

您第一次运行此命令时，可能会导致缓存依赖项，因此需要几秒钟才能运行。如果您已使用 JBang，并且您收到 线程 "main" java.lang.NoClassDefFoundError: "org/apache/camel/dsl/jbang/core/commands/CamelJBangMain" 中的 异常等错误，请尝试清除 JBang 缓存并重新安装。

所有命令都支持 --help，如果提供了该标志，则会显示适当的帮助。

3.2.1. 启用 shell 完成
复制链接

Camel JBang 为 bash 和 zsh out 提供 shell 完成功能。要为 Camel JBang 启用 shell 完成，请运行： 

source <(camel completion)
Copy to Clipboard Toggle word wrap

要使它永久生效，请运行： 

echo 'source <(camel completion)' >> ~/.bashrc
Copy to Clipboard Toggle word wrap

3.3. 创建并运行 Camel 路由
复制链接

您可以使用 init 命令创建新的基本路由。例如，要创建 XML 路由，请运行以下命令： 

camel init cheese.xml
Copy to Clipboard Toggle word wrap

这会创建带示例路由的 cheese.xml 文件（在当前目录中）。

要运行该文件，请运行： 

camel run cheese.xml
Copy to Clipboard Toggle word wrap
注意

您可以在 Camel 中创建并运行任何受支持的 DSL，如 YAML、XML、Java、Groovy。

要创建新的 .java 路由，请运行： 

camel init foo.java
Copy to Clipboard Toggle word wrap

当您使用 init 命令时，Camel 默认会在当前目录中创建该文件。但是，您可以使用 --directory 选项在指定的目录中创建文件。例如，要在名为 foobar 的文件夹中创建，请运行： 

camel init foo.java --directory=foobar
Copy to Clipboard Toggle word wrap
注意

当您使用 --directory 选项时，如果已存在，Camel 会自动清理此目录。

3.3.1. 从多个文件运行路由
复制链接

您可以从多个文件运行路由，例如运行两个 YAML 文件： 

camel run one.yaml two.yaml
Copy to Clipboard Toggle word wrap

您可以从两个不同文件（如 yaml 和 Java）运行路由： 

camel run one.yaml hello.java
Copy to Clipboard Toggle word wrap

您可以使用通配符(i.e. 114)来匹配多个文件，如运行所有 yaml 文件： 

camel run *.yaml
Copy to Clipboard Toggle word wrap

您可以运行以 foo the 开头的所有文件： 

camel run foo*
Copy to Clipboard Toggle word wrap

要运行目录中的所有文件，请使用： 

camel run *
Copy to Clipboard Toggle word wrap
注意

运行 目标也可以检测属于 属性 的文件，如 application.properties。

3.3.2. 从输入参数运行路由
复制链接

对于非常小的 Java 路由，可以将路由作为 CLI 参数提供，如下所示： 

camel run --code='from("kamelet:beer-source").to("log:beer")'
Copy to Clipboard Toggle word wrap

这非常有限，因为 CLI 参数比文件更繁琐。当您从输入参数运行路由时，请记住：

  • 仅支持 Java DSL 代码。
  • 代码用单引号括起来，因此您可以在 Java DSL 中使用双引号。
  • 代码仅限于可从终端和 JBang 提供的字面值。
  • 所有路由都必须在单一 --code 参数中定义。
注意

使用 --code 仅适用于非常快速和小的站。

3.3.3. 带有实时重新加载的 dev 模式
复制链接

您可以使用 --dev 选项启用源文件更新（保存）时与路由实时重新载入相关的 dev 模式，如下所示： 

camel run foo.yaml --dev
Copy to Clipboard Toggle word wrap

然后，在 Camel 集成运行时，您可以更新 YAML 路由并在保存时更新。这个选项适用于所有 DLS，包括 java，例如： 

camel run hello.java --dev
Copy to Clipboard Toggle word wrap
注意

live reload 选项仅用于开发目的，如果您遇到重新加载类加载问题（如 JVM 类加载问题）存在问题，您可能需要重启集成。

3.3.4. 开发人员控制台
复制链接

您可以启用开发人员控制台，它为开发人员提供各种信息。要启用开发人员控制台，请运行： 

camel run hello.java --console
Copy to Clipboard Toggle word wrap

然后可从位于 http://localhost:8080/q/dev 的网页浏览器访问控制台（默认为 ）。当 Camel 启动时，也会在日志中显示该链接。

控制台可让您深入了解正在运行的 Camel 集成，如报告需要最长时间来处理消息的顶级路由。然后您可以识别这些路由中最慢的独立 EIP。

开发人员控制台还可以以 JSON 格式输出数据，供第三方工具用来捕获信息。例如，要通过 curl 输出顶级路由，请运行： 

curl -s -H "Accept: application/json"  http://0.0.0.0:8080/q/dev/top/
Copy to Clipboard Toggle word wrap

如果您安装了 jq，可以格式化并输出 JSON 数据，请运行： 

curl -s -H "Accept: application/json"  http://0.0.0.0:8080/q/dev/top/ | jq
Copy to Clipboard Toggle word wrap

3.3.5. 使用配置集
复制链接

Camel JBang 中的配置文件是一个名称(id)，它引用使用 Camel JBang 自动载入的配置。default 配置集被命名为应用程序，它是一个 （默认）来让 Camel JBang 自动加载 application.properties （如果存在）。这意味着您可以创建与同名的特定属性文件匹配的配置集。

例如，使用名为 local 的配置集运行意味着 Camel JBang 将加载 local.properties 而不是 application.properties。要使用配置集，请指定命令行选项 --profile，如下所示： 

camel run hello.java --profile=local
Copy to Clipboard Toggle word wrap

您一次只能指定一个配置集名称，例如 --profile=local,two 无效。

在 属性文件中，您可以配置 Camel Main 中的所有配置。要关闭并启用日志掩码，请运行以下命令： 

camel.main.streamCaching=false
camel.main.logMask=true
Copy to Clipboard Toggle word wrap

您还可以配置 Camel 组件，如 camel-kafka，以声明代理的 URL： 

camel.component.kafka.brokers=broker1:9092,broker2:9092,broker3:9092
Copy to Clipboard Toggle word wrap
注意

以 camel.jbang 开头的键是 Camel JBang 内部使用的键，并允许 Camel JBang 命令的预配置参数。

3.3.6. 通过互联网下载 JAR
复制链接

默认情况下，Camel JBang 会自动解决运行 Camel 所需的依赖项，这由 JBang 和 Camel 分别完成。如果组件需要 JARs，则 Camel 本身会在 classpath 上不可用，然后可以自动下载 JAR。

Camel 按以下顺序下载这些 JAR：

  1. 来自 ~/.m2/repository中的本地磁盘
  2. 从 Maven Central 中的互联网
  3. 在自定义第三方 Maven 存储库中从互联网中
  4. 来自 ~/.m2/settings.xml 活跃配置集中找到的所有软件仓库，或使用 --maven-settings 选项指定的设置文件。

如果您不希望 Camel JBang 访问互联网下载，您可以使用 --download 选项关闭，如下所示： 

camel run foo.java --download=false
Copy to Clipboard Toggle word wrap

3.3.7. 添加自定义 JAR
复制链接

Camel JBang 会自动检测其自身发行版本的 Camel 组件、语言和数据格式的依赖项。这意味着不需要指定要使用的 JAR。但是，如果您需要添加第三方自定义 JAR，您可以使用 --deps 作为 Maven GAV 语法(groupId:artifactId:version)中的 CLI 参数指定，例如： 

camel run foo.java --deps=com.foo:acme:1.0
Copy to Clipboard Toggle word wrap 
To add a Camel dependency explicitly you can use a shorthand syntax (starting with `camel:` or `camel-`):
Copy to Clipboard Toggle word wrap 
camel run foo.java --deps=camel-saxon
Copy to Clipboard Toggle word wrap

您可以用逗号指定多个依赖项： 

camel run foo.java --deps=camel-saxon,com.foo:acme:1.0
Copy to Clipboard Toggle word wrap

3.3.8. 使用第三方 Maven 存储库
复制链接

Camel JBang 首先从本地存储库下载，然后从在线 Maven Central 存储库下载。要从第三方 Maven 存储库下载，您必须将这指定为 CLI 参数，或者在 application.properties 文件中指定。 

camel run foo.java --repos=https://packages.atlassian.com/maven-external
Copy to Clipboard Toggle word wrap
注意

您可以指定多个以逗号分开的存储库。

第三方 Maven 存储库的配置在 application.properties 文件中配置，键为 camel.jbang.repos，如下所示： 

camel.jbang.repos=https://packages.atlassian.com/maven-external
Copy to Clipboard Toggle word wrap

当您运行 Camel 路由时，application.properties 会自动载入： 

camel run foo.java
Copy to Clipboard Toggle word wrap

您还可以明确指定要使用的属性文件： 

camel run foo.java application.properties
Copy to Clipboard Toggle word wrap

或者您可以将它指定为配置集： 

camel run foo.java --profile=application
Copy to Clipboard Toggle word wrap

其中配置文件 id 是属性文件的名称。

3.3.9. 配置 Maven 用法
复制链接

默认情况下，加载现有的 ~/.m2/settings.xml 文件，因此可以更改 Maven 解析过程的行为。Maven 设置文件提供有关 Maven 镜像、凭证配置（早期加密）或活动配置集和其他存储库的信息。

Maven 存储库可以使用 authentication 和 Maven-way 来配置凭证通过 < server> 元素： 

<server>
    <id>external-repository</id>
    <username>camel</username>
    <password>{SSVqy/PexxQHvubrWhdguYuG7HnTvHlaNr6g3dJn7nk=}</password>
</server>
Copy to Clipboard Toggle word wrap

虽然可以使用纯文本来指定密码，但建议首先配置 maven master 密码，然后使用它配置存储库密码： 

$ mvn -emp
Master password: camel
{hqXUuec2RowH8dA8vdqkF6jn4NU9ybOsDjuTmWvYj4U=}
Copy to Clipboard Toggle word wrap

以上密码必须添加到 ~/.m2/settings-security.xml 文件中，如下所示： 

<settingsSecurity>
  <master>{hqXUuec2RowH8dA8vdqkF6jn4NU9ybOsDjuTmWvYj4U=}</master>
</settingsSecurity>
Copy to Clipboard Toggle word wrap

然后您可以配置普通密码： 

$ mvn -ep
Password: camel
{SSVqy/PexxQHvubrWhdguYuG7HnTvHlaNr6g3dJn7nk=}
Copy to Clipboard Toggle word wrap

然后，您可以在 < server>/<password> 配置中使用 这个密码。

默认情况下，Maven 从 ~/.m2/settings-security.xml 文件中读取 master 密码，但您可以覆盖它。可以指定 settings.xml 文件的位置，如下所示： 

camel run foo.java --maven-settings=/path/to/settings.xml --maven-settings-security=/path/to/settings-security.xml
Copy to Clipboard Toggle word wrap

如果要在不假设任何位置的情况下运行 Camel 应用程序（即使 ~/.m2/settings.xml），请使用这个选项： 

camel run foo.java --maven-settings=false
Copy to Clipboard Toggle word wrap

3.3.10. 运行托管在 GitHub 上的路由
复制链接

您可以使用 Camels 资源加载程序运行托管在 GitHub 上的路由。例如，要运行其中一个 Camel K 示例，请使用： 

camel run github:apache:camel-kamelets-examples:jbang/hello-java/Hey.java
Copy to Clipboard Toggle word wrap

您还可以将 https URL 用于 GitHub。例如，您可以从 web-browser 浏览示例，然后从浏览器窗口中复制 URL，并使用 Camel JBang 运行示例： 

camel run https://github.com/apache/camel-kamelets-examples/tree/main/jbang/hello-java
Copy to Clipboard Toggle word wrap

您还可以使用通配符（即 \114 ）匹配多个文件，如运行所有 groovy 文件： 

camel run https://github.com/apache/camel-kamelets-examples/tree/main/jbang/languages/*.groovy
Copy to Clipboard Toggle word wrap

或者，您可以运行以 rou the 开头的所有文件： 

camel run https://github.com/apache/camel-kamelets-examples/tree/main/jbang/languages/rou*
Copy to Clipboard Toggle word wrap
3.3.10.1. 从 GitHub gists 运行路由
复制链接

使用 GitHub 中的 gists 是一种快速共享可运行的小型 Camel 路由的方法。例如，要运行 gist，请使用： 

camel run https://gist.github.com/davsclaus/477ddff5cdeb1ae03619aa544ce47e92
Copy to Clipboard Toggle word wrap

gist 可以包含一个或多个文件，Camel JBang 将收集所有相关文件，因此 gist 可以包含多个路由、属性文件和 Java Bean。

3.3.11. 下载托管在 GitHub 上的路由
复制链接

您可以使用 Camel JBang 将现有示例从 GitHub 下载到本地磁盘，这样可修改示例并在本地运行。例如，您可以运行以下命令来下载 依赖项注入 示例： 

camel init https://github.com/apache/camel-kamelets-examples/tree/main/jbang/dependency-injection
Copy to Clipboard Toggle word wrap

然后，文件（而不是子文件夹）被下载到当前目录中。然后您可以使用以下方法在本地运行示例： 

camel run *
Copy to Clipboard Toggle word wrap

您还可以使用 --directory 选项将文件下载到新文件夹中，例如将文件下载到名为 myproject 的文件夹，请运行： 

camel init https://github.com/apache/camel-kamelets-examples/tree/main/jbang/dependency-injection --directory=myproject
Copy to Clipboard Toggle word wrap
注意

使用 --directory 选项时，如果已存在，Camel 将自动清理此目录。

您可以在 dev 模式下运行示例，以在源代码更改时热部署。 

camel run * --dev
Copy to Clipboard Toggle word wrap

您可以下载单个文件，例如下载其中一个 Camel K 示例，请运行： 

camel init https://github.com/apache/camel-k-examples/blob/main/generic-examples/languages/simple.groovy
Copy to Clipboard Toggle word wrap

这是一个 groovy 路由，您可以使用该路由运行（或使用 groovy 路由）： 

camel run simple.groovy
Copy to Clipboard Toggle word wrap
3.3.11.1. 下载路由表单 GitHub gists
复制链接

您可以从 gists 下载文件，如下所示： 

camel init https://gist.github.com/davsclaus/477ddff5cdeb1ae03619aa544ce47e92
Copy to Clipboard Toggle word wrap

这会将文件下载到本地磁盘，稍后您可以运行： 

camel run *
Copy to Clipboard Toggle word wrap

您可以使用 --directory 选项下载至新文件夹，例如，要下载至名为 foobar 的文件夹，请运行： 

camel init https://gist.github.com/davsclaus/477ddff5cdeb1ae03619aa544ce47e92 --directory=foobar
Copy to Clipboard Toggle word wrap
注意

使用 --directory 选项时，如果已存在，Camel 会自动清理此目录。

3.3.12. 使用特定的 Camel 版本
复制链接

您可以指定要运行的 Camel 版本，如下所示： 

jbang run -Dcamel.jbang.version=3.20.1 camel@apache/camel [command]
Copy to Clipboard Toggle word wrap
注意

旧版本的 Camel 可能也不适用于 Camel JBang 作为最新版本。建议使用从 Camel 3.18 开始的版本。

您还可以使用 SNAPSHOT 尝试对边缘开发，例如： 

jbang run --fresh -Dcamel.jbang.version=3.20.1-SNAPSHOT camel@apache/camel [command]
Copy to Clipboard Toggle word wrap

3.3.13. 运行 Camel K 集成或绑定
复制链接

Camel 支持运行名为 joke.yaml 的 kamelet 绑定文件，它们采用 CRD 格式(Kubernetes 自定义资源定义)。例如，运行名为 joke.yaml 的 kamelet 绑定文件： 

#!/usr/bin/env jbang camel@apache/camel run
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: joke
spec:
  source:
    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1
      name: chuck-norris-source
    properties:
      period: 2000
  sink:
    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1
      name: log-sink
    properties:
      show-headers: false
Copy to Clipboard Toggle word wrap 
camel run joke.yaml
Copy to Clipboard Toggle word wrap

3.3.14. 从剪贴板运行
复制链接

您可以直接从 OS 剪贴板运行 Camel 路由。这允许复制一些代码，然后快速运行路由。 

camel run clipboard.<extension>
Copy to Clipboard Toggle word wrap

其中 <extension> 是剪贴板的内容类型，如 java、xml 或 yaml。

例如，您可以将它复制到剪贴板中，然后运行路由： 

<route>
  <from uri="timer:foo"/>
  <log message="Hello World"/>
</route>
Copy to Clipboard Toggle word wrap 
camel run clipboard.xml
Copy to Clipboard Toggle word wrap

3.3.15. 控制本地 Camel 集成
复制链接

要列出当前运行的 Camel 集成，请使用 ps 选项： 

camel ps
  PID   NAME                          READY  STATUS    AGE
 61818  sample.camel.MyCamelApplica…   1/1   Running  26m38s
 62506  test1                          1/1   Running   4m34s
Copy to Clipboard Toggle word wrap

这将列出 PID、集成的名称和年龄。

您可以使用 stop 命令停止任何正在运行的 Camel 集成。例如，要停止 test1，请运行： 

camel stop test1
Stopping running Camel integration (pid: 62506)
Copy to Clipboard Toggle word wrap

您可以使用 PID 停止集成： 

camel stop 62506
Stopping running Camel integration (pid: 62506)
Copy to Clipboard Toggle word wrap
注意

您不必键入全名，因为 stop 命令将与以输入开头的集成匹配，例如，您可以键入 camel stop t 来停止以 t 开头的所有集成。

要停止所有集成，请使用 --all 选项，如下所示： 

camel stop --all
Stopping running Camel integration (pid: 61818)
Stopping running Camel integration (pid: 62506)
Copy to Clipboard Toggle word wrap

3.3.16. 控制 Spring Boot 和 Quarkus 集成
复制链接

默认情况下，Camel JBang CLI 只控制使用 CLI 运行的 Camel 集成，例如 camel run foo.java。

要使 CLI 能够控制和管理 Spring Boot 或 Quarkus 应用程序，您需要为这些项目添加依赖项，以便与 Camel CLI 集成。

Spring Boot

在 Spring Boot 应用程序中，添加以下依赖项： 

<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-cli-connector-starter</artifactId>
</dependency>
Copy to Clipboard Toggle word wrap

Quarkus

在 Quarkus 应用程序中，添加以下依赖项： 

<dependency>
    <groupId>org.apache.camel.quarkus</groupId>
    <artifactId>camel-quarkus-cli-connector</artifactId>
</dependency>
Copy to Clipboard Toggle word wrap

3.3.17. 获取 Camel 集成的状态
复制链接

Camel JBang 中的 get 命令用于获取一个或多个正在运行的 Camel 集成的特定状态。要显示正在运行的 Camel 集成的状态，请运行： 

camel get
  PID   NAME      CAMEL            PLATFORM            READY  STATUS    AGE    TOTAL  FAILED  INFLIGHT  SINCE-LAST
 61818  MyCamel   3.20.1-SNAPSHOT  Spring Boot v2.7.3   1/1   Running  28m34s    854       0         0     0s/0s/-
 63051  test1     3.20.1-SNAPSHOT  JBang                1/1   Running     18s     14       0         0     0s/0s/-
 63068  mygroovy  3.20.1-SNAPSHOT  JBang                1/1   Running      5s      2       0         0     0s/0s/-
Copy to Clipboard Toggle word wrap

camel get 命令显示默认集成，它等同于输入 camel get integrations 或 camel get int 命令。

这将显示每个 Camel 集成的整体信息，您可以在其中查看处理的消息总数。列 Since Last 显示三个阶段的最后处理消息前的时间(started/completed/failed)。

0s/0s/- 表示最后一次启动和完成的消息仅发生(0 秒前)，并且还没有失败消息。在本例中，9s/9s/1h3m 表示最后一次启动并完成的消息为 9 秒，最后失败为 1 小时，3 分钟前。

您还可以查看来自所有本地 Camel 与 camel get 路由 集成的每个路由的状态： 

camel get route
  PID   NAME      ID      FROM                        STATUS    AGE   TOTAL  FAILED  INFLIGHT  MEAN  MIN  MAX  SINCE-LAST
 61818  MyCamel   hello   timer://hello?period=2000   Running  29m2s    870       0         0     0    0   14     0s/0s/-
 63051  test1      java    timer://java?period=1000    Running    46s     46       0         0     0    0    9     0s/0s/-
 63068  mygroovy  groovy  timer://groovy?period=1000  Running    34s     34       0         0     0    0    5     0s/0s/-
Copy to Clipboard Toggle word wrap
注意

使用 camel get --help 显示所有可用的命令。

3.3.17.1. Camel 集成的主要状态
复制链接

camel top 命令用于获取正在运行的 Camel 集成的主要利用率统计（最高到最低堆使用内存）。 

camel top
  PID   NAME     JAVA     CAMEL            PLATFORM            STATUS    AGE         HEAP        NON-HEAP     GC     THREADS   CLASSES
 22104  chuck    11.0.13  3.20.1-SNAPSHOT  JBang               Running   2m10s  131/322/4294 MB  70/73 MB  17ms (6)      7/8  7456/7456
 14242  MyCamel  11.0.13  3.20.1-SNAPSHOT  Spring Boot v2.7.3  Running  33m40s  115/332/4294 MB  62/66 MB  37ms (6)    16/16  8428/8428
 22116  bar      11.0.13  3.20.1-SNAPSHOT  JBang               Running    2m7s   33/268/4294 MB  54/58 MB  20ms (4)      7/8  6104/6104
Copy to Clipboard Toggle word wrap

HEAP 列显示堆内存（使用/提交/最大）和非堆（使用/提交）。GC 列显示垃圾回收信息（时间和总运行）。CLASSES 列显示类数(loaded/total)。

您还可以从所有本地 Camel 与 camel 顶级路由集成中看到每个路由的最大执行路由（最高到最低的代表处理时间 ）： 

camel top route
  PID   NAME     ID                     FROM                                 STATUS    AGE    TOTAL  FAILED  INFLIGHT  MEAN  MIN  MAX  SINCE-LAST
 22104  chuck    chuck-norris-source-1  timer://chuck?period=10000           Started     10s      1       0         0   163  163  163          9s
 22116  bar      route1                 timer://yaml2?period=1000            Started      7s      7       0         0     1    0   11          0s
 22104  chuck    chuck                  kamelet://chuck-norris-source        Started     10s      1       0         0     0    0    0          9s
 22104  chuck    log-sink-2             kamelet://source?routeId=log-sink-2  Started     10s      1       0         0     0    0    0          9s
 14242  MyCamel  hello                  timer://hello?period=2000            Started  31m41s    948       0         0     0    0    4          0s
Copy to Clipboard Toggle word wrap
注意

使用 camel top --help 显示所有可用的命令。

3.3.17.2. 启动和停止路由
复制链接

camel cmd 用于在运行的 Camel 集成中执行其它命令，例如启动和停止路由的命令。

要停止 chuck 集成中的所有路由，请运行： 

camel cmd stop-route chuck
Copy to Clipboard Toggle word wrap

然后，对于 chuck 集成，状态将更改为 Stopped ： 

camel get route
  PID   NAME     ID                     FROM                                 STATUS    AGE   TOTAL  FAILED  INFLIGHT  MEAN  MIN  MAX  SINCE-LAST
 81663  chuck    chuck                  kamelet://chuck-norris-source        Stopped           600       0         0     0    0    1          4s
 81663  chuck    chuck-norris-source-1  timer://chuck?period=10000           Stopped           600       0         0    65   52  290          4s
 81663  chuck    log-sink-2             kamelet://source?routeId=log-sink-2  Stopped           600       0         0     0    0    1          4s
 83415  bar      route1                 timer://yaml2?period=1000            Started  5m30s    329       0         0     0    0   10          0s
 83695  MyCamel  hello                  timer://hello?period=2000            Started  3m52s    116       0         0     0    0    9          1s
Copy to Clipboard Toggle word wrap

要启动路由，请运行： 

camel cmd start-route chuck
Copy to Clipboard Toggle word wrap

要停止每个 Camel 集成中的所有路由，请使用 -- all 标志，如下所示： 

camel cmd stop-route --all
Copy to Clipboard Toggle word wrap

要启动 所有路由，请使用： 

camel cmd start-route --all
Copy to Clipboard Toggle word wrap
注意

您可以使用逗号（例如 camel cmd start-route --id=route1,hello ）分隔它们来停止一个或多个路由。如需了解更多详细信息，使用 camel cmd start-route --help 命令。

3.3.17.3. 配置日志记录级别
复制链接

您可以通过以下方法查看正在运行的 Camel 集成的当前日志记录级别： 

camel cmd logger
  PID   NAME   AGE   LOGGER  LEVEL
 90857  bar   2m48s  root    INFO
 91103  foo     20s  root    INFO
Copy to Clipboard Toggle word wrap

日志级别可在运行时更改。例如，要将 foo 的级别改为 DEBUG，请运行： 

camel cmd logger --level=DEBUG foo
Copy to Clipboard Toggle word wrap
注意

您可以使用 --all 来更改所有正在运行的集成的日志级别。

3.3.17.4. 列出服务
复制链接

有些 Camel 集成可能会托管客户端可以调用的服务，如 REST 或 SOAP-WS，或使用 TCP 协议套接字级服务。您可以列出可用服务，如下例所示： 

camel get service
 PID   NAME       COMPONENT      PROTOCOL  SERVICE
 1912  netty      netty          tcp       tcp:localhost:4444
 2023  greetings  platform-http  rest      http://0.0.0.0:7777/camel/greetings/{name} (GET)
 2023  greetings  platform-http  http      http://0.0.0.0:7777/q/dev
Copy to Clipboard Toggle word wrap

在这里，您可以看到两个 Camel 集成。netty 集成托管一个 TCP 服务，可在端口 4444 上可用。其他 Camel 集成托管 REST 服务，只能通过 GET 调用。第三个集成附带嵌入式 Web 控制台（通过 --console 选项开始）。

注意

要使服务列出 Camel 组件必须能够使用 Camel Console 公告服务。

3.3.17.5. 列出 Circuit Breakers 的状态
复制链接

如果您的 Camel 集成使用 link:https://camel.apache.org/components/3.20.x/eips/circuitBreaker-eip.html [Circuit Breaker]，您可以使用 Camel JBang 输出 breakers 的状态，如下所示： 

camel get circuit-breaker
  PID   NAME  COMPONENT     ROUTE   ID               STATE      PENDING  SUCCESS  FAIL  REJECT
 56033  mycb  resilience4j  route1  circuitBreaker1  HALF_OPEN        5        2     3       0
Copy to Clipboard Toggle word wrap

在这里，我们可以看到断路器处于 半打开 状态，如果失败开始丢弃，则上游社区试图过渡到关闭的状态。

注意

您可以使用 watch 选项运行命令来显示最新的状态，例如 watch camel getbreaker getbreaker。

3.3.18. 使用 Jolokia 和 Hawtio
复制链接

Web 控制台允许检查运行 Camel 集成，如所有 JMX 管理信息，而不是至少视觉化使用实时性能指标的 Camel 路由。

要允许 Hawtio 检查 Camel 集成，必须在正在运行的集成中安装 Jolokia JVM 代理。这是明确完成的，如下所示： 

camel ps
  PID   NAME                          READY  STATUS    AGE
 61818  sample.camel.MyCamelApplica…   1/1   Running  26m38s
 62506  test1.java                      1/1   Running   4m34s
Copy to Clipboard Toggle word wrap

使用 PID，您可以附加 Jolokia： 

camel jolokia 62506
Started Jolokia for PID 62506
http://127.0.0.1:8778/jolokia/
Copy to Clipboard Toggle word wrap

您也可以使用名称模式附加 PID，而不必使用 PID。在这个示例中，两个 Camel 集成具有唯一的名称(foo 和 test1)，您可以在没有 PID 的情况下附加 Jolokia，如下所示： 

camel jolokia te
Started Jolokia for PID 62506
http://127.0.0.1:8778/jolokia/
Copy to Clipboard Toggle word wrap

然后，您可以使用 Camel JBang 启动 Hawtio： 

camel hawtio
Copy to Clipboard Toggle word wrap

这将自动下载并启动 Hawtio，然后在 Web 浏览器中打开。

注意

如需了解更多选项，请参阅 camel hawtio --help。

在 Web 浏览器中启动 Hawtio 时，单击 Discover 选项卡，该选项卡将列出所有本地可用的 Jolokia Agent。您可以使用 camel jolokia PID 连接到多个不同的 Camel 集成，从此列表中选择要加载哪些。

单击绿色 lightning 图标，以连接到特定正在运行的 Camel 集成。

如果不再需要，您可以在正在运行的 Camel 集成中卸载 Jolokia JVM 代理： 

camel jolokia 62506 --stop
Stopped Jolokia for PID 62506
Copy to Clipboard Toggle word wrap

也可以使用一个命令达到此目的，如下所示： 

camel hawtio test1
Copy to Clipboard Toggle word wrap

其中 test1 是正在运行的 Camel 集成的名称。当您停止 Hawtio （使用 ctrl + c），然后 Camel 将尝试卸载 Jolokia JVM 代理，但这不会成功，因为 JVM 会被终止，从而防止 camel-jbang 执行 JVM 进程与正在运行的 Camel 集成通信。

3.3.19. 使用管道在终端中脚本
复制链接

您可以执行 Camel JBang 文件作为脚本，该脚本用于带有管道和过滤器的终端脚本。

注意

每次执行 JVM 时，每次使用 Camel 启动脚本时。这在内存用量上不是非常快或低的，因此请使用 Camel JBang 终端脚本，例如，使用许多 Camel 组件或 Kamelets 来更轻松地从不同的 IT 系统发送或接收数据。

这需要在文件顶部添加以下行，例如在以下的 upper.yaml 文件中： 

///usr/bin/env jbang --quiet camel@apache/camel pipe "$0" "$@" ; exit $?

# Will upper-case the input
- from:
    uri: "stream:in"
    steps:
      - setBody:
          simple: "${body.toUpperCase()}"
      - to: "stream:out"
Copy to Clipboard Toggle word wrap

要作为脚本执行此操作，您需要设置执行权限： 

chmod +x upper.yaml
Copy to Clipboard Toggle word wrap

然后，您可以作为脚本执行它： 

echo "Hello\nWorld" | ./upper.yaml
Copy to Clipboard Toggle word wrap

这个输出： 

HELLO
WORLD
Copy to Clipboard Toggle word wrap

您可以使用 --logging=true 打开日志记录，然后记录到 .camel-jbang/camel-pipe.log 文件。无法配置日志记录文件的名称。 

echo "Hello\nWorld" | ./upper.yaml --logging=true
Copy to Clipboard Toggle word wrap
3.3.19.1. 使用带有行和原始模式的 stream:in
复制链接

当使用 stream:in 从 System 读取数据时，流组件 以两种模式工作：

  • 行模式（默认）- 以单行形式读取输入（按换行符分隔）。消息正文 是一个字符串。
  • 原始模式 - 读取整个流，直到 流结束。消息正文是 byte[]。
注意

默认模式是过去的创建流组件的创建方式。因此，您可能想要将 stream:in?readline=false 设置为使用原始模式。

3.3.20. 运行本地 Kamelets
复制链接

您可以使用 Camel JBang 尝试本地 Kamelets，而无需在 GitHub 上发布它们，或者将它们打包到 jar 中。 

camel run --local-kamelet-dir=/path/to/local/kamelets earthquake.yaml
Copy to Clipboard Toggle word wrap
注意

当 kamelets 来自本地文件系统时，可以在 --dev 模式下运行 Camel JBang 时实时重新加载它们。

您还可以指向 GitHub 存储库中的文件夹。例如： 

camel run --local-kamelet-dir=https://github.com/apache/camel-kamelets-examples/tree/main/custom-kamelets user.java
Copy to Clipboard Toggle word wrap
注意

如果从 GitHub 加载 kamelet，则无法实时重新加载。

3.3.21. 使用 platform-http 组件
复制链接

当从 platform-http 启动路由时，Camel JBang 会自动包含运行在端口 8080 上的 VertX HTTP 服务器。以下示例显示了名为 server.yaml 文件中的路由： 

- from:
    uri: "platform-http:/hello"
    steps:
      - set-body:
          constant: "Hello World"
Copy to Clipboard Toggle word wrap

您可以使用以下方法运行这个示例： 

camel run server.yaml
Copy to Clipboard Toggle word wrap

然后使用以下方法调用 HTTP 服务： 

$ curl http://localhost:8080/hello
Hello World%
Copy to Clipboard Toggle word wrap

3.3.22. 使用 Java Bean 和处理器
复制链接

支持将常规 Java 源文件与 Camel 路由一起包含，并让 Camel JBang 运行时编译 Java 源。这意味着您可以包括较小的实用程序类、POJO、Camel Processors。

注意

Java 源文件无法使用软件包名称。

3.3.23. Java 类中的依赖关系注入
复制链接

在运行 Camel 与 camel-jbang 时，运行时基于 camel-main。这意味着没有 Spring Boot，或 Quarkus 可用。但是，支持在 Java 类中使用基于注解的依赖项注入。

3.3.23.1. 使用 Spring Boot 依赖项注入
复制链接

您可以使用以下 Spring Boot 注解：

  • @org.springframework.stereotype.Component 或 @org.springframework.stereotype.Service 在类级别上创建类实例并在 Registry 中注册。
  • @org.springframework.beans.factory.annotation.Autowired 以依赖项注入类字段上的 bean。@org.springframework.beans.factory.annotation.Qualifier 可以用来指定 bean id。
  • @org.springframework.beans.factory.annotation.Value 来注入 属性占位符。例如，如 application.properties 中定义的属性。
  • @org.springframework.context.annotation.Bean 关于通过调用方法创建 bean 的方法。

3.3.24. 调试
复制链接

有两种类型的调试：

  • Java 调试 - Java 代码调试（标准 Java）
  • Camel 路由调试 - 调试 Camel 路由（需要 Camel 工具插件）
3.3.24.1. Java 调试
复制链接

您可以使用 JBang 提供的 --debug 标志调试集成脚本。但是，要在启动 JVM 时启用 Java 调试，请使用 jbang 命令，而不是 camel，如下所示： 

jbang --debug  camel@apache/camel run hello.yaml
Listening for transport dt_socket at address: 4004
Copy to Clipboard Toggle word wrap

您可以看到默认监听端口为 4004，但可以进行配置，如 JBang 调试 中所述。

这是一个标准的 Java 调试套接字。然后，您可以使用您选择的 IDE。您可以添加处理器以在路由执行过程中放置断点命中（而不是路由定义创建）。

3.3.24.2. Camel 路由调试
复制链接

Camel 路由调试器默认可用( camel-debug 组件会自动添加到 classpath 中)。默认情况下，它可以通过 URL 服务通过 JMX 访问：jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi/camel。然后，您可以使用您选择的集成开发环境(IDE)。

3.3.25. 健康检查
复制链接

使用 CLI 的 Camel JBang 访问健康检查的状态，如下所示： 

camel get health
  PID   NAME    AGE  ID             RL  STATE  RATE    SINCE   MESSAGE
 61005  mybind   8s  camel/context   R   UP    2/2/-  1s/3s/-
Copy to Clipboard Toggle word wrap

您可以在此处看到 Camel 是 UP。应用程序正在运行 8 秒，并且调用了两个健康检查。

输出显示了 默认 检查级别，如下所示：

  • CamelContext 健康检查
  • 特定于组件的健康检查（如 camel-kafka 或 camel-aws​）
  • 自定义健康检查
  • 任何不是 UP的检查

RATE 列显示由 / 分隔的三个数字。因此，2/2/- 表示 2 个总检查，2 个成功且没有失败。当健康检查更改状态时，最后两列将重置，因为这个数字是成功或失败的连续检查的数量。因此，如果健康检查开始失败，则数字可以是： 

camel get health
  PID   NAME     AGE   ID             RL  STATE   RATE    SINCE    MESSAGE
 61005  mybind   3m2s  camel/context   R   UP    77/-/3  1s/-/17s  some kind of error
Copy to Clipboard Toggle word wrap

在这里，您可以看到数字已更改为 77/-/3。这意味着检查总数为 77。没有成功，但检查在一行中失败 3 次。SINCE 列对应于 RATE。因此，在这种情况下，您可以看到最后的检查为 1 秒，并且检查已针对一行中的 17 秒失败。

您还可以使用 --level=full 输出包含消费者和路由级别检查的每个健康检查。

健康检查通常可能会因为抛出异常而失败，这可使用 --trace 标志显示： 

camel get health --trace
  PID   NAME      AGE   ID                                      RL  STATE    RATE       SINCE     MESSAGE
 61038  mykafka  6m19s  camel/context                            R   UP    187/187/-  1s/6m16s/-
 61038  mykafka  6m19s  camel/kafka-consumer-kafka-not-secure…   R  DOWN   187/-/187  1s/-/6m16s  KafkaConsumer is not ready - Error: Invalid url in bootstrap.servers: value


------------------------------------------------------------------------------------------------------------------------
                                                       STACK-TRACE
------------------------------------------------------------------------------------------------------------------------
    PID: 61038
    NAME: mykafka
    AGE: 6m19s
    CHECK-ID: camel/kafka-consumer-kafka-not-secured-source-1
    STATE: DOWN
    RATE: 187
    SINCE: 6m16s
    METADATA:
        bootstrap.servers = value
        group.id = 7d8117be-41b4-4c81-b4df-cf26b928d38a
        route.id = kafka-not-secured-source-1
        topic = value
    MESSAGE: KafkaConsumer is not ready - Error: Invalid url in bootstrap.servers: value
    org.apache.kafka.common.KafkaException: Failed to construct kafka consumer
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:823)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:664)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:645)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:625)
        at org.apache.camel.component.kafka.DefaultKafkaClientFactory.getConsumer(DefaultKafkaClientFactory.java:34)
        at org.apache.camel.component.kafka.KafkaFetchRecords.createConsumer(KafkaFetchRecords.java:241)
        at org.apache.camel.component.kafka.KafkaFetchRecords.createConsumerTask(KafkaFetchRecords.java:201)
        at org.apache.camel.support.task.ForegroundTask.run(ForegroundTask.java:123)
        at org.apache.camel.component.kafka.KafkaFetchRecords.run(KafkaFetchRecords.java:125)
        at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515)
        at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
        at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
        at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
        at java.base/java.lang.Thread.run(Thread.java:829)
    Caused by: org.apache.kafka.common.config.ConfigException: Invalid url in bootstrap.servers: value
        at org.apache.kafka.clients.ClientUtils.parseAndValidateAddresses(ClientUtils.java:59)
        at org.apache.kafka.clients.ClientUtils.parseAndValidateAddresses(ClientUtils.java:48)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:730)
        ... 13 more
Copy to Clipboard Toggle word wrap

您可以看到健康检查失败，因为 org.apache.kafka.common.config.ConfigException，这是因为因为 bootstrap.servers: value 无效配置无效： Invalid url in bootstrap.servers: value。

注意

使用 camel get health --help 查看所有各种选项。

3.4. 列出哪些 Camel 组件可用
复制链接

Camel 附带很多工件，它们包括：

  • components
  • 数据格式
  • 表达式语言
  • 其它组件
  • kamelets

您可以使用 Camel CLI 列出使用 camel catalog 命令提供的 Camel。例如，列出所有组件： 

camel catalog components
Copy to Clipboard Toggle word wrap

查看哪些 Kamelets 可用： 

camel catalog kamelets
Copy to Clipboard Toggle word wrap
注意

使用 camel catalog --help 查看所有可能的命令。

3.4.1. 显示组件文档
复制链接

文档 目标可以显示每个组件、数据格式和 kamelets 的快速文档。例如，查看 kafka 组件运行： 

camel doc kafka
Copy to Clipboard Toggle word wrap
注意

文档不是网站中显示的完整文档，因为 Camel CLI 无法直接访问此信息，并且只显示组件的基本描述，但包括每个配置选项的表。

查看 jackson 数据格式的文档： 

camel doc jackson
Copy to Clipboard Toggle word wrap

在一些个别情况下，可能会有一个组件和数据格式的名称相同，doc 目标会优先选择组件。在这种情况下，您可以使用 dataformat 为名称添加前缀，例如： 

camel doc dataformat:thrift
Copy to Clipboard Toggle word wrap

您还可以查看 kamelet 文档，如下所示： 

camel doc aws-kinesis-sink
Copy to Clipboard Toggle word wrap
3.4.1.1. 从 Camel 网站浏览在线文档
复制链接

您可以使用 doc 命令在 Web 浏览器中快速打开 url 以获得在线文档。例如，要浏览 kafka 组件，请使用 --open-url ： 

camel doc kafka --open-url
Copy to Clipboard Toggle word wrap

这也适用于数据格式、语言、kamelet。 

camel doc aws-kinesis-sink --open-url
Copy to Clipboard Toggle word wrap
注意

要只获取在线文档的链接，请使用 camel doc kafka --url。

3.4.1.2. 过滤表中列出的选项
复制链接

有些组件可能有许多选项，在这种情况下，您可以使用 --filter 选项列出与名称、描述或组中的过滤器匹配的选项(producer、security、advanced)。

例如，只列出与安全相关的选项： 

camel doc kafka --filter=security
Copy to Clipboard Toggle word wrap

仅列出 超时 内容： 

camel doc kafka --filter=timeout
Copy to Clipboard Toggle word wrap

3.5. Open API
复制链接

Camel JBang 允许 首先使用合同 公开 Open API 服务，在其中已有现有的 OpenAPI 规格文件。Camel JBang 使用命名规则 direct:<operationId > 将每个 API 端点从 OpenAPI 规范桥接到 Camel 路由。这样可以更快地为给定操作实施 Camel 路由。

如需了解更多详细信息，请参阅 OpenAPI 示例。

3.6. 收集依赖项列表
复制链接

使用 Camel JBang 时会自动解析依赖项。这意味着您不必使用 Maven 或 Gradle 等构建系统来添加每个 Camel 组件作为依赖项。

但是，您可能希望了解运行 Camel 集成所需的依赖项。您可以使用 dependencies 命令查看所需的依赖项。命令输出不会输出详细的树，如 mvn dependencies:tree，因为输出旨在列出哪些 Camel 组件和其他所需的 JAR （使用 Kamelets 时）。

默认情况下，依赖项输出是 vanilla Apache Camel，camel-main 作为运行时，如下所示： 

camel dependencies
org.apache.camel:camel-dsl-modeline:3.20.0
org.apache.camel:camel-health:3.20.0
org.apache.camel:camel-kamelet:3.20.0
org.apache.camel:camel-log:3.20.0
org.apache.camel:camel-rest:3.20.0
org.apache.camel:camel-stream:3.20.0
org.apache.camel:camel-timer:3.20.0
org.apache.camel:camel-yaml-dsl:3.20.0
org.apache.camel.kamelets:camel-kamelets-utils:0.9.3
org.apache.camel.kamelets:camel-kamelets:0.9.3
Copy to Clipboard Toggle word wrap

默认情况下，输出是每个 maven 依赖项的行，格式为 GAV 格式(groupId:artifactId:version)。

您可以为输出指定 Maven 格式，如下所示： 

camel dependencies --output=maven
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-main</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-dsl-modeline</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-health</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-kamelet</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-log</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-rest</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-stream</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-timer</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-yaml-dsl</artifactId>
    <version>3.20.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel.kamelets</groupId>
    <artifactId>camel-kamelets-utils</artifactId>
    <version>0.9.3</version>
</dependency>
<dependency>
    <groupId>org.apache.camel.kamelets</groupId>
    <artifactId>camel-kamelets</artifactId>
    <version>0.9.3</version>
</dependency>
Copy to Clipboard Toggle word wrap

您还可以选择目标运行时作为 'quarkus' 或 spring-boot，如下所示： 

camel dependencies --runtime=spring-boot
org.springframework.boot:spring-boot-starter-actuator:2.7.5
org.springframework.boot:spring-boot-starter-web:2.7.5
org.apache.camel.springboot:camel-spring-boot-engine-starter:3.20.0
org.apache.camel.springboot:camel-dsl-modeline-starter:3.20.0
org.apache.camel.springboot:camel-kamelet-starter:3.20.0
org.apache.camel.springboot:camel-log-starter:3.20.0
org.apache.camel.springboot:camel-rest-starter:3.20.0
org.apache.camel.springboot:camel-stream-starter:3.20.0
org.apache.camel.springboot:camel-timer-starter:3.20.0
org.apache.camel.springboot:camel-yaml-dsl-starter:3.20
org.apache.camel.kamelets:camel-kamelets-utils:0.9.3
org.apache.camel.kamelets:camel-kamelets:0.9.3
Copy to Clipboard Toggle word wrap

3.7. 创建项目
复制链接

您可以将 Camel JBang 集成 导出到 传统的基于 Java 的项目，如 Spring Boot 或 Quarkus。您可能希望在使用 Camel JBang 来构建了 kiosk 后执行此操作，并且需要传统的基于 Java 的项目，对 Java 编码的需求，或使用 Spring Boot、Quarkus 或 vanilla Camel Main 的强大运行时。

3.7.1. 导出至 Camel Spring Boot
复制链接

命令将 --runtime=spring-boot 将当前的 Camel JBang 文件导出到 基于 Maven 的 Spring Boot 项目，其中的文件采用 src/main/ 文件夹结构。

例如，要使用 Maven groupId com.foo 和 artifactId acme 以及版本 1.0-SNAPSHOT 导出到 Spring Boot，请运行： 

camel export --runtime=spring-boot --gav=com.foo:acme:1.0-SNAPSHOT
Copy to Clipboard Toggle word wrap
注意

这将导出到 当前目录中，这意味着文件将移到所需的文件夹结构中。

要导出到另一个目录，请运行： 

camel export --runtime=spring-boot --gav=com.foo:acme:1.0-SNAPSHOT --directory=../myproject
Copy to Clipboard Toggle word wrap

当导出到 Spring Boot 时，pom.xml 或 build.gradle 中定义的 Camel 版本与 Camel JBang 使用的版本相同。但是，您可以指定不同的 Camel 版本，如下所示： 

camel export --runtime=spring-boot --gav=com.foo:acme:1.0-SNAPSHOT --directory=../myproject --camel-spring-boot-version=3.20.1.redhat-00064
Copy to Clipboard Toggle word wrap
注意

如需了解更多详细信息，请参阅运行 camel export --help 命令的选项。

3.7.2. 包括使用 Camel CLI 导出
复制链接

当导出到 Spring Boot、Quarkus 或 Camel Main 时，不会包含 Camel JBang CLI。要继续使用 Camel CLI （即 camel），您需要在 --deps 选项中添加 camel:cli-connector，如下所示： 

camel export --runtime=quarkus --gav=com.foo:acme:1.0-SNAPSHOT --deps=camel:cli-connector --directory=../myproject
Copy to Clipboard Toggle word wrap

3.7.3. 配置导出
复制链接

export 命令默认从 application.properties 文件加载配置，该文件用于导出特定参数，如选择运行时和 java 版本。

可在 application.properties 文件中配置与 导出 相关的以下选项：

Expand
选项Description

camel.jbang.runtime

运行时(spring-boot、quarkus 或 camel-main)

camel.jbang.gav

Maven 组：artifact:version

camel.jbang.dependencies

其他依赖项（使用逗号分隔多个依赖项）。请参阅 添加自定义 JAR 的更多信息。

camel.jbang.classpathFiles

要添加到 classpath 的额外文件（使用逗号分隔多个文件）。请参阅 添加自定义 JAR 的更多信息。

camel.jbang.javaVersion

Java 版本(11 或 17)

camel.jbang.kameletsVersion

Apache Camel Kamelets 版本

camel.jbang.localKameletDir

用于载入 Kamelets 的本地目录

camel.jbang.camelSpringBootVersion

用于 Spring Boot 的 Camel 版本

camel.jbang.springBootVersion

Spring Boot 版本

camel.jbang.quarkusGroupId

Quarkus Platform Maven groupId

camel.jbang.quarkusArtifactId

Quarkus Platform Maven artifactId

camel.jbang.quarkusVersion

Quarkus Platform 版本

camel.jbang.mavenWrapper

在导出的项目中包括 Maven Wrapper 文件

camel.jbang.gradleWrapper

在导出的项目中包括 Gradle Wrapper 文件

camel.jbang.buildTool

要使用的构建工具(maven 或 gradle)

camel.jbang.repos

用于按需下载的额外 maven 软件仓库（使用逗号分隔多个存储库）

camel.jbang.mavenSettings

maven setting.xml 文件的可选位置，以配置服务器、存储库、镜像和代理。如果设置为 false，而不是使用默认的 ~/.m2/settings.xml。

camel.jbang.mavenSettingsSecurity

maven settings-security.xml 文件的可选位置来解密 settings.xml

camel.jbang.exportDir

导出项目的目录。

camel.jbang.platform-http.port

运行独立 Camel 时使用的 HTTP 服务器端口，如启用 --console 时（默认为端口 8080）。

camel.jbang.console

运行独立 Camel 时，位于本地 HTTP 服务器上的 /q/dev 的开发人员控制台（默认端口 8080 ）。

camel.jbang.health

在运行独立 Camel 时，在本地 HTTP 服务器的 /q/health （默认端口 8080）进行健康检查。

注意

这些是 export 命令中的选项。您可以使用 camel export --help 查看更多详情和默认值。

3.8. 故障排除
复制链接

使用 JBang 时，它会将状态存储在 ~/.jbang 目录中。这也是 JBang 存储下载的 JAR 的位置。Camel JBang 也在运行时下载所需的依赖项。但是，这些依赖项下载到本地 Maven 存储库 ~/.m2。因此，当您在运行 Camel JBang 时对问题（如过时的 JAR）进行故障排除时，请尝试删除这些目录或部分目录。

第 4 章 在 Spring XML 中使用 Camel
复制链接

Spring XML

将 Camel 与 Spring XML 文件一起使用，是一种在 Camel 中使用 XML DSL 的方法。Camel 过去使用 Spring XML 长时间。Spring 框架以 XML 文件开始，作为构建 Spring 应用程序的常见配置。

Spring 应用程序示例

<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd
       http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
    ">

    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="direct:a"/>
            <choice>
                <when>
                    <xpath>$foo = 'bar'</xpath>
                    <to uri="direct:b"/>
                </when>
                <when>
                    <xpath>$foo = 'cheese'</xpath>
                    <to uri="direct:c"/>
                </when>
                <otherwise>
                    <to uri="direct:d"/>
                </otherwise>
            </choice>
        </route>
    </camelContext>

</beans>

== Specifying Camel routes using Spring XML

You can use Spring XML files to specify Camel routes using XML DSL as shown:

[source,xml]
Copy to Clipboard Toggle word wrap

<CamelContext id="camel-A" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="seda:start"/> <to uri="mock:result"/> </route> </camelContext> 

== Configuring Components and Endpoints

You can configure your Component or Endpoint instances in your Spring XML as follows in this example.

[source,xml]
Copy to Clipboard Toggle word wrap

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

<bean id="jmsConnectionFactory" class="org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory"> <property name="brokerURL" value="tcp:someserver:61616"/> </bean> <bean id="jms" class="org.apache.camel.component.jms.JmsComponent"> <property name="connectionFactory"> <bean class="org.apache.activemq.artemis.jms.client.ActiveMQCFactory"> <property name="brokerURL" value="tcp:someserver:61616"/> </bean> </property> </bean> 

This allows you to configure a component using any name, but its common to use the same name, for example, `jms`. Then you can refer to the component using `jms:destinationName`.

This works by the Camel fetching components from the Spring context for the scheme name you use for Endpoint URIs.

== Using Java DSL with Spring XML files

You can use Java Code to define your RouteBuilder implementations. These are defined as beans in spring and then referenced in your camel context, as shown:

[source,xml]
Copy to Clipboard Toggle word wrap

<CamelContext xmlns="http://camel.apache.org/schema/spring"> <routeBuilder ref="myBuilder"/> </camelContext>

<bean id="myBuilder" class="org.apache.camel.spring.example.test1.MyRouteBuilder"/> 

== Using package scanning

Camel also provides a powerful feature that allows for the automatic discovery and initialization of routes in given packages. This is configured by adding tags to the camel context in your spring context definition, specifying the packages to be recursively searched for `RouteBuilder` implementations. To use this feature add a <package></package> tag specifying a comma separated list of packages that should be searched. For example,

[source,xml]
Copy to Clipboard Toggle word wrap

<CamelContext> <packageScan> <package>com.foo</package& <excludes> gt; .Excluded</excludes> <includes& gt; 114</includes> </packageScan> </camelContext> 

This scans for RouteBuilder classes in the `com.foo` and the sub-packages.

You can also filter the classes with includes or excludes such as:

[source,xml]
Copy to Clipboard Toggle word wrap

<CamelContext> <packageScan> <package>com.foo</package <excludes> ></excludes> the </packageScan> </camelContext> 

This skips the classes that has Special in the name. Exclude patterns are applied before the include patterns. If no include or exclude patterns are defined then all the Route classes discovered in the packages are returned.

`?` matches one character, `\*` matches zero or more characters, `**` matches zero or more segments of a fully qualified name.

== Using context scanning

You can allow Camel to scan the container context, for example, the Spring `ApplicationContext` for route builder instances. This allows you to use the Spring `<component-scan>` feature and have Camel pickup any RouteBuilder instances which was created by Spring in its scan process.

[source,xml]
Copy to Clipboard Toggle word wrap

<!-- 启用 Spring @Component scan -→ <context:component-scan base-package="org.apache.camel.spring.issues.contextscan"/>

<CamelContext xmlns="http://camel.apache.org/schema/spring"> <!--，然后让 Camel 使用这些 @Component Scan route builders -→ <contextScan/> </camelContext> 

This allows you to just annotate your routes using the Spring `@Component` and have those routes included by Camel:

[source,java]
Copy to Clipboard Toggle word wrap

@component public class MyRoute 扩展 RouteBuilder { 

    @Override
    public void configure() throws Exception {
        from("direct:start")
            .to("mock:result");
    }
}
Copy to Clipboard Toggle word wrap 
You can also use the ANT style for inclusion and exclusion, as mentioned above in the package scan section.

:leveloffset!:
Copy to Clipboard Toggle word wrap

法律通告
复制链接

Copyright © 2023 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
返回顶部
Red Hat logoGithubredditYoutubeTwitter

学习

尝试、购买和销售

社区

关于红帽文档

通过我们的产品和服务，以及可以信赖的内容，帮助红帽用户创新并实现他们的目标。 了解我们当前的更新.

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情，请参阅红帽博客.

關於紅帽

我们提供强化的解决方案，使企业能够更轻松地跨平台和环境（从核心数据中心到网络边缘）工作。

Theme

© 2025 Red Hat