工具用户指南

Red Hat Fuse 7.8

工具用户指南

Red Hat Fuse Documentation Team

法律通告

摘要

本指南介绍了如何使用红帽 Fuse 工具，它提供了开发人员工具，旨在在设计、开发、测试和调试集成应用程序时提高生产力。

前言

红帽 Fuse 工具是基于 Eclipse 的 IDE，简化了在红帽 CodeReady Studio 中开发集成应用程序的过程。Fuse Tooling 提供了一组开发人员工具，专门设计用于：

Red Hat Fuse
Red Hat JBoss EAP
Apache Camel
Apache CXF
Apache Karaf
Spring Boot

本指南提供有关如何使用 Fuse 工具来的信息：

为您的应用程序创建一个项目，包括 Maven 依赖项
连接并配置企业集成模式以构建路由
浏览端点和路由
将消息拖放到正在运行的路由中
通过 JMX 浏览和视觉化运行时进程
在本地运行的 Camel 上下文和路由进行调试
通过以下方法测试应用程序：
- 在 Apache Camel 路由中创建并使用 JUnit 测试问题单
- 使用 JMX 分析正在运行的组件
- 通过 Apache Camel 路由追踪消息
部署应用程序

对于新用户，Tooling Tutorials 提供了如何创建、调试、测试和部署示例 Camel 应用程序的逐步说明。

部分 I. 开发应用程序

第 1 章创建新的 Fuse 集成项目

概述

创建新的 Fuse 集成项目涉及以下主要步骤：

指定项目名称和工作区
配置项目部署环境
选择项目模板
如有必要，解析 Maven 依赖项错误

配置项目后，工具会下载所有必需的 Maven 依赖项，并创建运行和发布项目所需的 POM 文件。

注意

首次在 CodeReady Studio 中构建 Fuse 项目时，向导可能需要几分钟时间来完成在从远程 Maven 存储库下载依赖项时生成项目。

开始前

在创建新 Fuse 集成项目前，您应该有以下信息：

您的目标运行时环境：OpenShift 上的 Fuse 或 Fuse 独立(Spring Boot、Fuse on Karaf 或 EAP 上的 Fuse)
Camel 版本（如工具使用的默认版本）

指定项目名称和工作区

要创建新的 Fuse 集成项目，请按照以下步骤执行：

选择 New → Project → Red Hat Fuse → Fuse Integration Project 以打开 New Fuse Integration Project 向导。
此时会打开向导，其中包含在 Location 窗格中选择的 Use default workspace location 选项。
在 Project Name 中，为新项目输入一个名称，如 MySampleProject。
指定要存储项目的数据的工作区位置。
- 要使用默认工作区，请保留启用 Use default workspace location 选项。
- 要使用其他位置，请清除 Use default workspace location 选项，并在 Path 字段中指定位置。
  点快速找到并选择一个备用工作区。
点 Next 打开 Select a Target Environment 页面。

配置项目部署环境

在创建新项目时，您可以指定项目的目标部署环境，以便项目在运行时具有它所需的资源。您必须选择一个部署平台和 Camel 版本。另外，您可以指定运行时配置。

选择目标环境页面 打开：

选择是否要在 Kubernetes/OpenShift 上部署项目还是在独立平台上部署。
如果您选择 Kubernetes/OpenShift 作为部署平台，则会自动选择 print Boot 运行时，您可以跳至第 3 步。
如果您为部署平台选择 Standalone ：
1. 选择目标运行时环境：
  - Spring Boot
  - Karaf/Fuse
  - EAP 上的 WildFly/Fuse
2. 对于 Karaf 和 EAP 单机运行时环境，请为运行时配置选择以下选项之一：
  - 接受 None selected 选项（您可以在稍后定义运行时配置）。
  - 从下拉菜单中选择现有运行时配置。
  - 创建新的运行时配置，如 “创建新目标运行时（可选）”一节所述。
在 Select the Camel version for your new project 窗格中，接受与运行时关联的默认 Camel 版本，或更改默认值：
- 从下拉列表中选择 Camel 版本。Fuse 工具支持列出的产品版本。
- 如果要使用非产品版本进行测试（不支持），请输入不同的 Camel 版本。
  您可以点击 Verify 按钮检查工具是否可以访问指定的版本。如果没有，类似以下示例的通知会出现在 Select a Target Runtime 页标头中：
  注意
  创建、配置和保存项目后，您可以更改 Camel 版本。请参阅第 12 章 更改 Camel 版本。
选择运行时环境和作为新 Fuse 集成项目的 Camel 版本后，点 Next 打开向导的 Advanced Project Setup 页面，然后按照 “选择项目模板”一节中的步骤操作。

创建新目标运行时（可选）

对于 Karaf 和 EAP 单机运行时环境，您可以选择从 New Fuse Integration Project 向导创建新的运行时配置。

在向导的 Select a Target Runtime 页面中，点 New 打开 New server runtime environment 页面：
扩展 红帽 JBoss 中间件 文件夹，然后选择红帽 Fuse 运行时环境。
将 Create a new local server 选项保留为不选中状态。当您准备好发布项目时，您可以稍后创建本地服务器（请参阅第 28.1 节 “添加服务器”）。
注意
如果您检查 Create a new local server 选项，新建 Fuse Integration Project 向导将帮助您执行额外的步骤来定义和配置 Fuse 服务器运行时（如第 28.1 节 “添加服务器”所述）。然后，当构建项目时，它还会在 Fuse 集成 视角中将服务器运行时添加到 Servers 视图中。
点 Next 打开服务器的 New Server Runtime Environment 页面：
指定服务器运行时的名称、主目录、执行环境 ：
- 名称 mvapich-busyboxAccept 默认，或为运行时环境输入新名称。
- Home Directory mvapich-DESTINATIONClick Browse 按钮找到并选择服务器运行时的安装目录。
  注意
  如果还没有在机器上安装服务器，点 Download and install runtime 链接安装它，然后按照站点的下载说明安装它。根据站点，您可能需要提供有效的凭证，然后才能继续下载过程。
- Runtime JRE: Execution Environment criu-busyboxAccept the default，或者从下拉列表中选择另一个 JavaSE 版本。
  如果列表中没有显示您想要的版本，点 Environments 按钮并从该列表中选择版本。必须在机器上安装您选择的 JRE 版本。
  注意
  Fuse 7.x 需要 JRE 版本 1.8。
- Runtime JRE: Alternate JRE - 如果您的项目需要不同的 Java 版本，您可以使用这个选项。
点击 Finish 返回到 New Fuse Integration Project 向导的 Select a Target Runtme 页面：
新配置的目标运行时会出现在 Target Runtime 窗格的下拉菜单中，运行时支持的 Camel 版本会出现在 Camel Version 窗格中，灰掉了。
创建 Fuse 集成项目后，可以更改 Camel 版本。请参阅第 12 章 更改 Camel 版本。
点 Next 为项目指定模板，如 “选择项目模板”一节所述。

选择项目模板

Advanced Project Setup 页面提供了一个模板列表，您可以用作新项目的起点。模板基于常见用例，提供示例代码和数据，以便您快速开始。可用模板列表取决于您在上一个页面中选择的运行时环境。选择一个模板来查看其在右侧窗格中的描述。

注意

如果没有看到一个满足您的要求的模板，您可以点 where can more examples to use as templates? link to open an information dialog with an information dialog with a more examples more examples:

要使用这些示例之一：

选择 Cancel 以退出 New Fuse Integration Project 向导。
从列出的 URL 之一克隆存储库。
如第 13 章 导入现有的 Maven 项目 所述，将示例项目导入到 CodeReady Studio。

对于 OpenShift 上的 Fuse，有一个模板演示了如何使用 Spring Boot 在 Spring Boot 中配置 Camel 路由。此模板会创建一个 Fuse 集成项目，需要比 2.18.1.redhat-000012 更新的 Camel 版本。
此模板会创建一个在 OpenShift 服务器上运行的项目，它仅支持 Spring DSL。有关使用此模板的详情，请参考第 7 章 在 OpenShift 中使用 Fuse。
对于 Wildfly 或 Fuse on EAP，有一个模板，它提供了一个示例 Camel 路由，它调用 bean 服务来表示"Hello"。此模板会创建一个在 Red Hat EAP 服务器上运行的项目，它仅支持 Spring DSL。
对于 Karaf 或 Fuse on Karaf，您可以选择模板。您可以创建一个空项目，它根据三个支持的域特定语言(DSL)之一创建一个框架 Camel 上下文路由文件，或者您可以使用预定义的模板，每个项目都基于常见用例。单个模板可能不支持所有 DSL 选项。
注意
对于 Java DSL，工具会生成一个 CamelRoute.java 文件，您可以在工具的 Java 编辑器中进行编辑，但不生成图形图表示。
- Content Based Router categoriesProvides a sample Camel route from a specific location 读取文件，并根据消息内容将它们路由到不同的输出文件夹。
  此模板会创建一个在红帽 Fuse 服务器上运行的项目，它支持所有三个 DSL。
- CXF 代码 first mvapichProvides 一个由 CXF Web 服务调用启动的示例 Camel 路由。
  此模板会创建一个在红帽 Fuse 服务器上运行的项目，它仅支持 Spring 和 Java DSL。
  1. 从列表中选择一个模板。
  2. 点 Finish。
    这些工具开始构建项目，并将其添加到 Project Explorer 视图中。
    如果 Fuse Integration 视角尚未打开，工具会询问您现在是否要切换到它：
  3. 点 Yes 在 Fuse Integration 视角中打开新项目：
    该项目会出现在 Project Explorer 视图中。默认情况下，项目包括 Apache Camel 上下文(XML)文件。
  4. 点 canvas 底部的 Source 选项卡来查看生成的 Camel 上下文文件：

注意

如果要在项目中添加另一个新的 Camel 上下文文件，请参阅第 11 章 创建新 Camel XML 文件。

当您构建使用 CXF 的项目时，您可能希望构建过程在 Java 文件中自动操作来生成 WSDL 文件。为此，请在项目的 .pom 文件中配置 java2ws Maven 插件。请参阅： Apache CXF 开发指南, Maven 工具参考, java2ws。

解决 Maven 依赖项错误

在创建新的 Fuse 集成项目后，您可能会遇到 Maven 依赖项错误。

虽然它可能会在其他时间发生，但通常会在进程完成前取消项目构建时发生。以这种方式中断流程通常会阻止所有项目的依赖项从 Maven 存储库下载，这可能需要一些时间。

您通常可以通过更新 Maven 依赖项来解决这些依赖关系错误，如下所示：

在 Project Explorer 视图中，右键单击 root 项目以打开上下文菜单。
选择 Maven → Update Project。
在 Update Maven Project 向导中：
- 如果向导列表中显示多个要更新的项目，请选择您要更新的项目。
- 点 Force Update of Snapshots/Releases 选项启用它。
点击确定。
在工作台的底部，您可以在 Maven 存储库下载缺少的依赖项时查看进度状态栏。

第 2 章在路由编辑器中编辑路由上下文

The following sections describe how to edit a routing context.

2.1. 在路由中添加模式

路由由一系列连接的模式组成，当它们放置在 Route 容器节点上的 canvas 后，称为节点。完整的路由通常由一个起始端点、处理节点字符串以及一个或多个目标端点组成。

当您将模式添加到 canvas 上的 Route 容器中时，模式会采用表示其节点类型的颜色：

BLULP-wagonRoute 容器，对应于上下文文件中的路由元素，以及其他容器节点，例如当和包含完成其逻辑的其他 EIP 的 EIP 时，这些容器节点则与完成其逻辑的其他 EIPs 相关联
用于输入数据输入路由的 green interaction-mvapichConsumer 端点
orange iwl-mvapichEIPs，路由、转换、进程或控制数据传输路由流
输出数据退出路由的 purple iwl-wagonProducer 端点

流程

在路由中添加模式：

在面板上，找到您要添加到路由的模式。
使用以下方法之一：
- 单击面板中的模式，然后在 canvas 中单击路由容器。
- 将模式拖到目标 Route 容器上并丢弃它。
  或者，您可以在没有传出连接的现有节点上或两个节点之间现有连接中添加模式，以便让工具自动连接所有涉及的连接。
  该工具检查生成的连接是否有效，然后允许或阻止您在目标中添加模式。对于有效的连接，工具的行为会根据目标是节点还是连接的不同：
  - 对于 现有节点，工具会将新节点添加到目标节点的传出端（根据编辑器首选项的设置方式），并在它们之间进行自动连接。
  - 对于 现有连接，工具会在两个连接节点之间插入新节点，并在三个节点之间自动重新连接连接
另外，您可以手动连接两个节点：
1. 在 canvas 上的 Route 容器中，选择源节点以显示其连接器箭头。
2. 将源节点的连接器箭头( )拖到目标节点，并释放鼠标按钮来丢弃连接器。
  注意
  并非所有节点都可以连接。当您尝试将源节点连接到无效的目标节点时，工具会显示附加到鼠标光标的符号，连接器无法坚持到目标节点。
在 Route 容器中添加模式后，您可以将其拖到路由容器内的不同位置，或者将其拖到 canvas 上的另一个路由容器，只要它可以建立有效的连接。您还可以重新定位已连接的现有节点，只要移动可以建立另一个有效的连接。
要查看简短的视频，它演示了如何重新组成端点，请单击此处。
选择 File → Save。这些工具将路由保存在上下文文件中，无论它们是否完成。

新模式会出现在 Route 容器的 canvas 上，并成为所选节点。Properties 视图显示您可以编辑的新节点属性的列表。

更改布局方向

当您将一个节点连接到另一个节点时，工具会根据路由编辑器的布局首选项更新布局。默认值为 Down。

访问路由编辑器的布局首选项：

在 Linux 和 Windows 机器上，选择 Windows → Preferences → Fuse Tooling → Editor → 选择图形编辑器的布局方向。
在 OS X 上，选择 CodeReady Studio → Preferences → Fuse Tooling → Editor → 选择图表编辑器的布局方向。

2.2. 配置模式

概述

大多数模式需要一些明确的配置。例如，端点需要明确输入 URI。

工具的 Properties 视图提供了一个表单，它列出了特定模式支持的所有配置详情。Properties 视图还提供以下方便功能：

验证所有必要属性是否具有值
验证提供的值是否为属性的正确数据类型
具有固定值的属性的下拉列表
使用 Apache Camel Spring 配置中的可用 bean 参考填充的下拉列表

流程

配置模式：

在 canvas 上，选择您要配置的节点。
Properties 视图列出了您要编辑的所有所选节点属性。对于 EIP，Details 选项卡会列出所有模式的属性。对于 Components drawer 中的组件，Details 选项卡列出了常规属性以及需要值的常规属性，高级选项卡则根据功能列出分组的其他属性。
Documentation 选项卡描述了模式及其每个属性。
编辑 Properties 视图中的字段以配置节点。
完成后，通过从菜单栏中选择 File → Save 来保存您的工作。

2.3. 从路由中删除模式

概述

在开发和测试路由时，您可能需要删除一个或多个路由的节点。节点的 garbageIcon 图标使这么简单。当您从 canvas 中删除节点时，也会删除与路由中其他节点的所有连接，并且节点也会从上下文文件中对应的 route 元素中删除。

注意

您还可以通过打开上下文菜单并选择 Remove 来删除节点。

流程

从路由中删除节点：

选择您要删除的节点。
点击其图标。
在被要求确定要删除此元素时，请单击 Yes。

节点及其所有连接都会从 canvas 中删除，节点将从上下文文件中对应的 route 元素中删除。

2.4. 在路由上下文中添加路由

概述

XML 上下文文件中的 camelContext 元素会创建一个路由上下文。camelContext 元素可以包含一个或多个路由，以及 canvas 作为 Route 容器节点显示的每个路由，映射到生成的 camelContext 元素中的 route 元素。

流程

将另一个路由添加到 camelContext:

在 Design 选项卡中，执行以下操作之一：
- 单击面板的"sRouting drawer"中的 Route 模式，然后单击您要放置路由的 canvas。
- 从面板的Routing drawer 拖动 Route 模式，并将它放到 canvas 上。
  Properties 视图显示您可以编辑的新路由属性的列表。
在 Properties 视图中，输入：
- 路由 Id 字段中新路由的 ID （如 Route2）
  注意
  这些工具会自动将 ID 分配给 EIP，并在 canvas 上丢弃的组件模式。您可以将这些自动生成的 ID 替换为您自己的 ID，以区分项目中的路由。
- Description 字段中路由的描述
- 根据需要，任何其他属性的值。必要属性通过星号 advisory 来指示。
在菜单栏中，选择 File → Save 以保存您对路由上下文文件所做的更改。
要在多个路由间切换，请在 Project Explorer 视图中项目 Camel Contexts 文件夹下点击其条目来选择要在 canvas 上显示的路由。
要显示上下文中的所有路由，根据空格，单击 Project Explorer 视图中的上下文文件条目。
要在将路由添加到 canvas 时查看工具生成的代码，请点 Source 选项卡。
注意
您还可以通过将 <route/> 元素添加到 camelContext 元素的现有列表中，在 Source 选项卡中添加路由。

2.5. 删除路由

概述

在某些情况下，您需要从路由上下文中删除整个路由。Route 容器的 garbageIcon 图标使这么简单。当您删除路由时，Route 容器内的所有节点都也会被删除，上下文文件中的对应 route 元素会被删除。

注意

您还可以使用 Route 容器的上下文菜单并选择 Remove 删除路由。

重要

您不能撤销此操作。

流程

删除路由：

如果路由上下文包含多个路由，首先在 Project Explorer 视图中选择您要删除的路由。
在 canvas 中，点 Route 容器的图标。
在被要求确定要删除此元素时，请单击 Yes。

路由已从上下文文件中删除，以及 Project Explorer 视图。

2.6. 添加全局端点、数据格式或 Bean

概述

有些路由依赖于全局端点、全局数据格式或全局 Bean 提供的共享配置。您可以使用路由编辑器的 Configuration 选项卡在项目的路由上下文文件中添加全局元素。

在路由上下文文件中添加全局元素：

在路由编辑器中打开路由上下文文件。
在路由编辑器的底部，单击 Configuration 选项卡以显示全局配置（如果存在）。
单击 Add 以打开 Create a new global element 对话框。
这些选项是：
- endpoint iwl-mvapichsee “添加全局端点”一节。
- 数据格式 iwl-busyboxsee “添加全局数据格式”一节。
- bean waits-INFRAsee “添加全局 bean”一节.

添加全局端点

在 Create a new global element 对话框中，选择 Endpoint 并点 OK 打开 Select component 对话框。
注意
默认情况下，会打开 Select component 对话框，并启用了 Show only palette components 选项。要查看所有可用的组件，请取消选中这个选项。
注意
Grouped by category 选项根据类型对组件进行分组。
在 Select component 对话框中，滚动浏览 Camel 组件列表以查找并选择您要添加到上下文文件的组件，然后在 Id 字段中输入 ID。
在本例中，选择了 JMS 组件，myJMS 是 Id 值。
点 Finish。
现在，您可以根据需要在 Properties 视图中设置属性。
工具自动填充 Id，使用您在 [globalEndptSelect] 中的组件 Id 字段中输入的值。在本例中，Camel 从组件的 schema （本例中为 jms:）构建 uri （必需字段），但您必须指定 destinationName 和 destinationType 以完成组件的 uri。
注意
对于 JMS 组件，目的地类型默认为 队列。在 Destination Name （必需字段）中输入了一个值前，在 Details 页中输入了一个值之前，这个默认值不会出现在 uri 字段中。
要完成组件的 uri，请单击 Advanced。
在 Destination Name 字段中输入目标端点的名称（例如 FOO.BAR）。在 Destination Type 字段中，输入端点目的地的类型（例如，队列、主题、temp:queue 或 temp:topic）。
Properties 视图的 Details 和 Advanced 选项卡提供对可用于配置特定组件的所有属性的访问。
单击 Consumer (advanced) 选项卡。
启用属性 Eager Loading Of Properties 和 Expose Listener Session。
在路由编辑器中，切换到 Source 选项卡，以查看添加到上下文文件（本例中为配置的 JMS 端点）到第一个 route 元素之前的代码。
完成后，通过在菜单栏中选择 File → Save 来保存您的更改。

添加全局数据格式

在 Create a new global element 对话框中，选择 Data Format 并单击 OK 以打开 Create a global Data Format 对话框。
数据格式默认为 avro，这是可用列表顶部的格式。
打开 Data Format 下拉菜单，然后选择您想要的格式，如 xmljson。
在 Id 字段中输入格式的名称，如 myDataFormat）。
点 Finish。
在 Properties 视图中，根据您的项目设置属性值，例如：
在路由编辑器中，点 Source 选项卡查看添加到上下文文件中的工具的代码。在本例中，配置的 xmljson 数据格式在第一个 route 元素之前。
完成后，通过在菜单栏中选择 File → Save 来保存您的更改。

添加全局 bean

全局 Bean 启用路由外 Bean 定义，可以从路由的任意位置引用。当您将 Bean 组件从面板复制到路由时，您可以在 Properties 视图的 Ref 下拉菜单中找到定义的全局 Bean。选择您要引用 Bean 组件的全局 bean。

添加全局 bean 元素：

在 Create a new global element 窗口中，选择 Bean 并点 OK 打开 Bean Definition 对话框。
在 Id 字段中输入全局 bean 的 ID，如 TransformBean。该 ID 在配置中必须是唯一的。
识别 bean 类或工厂 bean。
要指定 factory bean，您必须已经添加了指定了 factory 类的另一个全局 bean。然后，您可以选择该全局 bean 将其声明为全局 bean 工厂。bean 工厂类的一个实例将在运行时中。其他全局 Bean 可以调用该类上的工厂方法，以创建自己的其他类实例。
要填写 Class 字段，请执行以下操作之一：
- 在项目或引用的项目中输入类的名称。
- 点 … 进入并选择一个项目或引用项目中的类。
- 单击 + 以定义一个新的 bean 类，并将它添加为全局 bean。
如果您要添加的 bean 需要一个或多个参数，在 Constructor Arguments 部分中，每个参数：
1. 点击 Add。
2. （可选）在 Type 字段中输入参数的类型。默认值为 java.lang.String。
3. 在 Value 字段中，输入参数的值。
4. 点击确定。
（可选）指定全局 bean 访问的一个或多个属性。在 Bean Properties 部分中，对每个属性执行以下操作：
1. 点击 Add。
2. 在 Name 字段中输入属性的名称。
3. 在 Value 字段中输入属性的值。
4. 点击确定。
点 Finish 将全局 bean 添加到配置中。您指定的全局 bean ID 会出现在 Configuration 选项卡中，例如：
切换到 Source 选项卡，以查看添加到上下文文件中的工具的 bean 元素。例如：
点 Configuration 选项卡返回到全局元素列表，并选择全局 bean 在 Properties 视图中显示其标准属性，例如：
注意
要查看或编辑添加全局 Bean 时指定的属性，请在 Configuration 选项卡中选择 bean，然后点 Edit。
根据需要设置全局 bean 属性：
- dependent-on 是一个字符串，可用于识别必须在这个全局 Bean 之前创建的 bean。指定依赖于 bean 的 ID （名称）。例如，如果您要添加 TransformBean，并将 Depends-on 设置为 ChangeCaseBean，则必须创建 ChangeCaseBean，然后可以创建 TransformBean。当 Bean 被销毁时 ，首先销毁 Bean。
- factory-method 仅在全局 bean 是工厂类时才有用。在这种情况下，指定或选择在引用 bean 时调用的静态工厂方法。
- 范围是 单例 或 原型。默认 单例 表明 Camel 每次调用 bean 时使用相同的 bean 实例。当您希望 Camel 在每次调用 bean 时创建 Bean 的新实例时，指定 原型。
- init -method 允许您指定或选择在引用 bean 时调用 bean 的 init （） 方法。
- destroy-method 可让您指定或选择 bean 的 destory 方法在完成由 bean 执行的处理时要调用哪些。
完成后，通过在菜单栏中选择 File → Save 来保存您的更改。

删除全局元素

无论删除之前添加到路由上下文中的端点、数据格式或 bean，这个过程都相同。

注意

您不能执行撤销操作来删除全局元素。如果您意外删除要在配置中保留的全局元素，您可能可以通过关闭上下文文件来撤销删除，而无需保存它。如果这不可行，则重新添加无意删除的全局元素。

在 Configuration 选项卡中，选择您要删除的全局元素。
例如，假设您要删除添加到 “添加全局数据格式”一节中的数据格式 myDataFormat ：
点击 Delete。
全局元素 myDataFormat 从 Configuration 选项卡中 消失。
切换到 Source 选项卡，以检查工具是否从路由上下文中删除了 XML 代码。
完成后，通过在菜单栏中选择 File → Save 来保存您的更改。

编辑全局元素

无论修改端点的属性、数据格式还是添加到路由上下文中的 bean 属性，这个过程都是一样的。

通常，您不想更改全局元素的 ID。如果全局元素已在正在运行的路由中使用，更改 ID 可能会破坏对全局元素的引用。

在 Configuration 选项卡中，选择您要编辑的全局元素。
例如，要编辑添加到 “添加全局端点”一节中的端点 myJMS，请选择它：
点 Edit。
在 Properties 视图中，根据需要修改元素的属性。
例如，打开 Advanced → Consumer 选项卡，并将 Concurrent Consumers 的值改为 2 ：
在路由编辑器中，点 Source 选项卡，检查工具已将属性 concurrentConsumers=2 添加到路由上下文中：
完成后，通过在菜单栏中选择 File → Save 来保存您的更改。

2.7. 配置路由编辑器

概述

使用 Fuse preference 设置，您可以为路由编辑器的行为和用户界面指定选项：

企业级集成模式(EIP)中表达式的默认语言。
创建路由时，设计上模式流的方向（右侧或下线）
Design canvas 是否在后台显示网格覆盖。
在设计上标记节点的方法。

流程

配置路由编辑器：

打开 Editor 首选项窗口：
- 在 Linux 和 Windows 机器上，选择 Windows → Preferences → Fuse Tooling → Editor。
- 在 OS X 中，选择 CodeReady Studio → Preferences → Fuse Tooling → Editor。
要在 Enterprise Integration Pattern (EIP)组件中选择您要用于表达式的默认语言，请从下拉列表中选择语言。默认值为 Simple。
要指定您希望路由编辑器与路由中的模式保持一致的指示，请选择 Down 或 Right。默认值为 Down。
要在 canvas 的背景上启用或禁用显示网格覆盖，请选中在 Routes Editor 中显示图表网格 旁边的框。默认是启用的。
要在路由编辑器的 Design 选项卡中使用组件 ID 作为标签启用或禁用，请选中 使用组件标签的 ID 值 旁边的框。默认值为。
如果您检查这个选项，并同时为组件指定了首选标签（请参阅第 6 步），则该组件的首选标签用于该组件，而不是 ID 值。
在路由编辑器的 Design 选项卡中使用参数作为组件的标签（端点除外，如 File 节点）：
1. 在 Preferred labels 部分中，点 Add。此时会打开 New Preferred Label 对话框。
2. 选择一个组件，然后选择 用作组件标签的参数。
3. 点击确定。组件和参数对列在 Editor Preferences 窗口中。
  
  您可以选择 编辑和删除 组件标签。
  注意
  如果您检查了 组件标签选项的 Use ID 值，它适用于所有组件，但 Preferred labels 部分中列出的组件除外。
点 Apply and Close 将更改应用到 Editor 首选项并关闭 Preferences 窗口。

注意

您可以通过返回 Editor 首选项对话框并点 Restore Defaults 来恢复路由编辑器的原始默认值。

第 3 章查看和编辑 Rest DSL 组件

Apache Camel 支持多种定义 REST 服务的方法。特别是，Apache Camel 提供 REST DSL （域特定语言），它是一个简单但强大的 API，可以在任何 REST 组件上分层，并提供与 OpenAPI 2.0 规范的集成。OpenAPI （以前为 Swagger）是 API 服务的厂商中立且可移植的开放描述格式。

有关使用 Camel Rest DSL 的详情，请参考 Apache Camel 开发指南中的 "定义 REST 服务"一章。

借助 Fuse 工具，您可以查看和编辑 Camel 上下文文件中的 Rest DSL 组件。

您还可以配置 Fuse 集成项目，将 REST API 公开给 OpenAPI 客户端，如下所述： https://access.redhat.com/articles/4296981。

3.1. 查看 Rest DSL 组件的图形表示

以图形模式查看 Camel 上下文文件中的 REST DSL 组件：

在路由编辑器中打开 Camel Context 文件。
单击 REST 选项卡，以查看 Rest DSL 组件。
REST Configuration 部分显示这些配置选项：
- 用于 REST 传输 的组件 criu-wagon Camel 组件。
- 上下文路径 criu-osgi 是 REST 服务的前导上下文路径。您可以将此选项用于组件，如 Servlet，其中使用 context-path 部署 Web 应用。
- 公开 REST 服务的端口号。
- 为 JSON 或 XML 格式消息的绑定模式 mvapich-MAPPINGThe 绑定模式。可能的值有： off （默认值）、auto、json、xml 或 json_xml。
- 主机 mvapich- iwl 是用于公开 REST 服务的主机名。
单击 REST 元素，在 REST Operations 部分中查看其关联的操作（例如 GET、POST、PUT 和 DELETE）。
点 REST 元素或 REST 操作，在 Properties 视图中查看其属性。

3.2. 在图形视图中编辑 Rest DSL 组件

您可以在 REST 选项卡中的项目的 Camel Context 文件中添加、编辑或删除 REST 元素。

添加新 REST 元素：
1. 在 REST 元素 部分中，单击 + 按钮。REST 元素添加到 REST 元素 列表中。
2. 在 Properties 视图中，编辑 REST 元素属性。
在 REST 元素中添加 REST 操作：
1. 在 REST 元素 列表中，选择一个 REST 元素。
2. 在 REST 操作 部分中，单击 + 按钮。
  
  此时会打开 Add REST Operation 对话框。
3. 指定 ID、URI 和 操作类型。（可选）选择 引用的 Route ID。
4. 点 Finish。新操作显示在所选 REST 元素的 REST 操作列表中。
要编辑 REST 元素或操作，请在 REST 选项卡中选择它，然后在 Properties 选项卡中编辑其属性值。
要删除所选的 REST 元素或操作，请单击 x 按钮。

3.3. 查看和编辑 Rest DSL 源代码

您还可以在 Source 选项卡中查看和编辑 Rest DSL 组件：

在路由编辑器中打开 Camel Context 文件。
单击路由编辑器的 Source 选项卡，然后编辑代码。
（可选）点击 REST 选项卡来查看图形视图中的更改。
要保存您的更改，请选择 File → Save。

第 4 章将 SOAP 应用程序迁移到 RESTful Web 服务

您可以使用 WSDL 到Camel Rest 向导，使用现有的 WSDL 从现有的 JAX-WS SOAP Web 服务实施迁移到 RESTful Web 服务。该向导作为 Fuse 工具的一部分提供，它基于 Github wsdl2rest 项目中提供的 wsdl2rest 实用程序。

它支持以下规格/配置：

document/literal (doc/lit)
文档/字面处理（文档/包装）
RPC/literal (rpclit)

4.1. 向导工作流

向导使用 WSDL 路径，可以是有效的 URL （在 file:// URL 表单中）或远程 URL （使用 http 或 https）和所选 Fuse 项目。在向导中，您可以为生成的 Java 代码、生成的 Camel 配置文件、生成的 camel 端点的目标地址和 bean 实施类提供路径。

向导会根据项目生成目标 Java 和 Camel 路径。生成的 Java 代码位于 src/main/java 中，以及 Spring 或 Blueprint 的适当位置的 Camel 文件，如 src/main/resources/META-INF/spring。

您可以修改生成的类，并将其配置为某个点。

4.2. 先决条件

开始之前，您必须满足这些先决条件：

预先存在的 Fuse 集成项目。您可以使用 File→ New→ Fuse Integration Project 向导创建新项目。
WSDL 文件可通过 URL 访问。它可以是本地(file:// url)或 remote (http 或 https)。

4.3. 将示例 SOAP 应用程序迁移到 RESTful Web 服务

按照以下步骤运行向导：

在 CodeReady Studio 中，在 Project Explorer 视图中选择您的 Fuse 项目。
右键单击 Fuse 项目，然后从 WSDL 中选择 New → Camel Rest DSL。
此时会打开 Select Incoming WSDL 和 Project for Generated Output 页面。Destination Project 字段会自动预先填充 Project Explorer 中选择的 Fuse 项目。此项目是向导生成的工件的目的地。
对于 WSDL 文件，请指定用于处理的原始 SOAP 服务。
点击 Next。此时会出现 Specify Advanced Options for WSDL-to-REST Processing 页面。
1. 对于 Destination Java Folder，指定 CXF 生成的 Java 类的位置。
2. 对于 Destination Camel Folder，指定生成的 Camel Rest DSL 配置文件的位置。
  注意
  生成的 Camel 文件的路径和名称因 Camel 项目的类型而异：
  对于 Spring 项目： src/main/resources/META-INF/rest-camel-context.xml
  对于 Spring Boot 项目： src/main/resources/spring/rest-springboot-context.xml
  对于 Blueprint 项目： src/main/resources/OSGI-INF/rest-blueprint-context.xml
3. （可选）对于 目标服务地址，可提供 WSDL 绑定中指定的 SOAP 地址。您可以更改这个选项，以匹配 WSDL 引用的 SOAP 服务的实际地址。
4. 另外，对于 Target REST Service Address，提供用于访问 REST 服务的 URL。此 URL 放入了 Rest DSL 中的 &lt ;restConfiguration& gt ; 和 <rest > 标签的设置，以指定映射到 SOAP 服务的 REST 操作的完整 URL。
点击 Finish 创建两个文件，作为输出：
- 具有 Rest DSL 的 Camel 配置。
- 从 CXF 的 Java 类，以包装 SOAP 服务。

第 5 章创建新的 Apache Camel JUnit 测试问题单

概述

测试路由的常用方法是使用 JUnit。设计时间工具包含一个向导，简化了为您的路由创建 JUnit 测试案例的过程。向导使用您指定的端点来生成测试的起点代码和配置。

注意

创建样板 JUnit 测试案例后，您需要对其进行修改，以添加特定于您创建或修改的路由的预期和断言，因此测试对路由有效。

先决条件

在创建新的 JUnit 测试案例前，您需要执行初始任务：

如果您要替换现有的 JUnit 测试案例，则需要在创建新之前将其删除。请参阅 “删除和现有的 JUnit 测试案例”一节。
如果您要在尚未列出的项目中创建新的 JUnit 测试案例，您需要首先为构建路径中包含的测试案例创建 project_root/src/test/java 文件夹。请参阅 “创建并添加 src/test/java 文件夹到构建路径”一节。

删除和现有的 JUnit 测试案例

在 Project Explorer 视图中，展开项目的 root 节点，以公开 < root_project>/src/test/java 文件夹。
在 /src/test/java 文件夹中找到 JUnit 测试案例文件。
根据项目的 DSL，JUnit 测试案例文件名为 BlueprintXmlTest.java 或 CamelContextXmlTest.java。
右键单击 JUnit 测试案例 .java 文件以打开上下文菜单，然后选择 Delete。
JUnit 测试案例 .java 文件从 Project Explorer 视图中消失。
现在，您可以创建一个新的 JUnit 测试案例。

创建并添加 `src/test/java` 文件夹到构建路径

在 Project Explorer 视图中，右键单击项目的 root 以打开上下文菜单。
选择 New → Folder 以打开 Create a new folder 资源 向导。
在向导的项目树窗格中，展开项目的 root 节点，再选择 src 文件夹。
确保 & lt;project_root>/src 出现在 Enter 或选择 parent folder 字段中。
在 文件夹名称 中，输入 /test/java。此文件夹将存储您创建的新的 JUnit 测试案例。
点 Finish。
在 Project Explorer 视图中，新的 src/test/java 文件夹会出现在 src/main/resources 文件夹下。您可以通过打开上下文菜单并选择 Build Path 来验证此文件夹是否在类路径上。如果从构建路径中删除 是菜单选项，则知道 src/test/java 文件夹位于类路径上。
现在，您可以创建一个新的 JUnit 测试案例。

创建 JUnit 测试案例

为您的路由创建一个新的 JUnit 测试案例：

在 Project Explorer 视图中，选择项目中的路由上下文 .xml 文件。
右键单击它以打开上下文菜单，然后选择 New → Camel Test Case 以打开 New Camel JUnit Test Case 向导，如图 5.1 “新的 Camel JUnit Test Case 向导” 所示。
图 5.1. 新的 Camel JUnit Test Case 向导
另外，您可以通过从菜单栏中选择 File → New → Other > Fuse > Camel Test Case 来打开向导。
在 Source 文件夹 中，接受测试案例的源代码的默认位置，或者输入其他位置。
您可以点搜索位置。
在 Package 中，接受生成的测试代码的默认软件包名称，或者输入其他软件包名称。
您可以点搜索软件包。
在 test 下的 Camel XML 文件中，接受包含您要测试的路由或输入另一个路径名称的路由上下文文件的默认路径名称。
您可以点搜索上下文文件。
在 Name 中，接受生成的测试类的默认名称，或者输入其他名称。
选择您要包含在生成的代码中的方法存根。
如果要在生成的代码中包含默认生成的注释，请选中 Generate comments 复选框。
点打开 Test Endpoints 页面。例如，图 5.2 “新的 Camel JUnit Test Case 页面” 显示路由的输入和输出文件端点。
图 5.2. 新的 Camel JUnit Test Case 页面
在 Available endpoint 下，选择您要测试的端点。单击任何选定端点旁边的复选框，以取消选择它。
点击。
注意
如有提示，将 JUnit 添加到构建路径中。

测试的工件添加到项目中，并显示在 src/test/java 下的 Project Explorer 视图中。实施测试案例的类在 Java 编辑器中打开。

第 6 章在 Red Hat Fuse Tooling 中运行路由

使用工具运行路由的方法有两种：

第 6.1 节 “将路由作为本地 Camel 上下文运行”
第 6.2 节 “使用 Maven 运行路由”

6.1. 将路由作为本地 Camel 上下文运行

概述

运行 Apache Camel 路由的最简单方法是作为 本地 Camel 上下文。这个方法可让您直接从 Project Explorer 视图的上下文菜单中启动路由。当您从上下文菜单运行路由时，工具会自动为您创建运行时配置集。您还可以创建自定义运行时配置集来运行路由。

您的路由像直接从命令行调用一样运行，并使用 Apache Camel 嵌入的 Spring 容器。您可以通过编辑运行时配置集来配置多个运行时参数。

流程

将路由作为本地 Camel 上下文运行：

在 Project Explorer 视图中，选择一个路由上下文文件。
右键单击它以打开上下文菜单，然后选择 Run As → Local Camel Context。
注意
选择 Local Camel Context （没有测试） 会指示工具在不执行验证测试的情况下运行项目，这可能会更快。

结果

Console 视图显示从运行路由生成的输出。

6.2. 使用 Maven 运行路由

概述

如果包含路由的项目是一个 Maven 项目，您可以使用 m2e 插件来运行路由。使用这个选项，您可以在路由运行前执行任何 Maven 目标。

流程

使用 Maven 运行路由：

在 Project Explorer 视图中，选择项目的根目录。
右键单击它以打开上下文菜单，然后选择 Run As → Maven build。
1. 您第一次使用 Maven 运行项目时，编辑配置和启动 编辑器会打开，以便您可以创建 Maven 运行时配置文件。
  要创建运行时配置集，在 Maven 选项卡中：
  1. 确保 Apache Camel 项目的路由目录出现在 Base directory: 字段中。
    例如，在 Linux 上，项目的根目录与 ~/workspace/simple-router 类似。
  2. 在 Goals: 字段中，输入 camel:run。
    重要
    如果您使用 Java DSL 创建项目，请在 Goals: 字段中输入 exec:java。
  3. 单击" 应用 "，然后单击 "运行 "。
2. 后续 Maven 运行使用此配置集，除非您在运行时进行了修改。

结果

Console 视图显示 Maven run 的输出。

6.3. 使用运行时配置集

Red Hat Fuse Tooling 将每个项目的运行时环境信息存储在 运行时配置文件中。运行时配置文件跟踪此类信息，如要调用的 Maven 目标、要使用的 Java 运行时环境、需要设置的任何系统变量，等等。项目可以有多个运行时配置集。

6.3.1. 编辑本地 Camel 上下文运行时配置集

概述

Local Camel Context runtime 配置集配置如何调用 Apache Camel 来执行路由。Local Camel Context runtime 配置集存储定义您的路由的上下文文件的名称、要调用的 主要 命令行选项、传递给 JVM 的命令行选项、要使用的类路径、需要设置的任何环境变量以及一些其他信息。

Local Camel Context runtime 配置集的运行时配置编辑器包含以下标签页：

Camel Context File criu-wagonspec 表示新配置的名称以及包含路由的路由上下文文件的完整路径。
JMX mvapich-wagonspecifies JMX 连接详情，包括 JMX URI 和用于访问它的用户名和密码（可选）。
main ProductShortName-wagonspecs 项目基础目录的完全限定域名、一些选项用于定位基础目录，以及运行路由前执行的任何目标，以及要使用的 Maven 运行时版本。
JRE mvapich-growfsspec 在启动 JVM 时会通知 JRE 和命令行参数。
刷新 ProductShortName-wagonspecifies Maven 在运行终止后如何刷新项目的资源文件。
环境 ProductShortName-wagonspec 会通知需要设置的任何环境变量。
常见 criu-wagonspec 表示配置集的存储方式以及显示的输出。

Apache Camel 路由第一次作为 本地 Camel 上下文 运行时，Red Hat Fuse Tooling 为路由上下文文件创建，默认运行时配置文件不需要编辑。

访问本地 Camel 上下文的运行时配置编辑器

在 Project Explorer 视图中，选择您要编辑或创建自定义运行时配置集的 Camel 上下文文件。
右键单击它以打开上下文菜单，然后选择 Run As → Run Configuration 以打开 Run Configuration 对话框。
在 上下文选择 窗格中，选择 Local Camel Context，然后点击 上下文选择 窗格顶部的。
在 Name 字段中输入运行时配置集的新名称。

图 6.1. Local Camel 上下文的运行时配置编辑器

设置 camel 上下文文件

Camel Context File 选项卡有一个字段，选择 Camel Context file…。输入包含路由定义的路由上下文文件的完整路径。

Browse 按钮可以访问 Open Resource 对话框，这有助于查找目标路由上下文文件。此对话框已预先配置为搜索包含 Apache Camel 路由的文件。

更改命令行选项

默认情况下，传递给 JVM 的唯一命令行选项是：

-fa context-file

如果您使用自定义主类，您可能需要传递不同的选项。为此，请在主选项卡中 单击添加按钮，以输入参数的名称和值。您可以单击 Add Parameter 对话框的 Variables… 按钮，以显示您可以选择的变量列表。

要添加或修改特定于 JVM 的参数，请编辑 JRE 选项卡上的 VM 参数 字段。

更改发送输出的位置

默认情况下，从运行路由生成的输出发送到 Console 视图。但是您可以将它重定向到文件。

将输出重定向到文件：

选择 Common 选项卡。
在 Standard Input and Output 窗格中，单击 Output File: 字段旁边的复选框，然后输入您要发送输出的文件的路径。
Workspace、文件系统 和变量 按钮有助于构建输出文件的路径。

6.3.2. 编辑 Maven 运行时配置集

概述

Maven 运行时配置集配置 Maven 如何调用 Apache Camel。Maven 运行时配置文件存储要执行的 Maven 目标、要使用的任何 Maven 配置文件、要使用的 Maven 版本、要使用的类路径、需要设置的任何环境变量以及一些其他信息部分。

重要

第一次使用 Maven 运行 Apache Camel 路由时，您必须为它创建一个默认的运行时配置集。

Fuse 运行时配置集的运行时配置编辑器包含以下标签页：

main criu-unmarshalspec 表示新配置的名称、项目基础目录的完全限定名称、查找基础目录的几个选项、运行路由前执行的任何目标，以及要使用的 Maven 运行时版本。
JRE mvapich-growfsspec 在启动 JVM 时会通知 JRE 和命令行参数。
刷新 ProductShortName-wagonspecifies Maven 在运行终止后如何刷新项目的资源文件。
source ProductShortName-wagonspec 会通知项目所需的任何其他源的位置。
环境 ProductShortName-wagonspec 会通知需要设置的任何环境变量。
常见 criu-wagonspec 表示配置集的存储方式以及显示的输出。

访问 Maven 运行时配置编辑器

在 Project Explorer 视图中，选择您要编辑或创建自定义运行时配置集的项目根。
右键单击它以打开上下文菜单，然后选择 Run As → Run Configuration 以打开 Run Configuration 对话框。
在 上下文选择 窗格中，选择 Maven Build，然后点击 上下文选择 窗格顶部的。

图 6.2. Maven 的运行时配置编辑器

更改 Maven 目标

运行路由时最常用的目标是 camel:run。它将路由加载到在其自身 JVM 中运行的 Spring 容器中。

Apache Camel 插件还支持 camel:embedded 目标，它将 Spring 容器加载到 Maven 使用的同一 JVM 中。这样做的好处是路由应该更快地引导。

基于 Java DSL 的项目使用 exec:java 目标。

如果您的 POM 包含其他目标，您可以通过单击 Main 选项卡上 Maven Runtime 字段旁边的 Configure… 按钮来更改所使用的 Maven 目标。在 Installations 对话框中，您可以编辑 &lt ;selected_runtime> 安装 字段的全局设置。

更改 Maven 的版本

默认情况下，Red Hat Fuse Tooling for Eclipse 使用 m2e，它嵌入在 Eclipse 中。如果要使用不同版本的 Maven 或在开发机器上安装更新的版本，您可以从 Main 选项卡上的 Maven Runtime 下拉菜单中选择它。

更改输出的发送位置

默认情况下，路由执行的输出发送到 Console 视图。但是您可以将它重定向到文件。

将输出重定向到文件：

选择 Common 选项卡。
单击 Output File: 字段旁边的复选框，然后输入要发送输出的文件的路径。
Workspace、文件系统 和变量 按钮有助于构建输出文件的路径。

第 7 章在 OpenShift 中使用 Fuse

从 7.0 开始，OpenShift 上的 Fuse (Fuse 集成服务的名称)可让您在 OpenShift Container Platform 上部署 Fuse 应用程序。

重要

对于 Fuse 集成项目（在 OpenShift 项目中使用），Fuse Tooling 需要安装 Red Hat Container Development Kit (CDK) v3.x。具体步骤请查看入门指南。除了本指南中指定的先决条件外，如果您没有红帽帐户，则需要建立一个红帽帐户。需要您的红帽用户名和密码来启动 Red Hat Container Development Kit 中提供的虚拟 OpenShift 实例。

您可以通过注册红帽客户门户网站来轻松获得帐户。点击白色标语右上角的 Account ，然后点击 Login to Your Red Hat Account 页面的 RH acctRegBut 。

Fuse 工具可让您使用 s2i 二进制工作流开发和部署 Fuse 集成项目。在此工作流中，工具会在本地构建项目，将其汇编为镜像流，然后将镜像流推送到 OpenShift，在其中用于构建 Docker 容器。构建 Docker 容器后，OpenShift 会将它部署到容器集中。

重要

Fuse Tooling 只适用于 S2I 二进制工作流，且只适用于基于 Spring Boot 框架的项目。

注意

虽然 Fuse 工具可以使用工具在远程 OpenShift 服务器部署 Fuse 集成项目，但本章描述了将 Fuse 集成项目创建和部署到虚拟 OpenShift 实例，后者使用 Red Hat Container Development Kit (CDK) v3.x 在本地安装。

以下小节介绍了如何创建和部署第一个 Fuse 集成项目：

第 7.1 节 “添加 Red Hat Container Development Kit 服务器”
第 7.2 节 “启动容器开发环境(CDE)和虚拟 OpenShift 服务器”
第 7.3 节 “创建新的 OpenShift 项目”
第 7.4 节 “创建新的 Fuse 集成项目”
第 7.5 节 “将 Fuse Integration 项目部署到 OpenShift”

注意

您还可以将 Fuse 集成项目作为本地 Camel 上下文运行，请参阅第 6.1 节 “将路由作为本地 Camel 上下文运行”，然后在 JMX Navigator 视图中连接到它，您可以在其中监控和测试路由上下文。您还可以在 Fuse 集成项目(第 II 部分 “调试路由上下文”)上运行 Camel 调试器，以公开和修复路由上下文中的任何逻辑错误。

7.1. 添加 Red Hat Container Development Kit 服务器

将 Red Hat Container Development Kit 添加到 Servers 视图中：

如有必要，选择 Window → Perspective → Open Perspective → Fuse Integration，切换到 Fuse Integration 视角。
注意
如果没有打开此流程中描述的视图，您可以选择 Window → Show View → Other 来打开它，然后选择您要打开的视图的名称。
在 Servers 视图中，点链接 No servers are available.点击此链接来创建新 server… 以打开 Define a New Server 向导。只有在 Servers 视图不包含服务器条目时，才会显示此链接。
否则，在 Servers 视图中右键单击以打开上下文菜单，然后选择 New → Server 以打开 Define a New Server 向导。
选择 Red Hat JBoss Middleware → Red Hat Container Development Kit 3.2+。
接受以下的默认值：
- 服务器的主机名 iwl - localhost
- 服务器名称 mvapich - Container Development 环境
点 Next 以打开 Red Hat Container Development Environment 页面。
在 MiniShift Binary 旁边，点 Browse，进入安装 Red Hat Container Development Kit 3.x 的位置，然后点 Open。
在 Username 旁边，单击 Add 以打开 Add a Credential 页面。
以这种方式设置凭证：
- 用户名 ProductShortName-wagonEnter 用于登录到您的红帽帐户的名称。
- 始终提示密码 mvapich-wagonLeave 为（禁用）。
- password ProductShortName-wagonEnter 用于登录到您的红帽帐户 的密码 。
点 OK 返回 Red Hat Container Development Environment 页面，它现已填充。例如：
点 Finish。容器开发环境 3.2+ [Stopped, Synchronized] 出现在 Servers 视图中。当您添加 CDK 3.x 服务器时，容器开发环境 3.2+ 是默认的服务器名称。

7.2. 启动容器开发环境(CDE)和虚拟 OpenShift 服务器

启动容器开发环境(CDE)也会启动虚拟 OpenShift 服务器。停止 CDE 也会停止虚拟 OpenShift 服务器。

在 Servers 视图中，选择 Container Development Environment 3 [stopped, Synchronized]，然后点 Servers 菜单栏中的。
控制台 视图会打开并显示引导过程的状态：
注意
在初始启动时，CDE 询问您是否接受不受信任的 SSL 证书。单击 Yes 。
启动过程完成后，Servers 视图会显示：
切换到 OpenShift Explorer 视图。
开发人员 的虚拟 OpenShift 服务器实例也在运行：
https://192.168.99.100:8443 是 OpenShift 开发人员 Web 控制台的 URL 示例。您的安装会显示您的实例的 URL。如需了解更多详细信息，请参阅第 7.6 节 “访问 OpenShift Web 控制台”。

7.3. 创建新的 OpenShift 项目

将 Fuse 集成项目部署到 OpenShift 时，它将发布到您在此处创建的 OpenShift 项目。

在 OpenShift Explorer 视图中，右键单击 developer 条目，以打开上下文菜单。
选择 New → Project 以打开 New OpenShift Project 向导。
以这种方式设置新项目的属性：
- 在 Project Name 字段中输入虚拟 OpenShift 服务器上项目名称。
  只有小写字母、数字和横线才有效。
- 在 Display Name 字段中，输入要在虚拟 OpenShift Web 控制台的 Overview 页面中显示的名称。
- Description 字段保留原样。
  例如：
点 Finish。
新的 OpenShift 项目（本例中为 New FIS Test newtest）会出现在 OpenShift Explorer 选项卡中，在本例中为 developer https://192.168.99.100:8443 ：
注意
myproject myproject 是 OpenShift 中包含的初始示例项目。
在 OpenShift Explorer 视图中选择了 New FIS Test newtest 时，Properties 视图会显示项目的详细信息。例如：
注意
将项目部署到 OpenShift 时，Properties 视图会收集并显示有关 OpenShift Web 控制台所执行项目的相同信息。

7.4. 创建新的 Fuse 集成项目

在创建新的 Fuse 集成项目之前，您应该启用 staging 存储库。这是必要的，因为一些 Maven 工件不在默认的 Maven 存储库中。要启用暂存存储库，请选择 Window → Preferences → Fuse Tooling → Staging Repositories。

要创建 Fuse 集成项目，请使用 Spring Boot on OpenShift 模板：

在 Project Explorer 视图中，右键单击以打开上下文菜单，然后选择 New → Fuse Integration Project 来打开向导的 Choose a project name 页面：
在 Project Name 字段中，输入您正在使用的工作区唯一的名称，例如 myFISproject。
接受其他选项的默认值。
点 Next 打开 Select a Target Runtime 页面：
保留 Target Runtime (No Runtime selected)和 Camel Version 的默认值。
点 Next 打开 Advanced Project Setup 页面：
使用 Spring Boot - Spring DSL 模板选择 Simple log。
点 Finish。
注意
由于为首次 Fuse 集成项目下载的依赖项数量，构建可能需要一些时间。
如果 Fuse Integration 视角还没有打开，Developer Studio 会提示您指示您现在是否要打开它。单击 Yes 。

构建完成后，Fuse Integration 视角会显示项目，例如：

此时，您可以：

在 OpenShift 上部署项目
第 6.1 节 “将路由作为本地 Camel 上下文运行” 验证路由上下文是否在本地机器上成功运行
连接到 JMX Navigator 视图中的运行上下文（请参阅 “查看本地 JMX 服务器中的进程”一节），您可以监控路由组件并测试路由是否按预期执行：
- 查看路由组件的 JMX 统计直接 see 第 21 章 查看组件的 JMX 统计。
- 编辑正在运行的路由 CamelAwsS-busyboxsee 第 25 章 管理路由端点。
- suspend/resume 正在运行的路由 iwl- iwlsee 第 27 章 管理路由上下文
- 运行的路由的 start/stop tracing on the started/stopsee 第 23 章 追踪路由
在项目的 camel-context.xml 文件上运行 Camel debugger，以发现并修复逻辑错误，请参阅。第 II 部分 “调试路由上下文”

7.5. 将 Fuse Integration 项目部署到 OpenShift

在 Project Explorer 视图中，右键单击项目的根目录（本例中为 myFISproject）以打开上下文菜单。
选择 Run As → Run Configuration 以打开 Run Configuration 向导。
在侧边栏菜单中选择 Maven Build → Deploy <projectname> on OpenShift （本例中为 Deploy myFISproject on OpenShift），以打开项目的默认运行配置：
保留默认设置，因为它们位于 Main 选项卡中。
打开 JRE 选项卡以访问虚拟机参数：
在 VM 参数 窗格中，更改 -Dkubernetes.namespace=test 参数的值，以匹配您在创建时用于 OpenShift 项目的项目名称（位于第 7.3 节 “创建新的 OpenShift 项目” 中的OpenShift 项目名称）。
在本例中，将默认值 test 改为 newtest ：
根据您的 OpenShift 配置，您可能需要修改其他的 VM 参数来支持它：
- -Dkubernetes.master=https://192.168.99.1:8443
  在运行多个 OpenShift 实例或使用远程实例时，您需要指定面向部署的 OpenShift 实例的 URL。上面的 URL 是示例。
- -Dkubernetes.trust.certificates=true
  - 在使用 CDK 时，需要此参数。将它设为 true。
  - 如果您使用具有有效 SSL 证书的 OpenShift 实例，请将此参数的值更改为 false。
单击 Apply，然后单击 Run。
由于要下载依赖项数量，首次部署可能需要一些时间。计算机和互联网连接的速度是贡献因素。通常，需要 25 到 35 分钟才能完成首次部署。
在 Console 视图中，您可以跟踪部署过程的进度。在以下输出中，条目 *Pushing image 172.30.1 ….* 表示项目构建成功，应用程序镜像被推送到 OpenShift，它将用于构建 Docker 容器。
部署成功后，Console 视图会显示 BUILD SUCCESS ：
切换到 OpenShift Explorer 视图并选择 New FIS Test newtest ：
在 Properties 视图中，Details 页面显示所有项目的属性值。
打开其他选项卡(Build、Build Configs、Deployment、…)以查看项目的其他属性。Properties 视图提供与 OpenShift Web 控制台相同的信息。
在 OpenShift Explorer 视图中，选择 camel-ose-springboot-xml 在 Properties 视图中查看其详情：
滚动浏览其他选项卡，以查看部署配置的其他属性。
在 OpenShift Explorer 视图中，选择 camel-ose-springboot-xml-1-mdmtd Pod Running，然后在 Properties 视图中查看正在运行的实例的详情：
在 OpenShift Explorer 视图中，右键点击 camel-ose-springboot-xml-1-mdmtd Pod Running，然后选择 Pod Logs…。
注意
如有提示，输入到已安装的 oc 可执行文件的路径。检索 pod 日志需要它。
Console 视图会自动打开，显示来自正在运行的 pod 的日志：
点 Console 视图的菜单栏中的终止会话并清除控制台输出。

7.6. 访问 OpenShift Web 控制台

注意

此信息只适用于 Red Hat Container Development Kit 安装。

要访问 OpenShift Web 控制台，请打开浏览器并输入 OpenShift 服务器的 URL，该 URL 特定于您的实例和您的计算机。例如，在浏览器的地址字段中输入 https://192.168.99.100:8443。

您可以使用默认凭证以开发者或管理员身份登录 Web 控制台：

默认开发人员角色
开发人员用户只能查看自己的项目和提供的 OpenShift 示例项目，其演示了 OpenShift v3 功能。开发人员用户可以创建、编辑和删除他们拥有在 OpenShift 上部署的任何项目。
- 用户名 - 开发人员
- 密码 - developer
默认管理员角色
管理员用户可以查看并访问 OpenShift (CDK)中的所有项目。管理员可以创建、编辑和删除 OpenShift 中部署的任何项目。
- 用户名 - admin
- password - admin

有关使用 OpenShift Web 控制台的更多信息，请参阅入门指南。

第 8 章使用红帽 Fuse SAP 工具套件

红帽 Fuse SAP 工具套件可以将您的 Camel 路由与远程 SAP Application Server 集成。提供了各种 SAP 组件来支持远程功能调用(RFC)以及中介文档(IDoc)的发送和接收。SAP 工具套件依赖于 SAP 中的 JCo 和 IDoc 客户端库。要安装和使用这些库，您必须有一个 SAP Service Marketplace 帐户。

8.1. 安装 Red Hat Fuse SAP Tool Suite

概述

Red Hat Fuse SAP Tool Suite 提供 Edit SAP Connection Configuration 对话框，它可帮助您创建和管理 SAP Application Server 和 Destination 连接。默认情况下，该套件没有安装，因为它需要第三方 JCo 和 IDoc 客户端库，这些库由 SAP 单独获得。

SAP 工具的平台限制

由于 SAP 工具套件依赖于第三方 JCo 和 IDoc 库，所以它只能安装在这些库支持的平台上。有关 SAP 工具平台限制的详情，请参阅 Red Hat Fuse 支持的配置。

先决条件

在安装 Fuse SAP 工具套件前，您必须从以下位置下载 JCo 和 IDoc 库： http://service.sap.com/connectors
要为您的操作系统确定适当的 JCo 和 IDoc 库，请参阅 Red Hat Fuse 支持的配置页面。
要下载 JCo 和 IDoc 库，您需要一个 SAP Service Marketplace 帐户。
对于这个安装过程，您可以使用存档格式保留下载的文件。不需要提取内容。

流程

要将 Fuse SAP Tool Suite 安装到 Red Hat CodeReady Studio 中，请执行以下步骤：

在 Red Hat CodeReady Studio 中，选择 File → Import 以打开 Import 向导。
在 Import 向导的 Select 屏幕中，选择 Fuse → Install Fuse SAP Tool Suite，然后点 Next。
Install the Red Hat Fuse SAP Tool Suite 屏幕将打开，其中显示了从 SAP Service Marketplace 下载 JCo 和 IDoc 库的说明。点击 Next。
此时会打开 Select JCo and IDoc Archive to Import 屏幕。在 JCo Archive File 字段旁边，使用 Browse 按钮选择您从 SAP Service Marketplace 下载的 JCo 存档。选择 JCo 归档后，将自动填充归档版本和归档 OS Platform 字段，以便您可以检查您要安装的库是否具有正确的版本和操作系统平台。
在 IDoc Archive File 字段旁边，使用 Browse 按钮选择您从 SAP Service Marketplace 下载的 IDoc 存档。
选择了这两个存档文件后，单击 Finish。
一个新的 Install 向导（用于安装 Eclipse 插件）会自动打开。这个向导显示以下内容以安装插件：
- Fuse SAP 工具套件
- SAP JCo 和 IDoc Libraries
  确保选择了这两个插件。点击 Next。
  注意
  SAP JCo 和 IDoc Libraries 插件由所选的 JCo 和 IDoc 库动态构建。
通过 Install Details 屏幕，您可以查看要安装的插件。点击 Next。
此时会打开 Review Licenses 对话框。选择 I accept 单键选项，然后单击 Finish。
如果您遇到 安全警告 对话框（未签名内容的警告），请单击 OK 忽略警告并继续安装。
此时会打开 Restart Eclipse 对话框。单击 OK 以重新启动 Eclipse。

8.2. 创建和测试 SAP 目标连接

概述

在 Fuse SAP Tool 套件中，编辑 SAP 连接配置对话框可帮助您创建和管理 SAP 应用程序目标连接。这部分论述了如何创建和测试 SAP 目标连接。

流程

要创建并测试 SAP 目标连接，请执行以下步骤：

导航到路由编辑器的 全局配置 选项卡，再单击 Add。
此时会出现 Create new global element view。
在 SAP 下，选择您要创建的连接类型。选择 SAP Connection，然后单击 Ok。
此时会出现 Edit SAP Connection Configuration 对话框。它允许您创建、编辑和删除 Destination 和 Server Connection 配置。
要创建新 Destination Data Store，点 Add Destination 选项卡。
此时会出现 Create Destination 对话框。
在 Destination Name 字段中输入目的地的名称，然后单击确定。
在 Properties 对话框中，
1. 点 Basic 选项卡配置连接到 SAP 目标所需的基本属性。在这个标签页中，填写以下属性字段来配置连接：
  - SAP Application Server
  - SAP 系统号
  - SAP Client
  - logon User
  - logon Password
  - Logon Language
2. 单击 Connection 选项卡，以添加连接到 SAP 目标所需的值。填写以下属性字段来配置连接：
  - SAP 系统号
  - SAP 路由器字符串
  - SAP Application Server
  - SAP Message Server
  - SAP Message Server Port
  - 网关主机
  - 网关端口
  - SAP 系统 ID
  - SAP Application Server Group
3. 单击 Authenticate 选项卡，以添加验证 SAP 目标所需的值。填写下列属性字段以配置连接。
  - SAP 身份验证类型
  - SAP Client
  - logon User
  - logon User Alias
  - logon Password
  - SAP SSO Logon Ticket
  - SAP X509 Login Ticket
  - Logon Language
4. 点 Special 选项卡。在这个标签页中，填写以下属性字段来配置连接：
  - 选择 CPIC Trace
  - 初始代码页面
5. 点 Pool 选项卡，并填写以下属性字段来配置连接：
  - 连接池调整限制
  - 连接池容量
  - 连接池过期时间
  - Connection Pool Expire Check Period
  - 连接池最大获取客户端时间
6. 点 SNC 选项卡并填写以下属性字段来配置连接：
  - SNC 合作伙伴名称
  - SNC 安全级别
  - SNC 名称
  - SNC 库路径
7. 点 Repository 选项卡，并填写以下属性字段来配置连接：
  - 仓库目的地
  - 仓库登录用户
  - 仓库登录密码
    注意
    如果您需要有关这些设置的更多信息，请参阅 SAP 文档。
现在，您可以测试目标连接。在 Edit SAP Connection Configuration 对话框中，右键单击目的地名称并选择 Test。
此时会打开 Test Destination Connection 对话框。
对话框使用当前目标配置设置来连接 SAP Destination Data Store。如果测试成功，您将在状态区域中看到以下信息：
```
Connection test for destination 'YourDestination' succeeded.
```
否则，错误报告会出现在状态区域中。
点击 Close 关闭 Test Destination Connection 对话框。
点 Finish。新创建的 SAP Destination Connection 会出现在 SAP 下。

8.3. 创建和测试 SAP 服务器连接

概述

在 Fuse SAP Tool 套件中，编辑 SAP 连接配置对话框可帮助您创建和管理 SAP 应用服务器连接。这部分论述了如何创建和测试 SAP 服务器连接。

流程

要创建并测试 SAP 服务器连接，请执行以下步骤：

导航到路由编辑器的 全局配置 选项卡，再单击 Add。
此时会出现 Create new global element view。
在 SAP 下，选择您要创建的连接类型。选择 SAP Connection，然后单击 Ok。
此时会出现 Edit SAP Connection Configuration 对话框。它允许您创建、编辑和删除 Destination 和 Server Connection 配置。
若要创建新 服务器数据存储， 请单击 Add Server 选项卡。
此时会出现 Create Server 对话框。
在 Server Name 字段中输入服务器名称，然后单击确定。
在 Properties 对话框中，
1. 点 Mandatory 选项卡配置连接到 SAP 服务器所需的基本属性。在这个标签页中，填写以下属性字段来配置连接：
  - 网关主机
  - 网关端口
  - 程序 ID
  - 仓库目的地
  - 连接数
2. 点击 Optional 选项卡并填写以下属性字段来配置连接：
  - SAP 路由器字符串
  - worker 线程数
  - 最小 worker 线程数
  - 最大启动延迟
  - 仓库映射
3. 点 SNC 选项卡，并填写以下属性字段来配置连接。
  - SNC 安全级别
  - SNC 名称
  - SNC 库路径
    注意
    有关设置的更多信息，请参阅 SAP 文档。
现在，您可以测试服务器连接。在 Edit SAP Connection Configuration 对话框中，右键单击服务器名称并选择 Test。
此时会打开 Test Server Connection 对话框。
对话框使用当前服务器配置设置连接到 SAP Server Data Store。如果测试成功，您将在状态区域中看到以下信息：
```
Server state: STARTED
Server state: ALIVE
```
如果测试失败，服务器状态将报告为 DEAD。
点 Stop 关闭 Test Sever。
单击 Close 以关闭 Test Server Connection 对话框。
点 Finish。新创建的 SAP Server Connection 会出现在 SAP 下。

8.4. 删除目标和服务器连接

概述

这部分论述了如何在 Edit SAP Connection Configuration 对话框中删除 SAP Destination 和 Server 连接。

流程

如果要删除目标和服务器连接，请执行以下步骤：

导航到路由编辑器的 全局配置 选项卡，再单击 Add。
此时会出现 Create new global element view。
在 SAP 下，选择 SAP Connection 并单击 Ok。
此时会出现 Edit SAP Connection Configuration 对话框。它允许您创建、编辑和删除 Destination 和 Server Connection 配置。
在 Edit SAP Connection Configuration 对话框中，选择您要删除的 Destination 和 Server Data Stores。
点击 Delete。它将删除所选连接。
Atlast，单击 Finish。它将保存所有更改。

8.5. 创建新的 SAP 端点

概述

您可以使用路由编辑器中的 Components palette 将 SAP 组件添加到路由，并帮助 Edit SAP Connection Configuration 对话框。

注意

如果您使用 SAP Connection 视图，请记住将必要的 SAP 连接配置数据粘贴到 Blueprint XML 或 Spring XML 代码中。

先决条件

您必须已创建了一些 SAP 目标连接和/或服务器连接，以及 Edit SAP Connection Configuration 对话框。

注意

如果您使用 SAP Connection 视图，请将此配置导出到适当类型的文件中（打印 XML 或 Spring XML）。

流程

要创建新的 SAP 端点，请执行以下步骤：

假设您已有一个 Fuse 项目和一个 Camel XML 文件来使用（可以是 Blueprint XML 或 Spring XML 格式）。
在路由编辑器中打开您的 Camel XML 文件。如果您已经安装了 Red Hat Fuse SAP Tool Suite，则应在路由编辑器中的 Components palette 下看到 SAP 组件。以下 SAP 组件由工具套件提供：
- SAP IDoc Destination
- SAP IDoc 列表目标
- SAP IDoc List Server
- SAP qRFC Destination
- SAP Queued IDoc Destination
- SAP Queued IDoc 列表目的地
- SAP sRFC Destination
- SAP sRFC 服务器
- SAP tRFC Destination
- SAP tRFC Server
  在路由编辑器的 Design 选项卡中，将其中一个组件拖到 canvas 中，以在当前 camelContext 中创建新的 SAP 端点。
  注意
  SAP Netweaver 组件不属于红帽 Fuse SAP 工具套件。它托管在 Apache Camel 项目中。
单击 canvas 底部的 Source 选项卡，以切换到路由编辑器的 Source 选项卡。您可以查看路由的 XML 源。
在指定 SAP 端点 URI 时，您必须以 URI 格式嵌入目的地名称或服务器连接名称。例如，sap-srfc-destination 组件有以下 URI 格式：
```
sap-srfc-destination:destinationName:rfcName
```
要引用特定目的地，请使用相关条目元素的 key 属性的值作为 URI 中的 destinationName。

第 9 章数据转换入门

系统和数据集成所带来的一个挑战是组件系统通常使用不同的数据格式工作。在接收系统可识别的格式（或语言）的情况下，您无法只将信息从一个系统发送到另一个系统。数据转换是针对此翻译的术语。

在本章中，您将了解如何在预定义的 Camel 路由中包含数据转换。Camel 路由将来自源端点的消息定向到使用 JSON 数据的目标端点。您可以添加并定义一个数据转换组件，将源的 XML 数据格式映射到目标的 JSON 数据格式。

9.1. 为数据转换示例创建一个项目

创建新的 Fuse 集成项目（选择 File → New → Fuse Integration Project）。
在向导中提供以下信息：
- 项目名称： starter
- 部署平台：独立
- 运行时环境：2019 年 2 月/Fuse
- Camel 版本：使用默认
- 模板： Empty - Blueprint DSL
从以下位置下载准备的数据示例 ：https://github.com/FuseByExample/fuse-tooling-tutorials/archive/user-guide-11.1.zip
将 data 文件夹及其包含自 user-guide-11.1.zip 归档的三个文件提取到 Fuse 集成项目的 src 目录(starter/src/data)。
在 Project Explorer 视图中，展开初学者项目。
双击 Camel Contexts → src/main/resources/OSGI-INF/blueprint/blueprint.xml，以在路由编辑器的 Design 选项卡中打开 路由。
点 Source 选项卡查看底层 XML。

将 <route id="_route1"/& gt; 替换为以下代码：

<route id="_route1">
  <from id="_from1" uri="file:src/data?fileName=abc-order.xml&amp;noop=true"/>
  <setHeader headerName="approvalID" id="_setHeader1">
    <simple>AUTO_OK</simple>
  </setHeader>
  <to id="_to1" uri="file:target/messages?fileName=xyz-order.json"/>
</route>

点击 Design 选项卡返回到路由的图形显示：

9.2. 将数据转换节点添加到 Camel 路由

在 panel 中，展开 Transformation drawer。
单击 Data Transformation 模式，然后在 canvas 中单击 SetHeader _setHeader1 和 To_to1 节点之间的箭头。
New Transformation 向导会打开，并自动填充 Dozer File Path 字段。
填写剩余的字段：
- 在 Transformation ID 字段中，输入 xml2json。
- 对于 Source Type，从下拉菜单中选择 XML。
- 对于 Target Type，请从下拉菜单中选择 JSON。
点击 Next。
Source Type (XML) 定义页面将打开，其中指定了 XML 架构 （默认）或示例 XML 实例文档，以提供源数据的类型定义：
使 XML 架构 保持启用状态。
对于 Source file，浏览到用于源数据的 XML 模式文件或 XML 实例文件的位置，并选择它（本例中为 abc-order.xsd）。
XML 结构 窗格显示 XML 结构的预览。
在 Element root 字段中，输入 ABCOrder。
这些工具使用此文本标记要映射的源数据项目的窗格。
源类型(XML) 定义页面现在应如下所示：
点 Next 以打开 Target Type (JSON) 定义页面。这是您为目标数据指定类型定义的位置。
单击 JSON 实例文档。
在 Target File 字段中，输入 xyz-order.json 实例文档的路径，或者浏览到它。JSON 结构 窗格显示 JSON 数据结构的预览：
点 Finish。

此时会打开转换编辑器。在这里，您可以将 XML 源中的数据项映射到 JSON 目标中的数据项。

转换编辑器由三个面板组成：

source criu-wagonlists 源的可用数据项
映射 iwl-wagondisplay 源和目标数据项目之间的映射
目标 criu-wagonlists 的目标可用数据项

此外，编辑器的详细信息窗格仅位于编辑器的三个面板（一旦进行了第一个映射）下，图形方式显示当前所选择的映射源和目标数据项目的层次结构。例如：

带有源属性 customerNum 映射到目标属性 role="italic">custId

使用详情窗格，您可以自定义所选源和目标数据项目的映射：

设置属性 setuptools-ModifyModify 现有映射，或者将简单的数据项映射到集合中的一个数据项目（请参阅第 9.8 节 “将简单的数据项映射到集合中的数据项”）。
为数据项目设置变量 criu-DESTINATIONSpecify 常量值（请参阅第 9.5 节 “将常量变量映射到数据项”）。
将 expression criu-wagonMap 一个数据项设置为指定表达式的动态评估（请参阅第 9.6 节 “将表达式映射到数据项目”）。
使用内置功能 添加映射数据项的值转换 （请参阅第 9.9 节 “在映射的数据项中添加内置功能”）。
使用您创建的 Java 方法或您之前创建的 Java 方法，添加自定义转换 mvapich-ModifyModify 值（请参阅第 9.7 节 “将自定义转换添加到映射的数据项”）。

9.3. 将源数据项映射到目标数据项

展开 Mappings 面板左侧的 Source 和 Target 面板中的所有项。
从 Source 面板拖动数据项，并将它放到 Target 面板中的对应数据项。
例如，将 customerNum 数据项从 Source 面板拖放，并将它放到 Target 面板中的 custId data 项上。
映射会出现在 Mappings 面板中，Source 和 Target data items 的详细信息会出现在详情窗格中。

继续将源数据项目拖放到对应的目标数据项目中，直到您完成所有基本映射。

在 初学者 示例中，要映射的剩余数据项有：

源	目标
`orderNum`	`orderId`
`status`	`priority`
`id`	`itemId`
`价格`	`cost`
`quantity`	`amount`

注意

您可以将集合（包含列表或集合的数据项目）映射到非集合数据项，反之亦然，但您无法将集合映射到其他集合。

在 Source 和 Target 面板中点来快速确定所有数据项是否已映射。
只有尚未映射的数据项才会列在 Source 和 Target 面板中。
在 初学者 示例中，其余的未映射目标属性是 approvalCode 和 origin。
点 blueprint.xml 选项卡返回到路由的图形显示：
点 File → Save。

在创建转换测试后，您可以在转换文件上运行 JUnit 测试。详情请查看第 9.4 节 “创建转换测试文件并运行 JUnit 测试”。此时，您将在 Console 视图中看到此输出：

对于源 XML 数据：

<?xml version="1.0" encoding="UTF-8"?>
<ABCOrder xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:java="http://java.sun.com">
    <header>
        <status>GOLD</status>
        <customer-num>ACME-123</customer-num>
        <order-num>ORDER1</order-num>
    </header>
    <order-items>
        <item id="PICKLE">
            <price>2.25</price>
            <quantity>1000</quantity>
        </item>
        <item id="BANANA">
            <price>1.25</price>
            <quantity>400</quantity>
        </item>
    </order-items>
</ABCOrder>

对于目标 JSON 数据：

{"custId":"ACME-123","priority":"GOLD","orderId":"ORDER1","lineItems":[{"itemId":"PICKLE",
"amount":1000,"cost":2.25},{"itemId":"BANANA","amount":400,"cost":1.25

9.4. 创建转换测试文件并运行 JUnit 测试

右键单击 Project Explorer 视图中的 初学者 项目，然后选择 New → Other → Fuse Tooling → Fuse Transformation Test。
选择 Next 以打开 New Transformation Test 向导。

在 New Transformation Test 向导中，设置以下值：

字段	值
软件包	`example`
Camel 文件路径	`OSGI-INF/blueprint/blueprint.xml`
转换 ID	`xml2json`

点 Finish。
在 Project Explorer 视图中，导航到 starter/src/test/java/example，然后打开 TransformationTest.java 文件。

在转换方法中 添加以下代码 ：

startEndpoint.sendBodyAndHeader(readFile("src/data/abc-order.xml"), "approvalID", "AUTO_OK");

点 File → Save。
现在，您可以在这些教程中的任何点对转换文件运行 JUnit 测试。
在 Project Explorer 视图中，展开 初学者 项目，以公开 /src/test/java/example/TransformationTest.java 文件。
右键单击以打开上下文菜单，然后选择 Run as JUnit Test。
这时将打开 JUnit Test 窗格，以显示测试的状态。为了避免混淆您的工作区，请在 Console 视图旁的底部面板中拖放窗格。
打开 Console 视图以查看日志输出。

9.5. 将常量变量映射到数据项

当 source/target 数据项没有对应的目标/源数据项时，您可以将常量变量映射到现有数据项。

在 初学者 示例中，目标数据项 origin 没有对应的源数据项。将 origin 属性映射到常量变量：

在 Source 面板中，点 Variables 视图。
在 Variables 视图中，点打开 Enter a new variables name 对话框。
输入您要创建的变量的名称。
在 初学者示例中，输入 ORIGIN。
点击确定。
新创建的变量 ORIGIN 在 Name 列中的 Variables 视图中显示，默认值 ORIGIN 在 Value 列中显示。
单击默认值以对其进行编辑，并将值更改为 Web。
按 Enter 键。
将新变量 ORIGIN 拖放到 Target 面板中的原始数据项。
变量 $(ORIGIN) 的新映射会出现在 Mappings 面板中和详情窗格中。

对 TransformationTest.java 文件运行 JUnit 测试。详情请查看第 9.4 节 “创建转换测试文件并运行 JUnit 测试”。

Console 视图显示 JSON 格式的输出数据：

{"custId":"ACME-123","priority":"GOLD","orderId":"ORDER1","origin":"Web",
"approvalCode":"AUTO_OK","lineItems":[{"itemId":"PICKLE","amount":1000,"cost":2.25},
{"itemId":"BANANA","amount":400,"cost":1.25}]}

9.6. 将表达式映射到数据项目

例如，此功能允许您将目标数据项映射到 Camel 语言表达式的动态评估。

使用目标 approvalCode 数据项，它缺少对应的源数据项目：

点将一个空的转换映射添加到 Mappings 面板中。
在 Target 面板中，将 approvalCode 数据项拖放到映射中新创建的映射的目标字段。
approvalCode 数据项也会出现在详情窗格的目标框中。
在详情窗格中，点 ABCOrder 源框中的打开下拉菜单。
菜单选项取决于所选数据项目的数据类型。可用的选项有粗体显示。
选择 Set expression 以打开 Expression 对话框。
在 Language 中，从可用的列表中选择要使用的表达式语言。可用选项取决于数据项目的数据类型。
对于 初学者 示例，请选择 Header。
在详细信息窗格中，选择要使用的表达式的来源。
选项为 Value 和 Script。
对于 初学者 示例，单击 Value，然后输入 ApprovalID。
点击确定。
Mappings 面板和详情窗格都显示目标数据项目 approvalCode 的新映射。

对 TransformationTest.java 文件运行 JUnit 测试。详情请查看第 9.4 节 “创建转换测试文件并运行 JUnit 测试”。

Console 视图显示 JSON 格式的输出数据：

{"custId":"ACME-123","priority":"GOLD","orderId":"ORDER1","origin":"Web",
"approvalCode":"AUTO_OK","lineItems":[{"itemId":"PICKLE","amount":1000,"cost":2.25},
{"itemId":"BANANA","amount":400,"cost":1.25}]}

9.7. 将自定义转换添加到映射的数据项

当源数据项目不满足目标系统要求时，您可能需要修改源数据项的格式。

例如，要满足目标系统的要求，所有客户 ID 都用括号括起来：

在 Mappings 面板中，选择 customerNum 映射来填充详情窗格。
在详情窗格中，点 ABCOrder 源框中的打开下拉菜单。
选择 Add custom transformation 以打开 Add Custom Transformation 页面。
点 Class 字段旁的打开 Create a New Java Class 向导。
修改以下字段：
- 软件包 ProductShortName-wagonEnter 示例.
- 名称 wagon-wagonEnter MyCustomMapper.
- 方法 Name mvapich- iwlChange 映射到 方括号.
  所有其他字段保留原样。
点 Finish。
Add Custom Transformation 页面会打开，并自动填充 Class 和 Method 字段：
点 OK 在 Java 编辑器中打开 MyCustomMapper.java 文件：
编辑 括号 方法，将最后一行 返回 null;。
```
return "[" + input + "]";
```
点 transformation.xml 选项卡切回到转换编辑器。
详情窗格显示 括号 方法已与 customerNum 数据项关联。
括号 方法在将源输入发送到目标系统之前在源输入上执行。

对 TransformationTest.java 文件运行 JUnit 测试。详情请查看第 9.4 节 “创建转换测试文件并运行 JUnit 测试”。

Console 视图显示 JSON 格式的输出数据：

{"custId":"[ACME-123]","priority":"GOLD","orderId":"ORDER1","origin":"Web",
"approvalCode":"AUTO_OK","lineItems":[{"itemId":"PICKLE","amount":1000,"cost":2.25},
{"itemId":"BANANA","amount":400,"cost":1.25}]}

9.8. 将简单的数据项映射到集合中的数据项

在本教程中，您将修改现有映射，它将源中的所有 ids 映射到目标中的 itemIds。新映射将 Source 中的 customerNum data 项映射到 Target 中 lineItems 集合中第二个项目的 itemId。

在这个版本中，源中的 ids 不会被映射到 Target 中的 itemIds。

在 Mappings 面板中，选择映射 id mvapich-PROFILE&gt ; 项Id，以在详情窗格中显示映射。
在 Source 框中，点打开下拉菜单，然后选择 Set property。
在 Select a property 页面中，展开 标头 节点并选择 customerNum。点 OK 保存更改。
现在，详情窗格显示 XyzOrder 有一个 lineItems 字段。单击 lineItems 旁边的切换按钮，将其值增加到 1。
注意
索引基于零，因此值 1 在集合中选择 itemId 的第二个实例。
请注意，详细信息窗格显示 customerNum 映射到 lineItems 集合中第二个项目的 itemId。

对 TransformationTest.java 文件运行 JUnit 测试。详情请查看第 9.4 节 “创建转换测试文件并运行 JUnit 测试”。

Console 视图显示 JSON 格式的输出数据：

{"custId":"[ACME-123]","priority":"GOLD","orderId":"ORDER1","origin":"Web",
"approvalCode":"AUTO_OK","lineItems":[{"amount":1000,"cost":2.25},
{"itemId":"ACME-123","amount":400,"cost":1.25}]}

9.9. 在映射的数据项中添加内置功能

您可以使用内置字符串相关的功能来将转换应用到映射的数据项目。

在 Transformations 面板中，选择 status 到 priority mapping 来填充详情窗格。
在 Source 框中，点打开下拉菜单，然后选择 Add transformation。
在 Transformations 窗格中，选择 附加，然后在参数窗格中为后缀值输入 -level。
在将其映射到目标 优先级 数据项前，此 附加 函数会将指定的后缀添加到 状态 字符串的末尾。
点击确定。
默认情况下，详情窗格以用户友好格式显示将附加功能添加到 状态 数据项的结果。您可以通过点 Source 框中的右边并选择 Show standard format 来更改这种格式。

对 TransformationTest.java 文件运行 JUnit 测试。详情请查看第 9.4 节 “创建转换测试文件并运行 JUnit 测试”。

Console 视图显示 JSON 格式的输出数据：

{"custId":"[ACME-123]","priority":"GOLD-level","orderId":"ORDER1","origin":"Web",
"approvalCode":"AUTO_OK","lineItems":[{"amount":1000,"cost":2.25},{"itemId":"ACME-123",
"amount":400,"cost":1.25}]}

9.10. 将 Fuse 集成项目与数据转换发布到红帽 Fuse 服务器

在将数据转换项目发布到 Fuse 服务器前（请参阅第 29 章 将 Fuse 集成项目发布到服务器），您需要在 Fuse 运行时中安装以下功能：

camel-dozer
camel-jackson
camel-jaxb

在 Fuse 运行时上安装所需的功能：

如果还没有存在，切换到 Fuse Integration 视角。
如有必要，将 Fuse 服务器添加到 服务器 列表中（请参阅第 28.1 节 “添加服务器”）。
启动 Fuse Server （请参阅第 28.2 节 “启动服务器”），并等待 JBoss Fuse shell 出现在 Terminal 视图中。
对于每个所需的 camel- 功能，在 JBossFuse:admin@root > 提示类型中：
features:install camel-<featureName>
其中 featureName 是 dozer、jackson 或 jaxb 之一。
要验证每个功能是否已成功安装，在 JBossFuse:admin@root > 提示类型中：
features:list --ordered --installed
您应该看到刚刚在输出列表中安装的 camel 功能：

第 10 章为 Fuse 在线集成开发扩展

Fuse Online 是红帽 Fuse 功能，为集成应用程序提供 Web 界面。如果没有编写代码，业务专家可以使用 Fuse 在线连接到应用程序，并选择性地在不同应用程序之间的数据上运行。如果 Fuse Online 不提供集成商需要的功能，则开发人员可以创建定义所需行为的扩展。

您可以使用 Fuse 工具开发提供 Fuse 在线中使用的功能的扩展。扩展定义：

对集成连接间的数据操作的一个或多个自定义步骤
或
一个自定义 连接器

在 Fuse Online 中，连接器 代表特定的应用程序，用于从或向其获取数据。每个连接器都是用于创建与该特定应用程序连接的模板。例如，Salesforce 连接器是创建与 Salesforce 的连接的模板。如果 Fuse Online 不提供 Fuse Online 用户需要的连接器，您可以开发定义自定义连接器的扩展。

在 Fuse Online 中，集成连接之间发生的数据操作被称为步骤。Fuse Online 提供诸如过滤和映射数据等操作的步骤。要以 Fuse Online 内置步骤提供的方式在连接间操作数据，您可以开发定义一个或多个自定义步骤的 Fuse Online 扩展。

注意

您可能需要在您选择的 IDE 中开发扩展。无论您使用 Fuse 工具或其他 IDE，都完全是个人首选项。在任何 IDE 中开发扩展的信息是将应用程序与 Fuse 在线集成。

10.1. 任务概述

以下是开发 Fuse 在线扩展的任务概述：

在 Red Hat CodeReady Studio 中，创建一个 Fuse Online 扩展项目，然后选择 Custom Connector 或 Custom Step 作为扩展类型。
根据扩展类型，为扩展编写代码：
- 对于自定义 连接器 ：定义基本 Camel 组件、连接器图标、全局连接器属性和连接器操作。
- 对于自定义步骤：添加路由、定义操作并指定任何依赖项。
构建 .jar 文件。
为 Fuse Online 用户提供 .jar 文件。

Fuse Online 用户将 .jar 文件上传到 Fuse Online，这将使自定义连接器或自定义步骤可供使用。有关 Fuse 在线以及如何创建集成的详情，请参考将应用程序与 Fuse 在线集成。

10.2. 先决条件

开始之前，您需要以下信息和知识：

有关 Fuse 在线自定义连接器或步骤（来自 Fuse Online 用户）所需的功能的描述。
Fuse Online 扩展名版本号。
对于自定义连接器，以 PNG 或 SVG 格式的图标镜像文件。Fuse Online 在显示集成流时使用此图标。如果没有提供图标，则在上传包含扩展的 .jar 时，Fuse Online 会生成一个。
您应该熟悉：
- Fuse Online
- Spring Boot XML 或 Java
- Apache Camel 路由（如果您想要创建基于路由的步骤扩展）
- JSON
- Maven

10.3. 创建自定义连接器

在 Fuse Online 中，自定义连接器由一个或多个连接配置参数、一个或多个连接操作以及每个操作的可选配置参数。

以下是用于开发自定义连接器的任务概述：

在 Red Hat CodeReady Studio 中，创建一个 Fuse Online 扩展项目，然后选择 Custom Connector 作为扩展类型。
为扩展编写代码。定义基本 Camel 组件、连接器图标、全局连接器属性和连接器操作。

10.3.1. 为自定义连接器创建 Fuse Online 扩展项目

Fuse 工具 Fuse Online 扩展项目为自定义连接器提供了一个起点。

要创建 Fuse 工具 Fuse 在线扩展项目，请按照以下步骤操作：

在 Red Hat CodeReady Studio 中，选择 New → Project → Red Hat Fuse → Fuse Online Extension Project。
New Fuse Online Extension Project 向导将打开。
输入项目的名称和位置，然后单击 Next。
选择 Fuse Online 版本。
指定以下扩展详情：
- 在 Fuse Online 环境中定义且在 Fuse Online 环境中是唯一的 ID criu-wagonA 值。当 Fuse Online 用户导入扩展 .jar 文件时，该值将在 Fuse Online 中可见。
- 名称扩展名为 wagon-wagon。这个值将在 Fuse Online 作为扩展名称中看到。在 Fuse Online 中，在 Customizations → Extensions 选项卡中，用户可以看到上传到 Fuse Online 的扩展的名称和描述。
- 描述扩展内容的可选描述。
- 版本 criu-MAPPINGThe version of the extension.例如，如果这是初始版本，您可以键入 1.0。如果要更新版本，您可以键入 1.1 或 2.0。
为您要创建的 Fuse 在线扩展选择 Custom Connector。
点 Finish。

新项目会出现在 Red Hat CodeReady Studio Project Explorer 视图中。它包括以下用于自定义连接器扩展的文件：

在 src/main/resources/META-INF/syndesis 文件夹中：
- 描述符文件： syndesis-extension-definition.json
  这是您编辑的文件： * 添加顶级全局属性、连接器操作和操作属性。* 更改 Extension Id, Name, Version, 或 Description 值。
- 默认图标镜像文件： icon.png
  您可以选择将此文件替换为您自己的图标镜像(PNG 或 SVG)文件。

Maven 项目对象模型文件： pom.xml

此文件包含 Maven 用于构建项目的项目和配置详情的信息，包括默认扩展依赖项。您可以编辑此文件来添加自定义依赖项。红帽提供的任何依赖项的范围，例如：

<dependency>
    <groupId>io.syndesis.extension</groupId>
    <artifactId>extension-api</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <scope>provided</scope>
</dependency>

10.3.2. 为自定义连接器编写代码

创建 Fuse Online 扩展项目后，您可以编写根据 Fuse Online 用户为您提供所需功能的描述来定义自定义连接器元素的代码。表 10.1 “自定义连接器元素” 表显示您在 Fuse 工具中创建的自定义连接器元素如何与 Fuse Online 中的元素对应。

表 10.1. 自定义连接器元素
Fuse Tooling 元素	Fuse Online 元素	描述
全局（顶级）属性	连接配置参数	当 Fuse Online 用户从这个连接器创建连接时，用户会指定此属性的值作为连接的配置的一部分。
操作	连接操作	在 Fuse Online 中，对于从此连接器创建的连接，Fuse Online 用户选择这些操作之一。
操作中定义的属性	操作配置参数	当 Fuse Online 用户配置连接执行的操作时，Fuse Online 用户会指定此属性的值作为操作配置的一部分。

编写为 Fuse Online 实现自定义连接器的代码：

在 Editor 视图中打开 syndesis-extension-definition.json 文件，编写定义全局属性的代码，自定义连接器可以执行的操作以及每个操作的属性。

每个全局属性都对应 Fuse Online 中的连接配置参数。每个 action 属性都对应于 Fuse Online connection action 配置参数。在 Fuse Online 中，当用户选择自定义连接器时，Fuse Online 会提示输入每个连接配置参数的值。自定义连接器可用于使用 OAuth 协议的应用程序。在这种情况下，请确保为 OAuth 客户端 ID 指定全局属性，以及 OAuth 客户端 secret 的另一个全局属性。Fuse Online 用户需要为这些参数指定值，以便从此连接器创建的连接正常工作。

每个连接器操作都会 声明一个基本 Camel 组件方案。

New Fuse Online Extension Project 向导提供的示例使用 telegram Camel 组件方案：

{
  "schemaVersion" : "v1",
  "name" : "Example Fuse Online Extension",
  "extensionId" : "fuse.online.extension.example",
  "version" : "1.0.0",
  "actions" : [ {
    "id" : "io.syndesis:telegram-chat-from-action",
    "name" : "Chat Messages",
    "description" : "Receive all messages sent to the chat bot",
    "descriptor" : {
      "componentScheme" : "telegram",
      "inputDataShape" : {
        "kind" : "none"
      },
      "outputDataShape" : {
        "kind" : "java",
        "type" : "org.apache.camel.component.telegram.model.IncomingMessage"
      },
      "configuredProperties" : {
        "type" : "bots"
      }
    },
    "actionType" : "connector",
    "pattern" : "From"
  }, {
    "id" : "io.syndesis:telegram-chat-to-action",
    "name" : "Send a chat Messages",
    "description" : "Send messages to the chat (through the bot).",
    "descriptor" : {
      "componentScheme" : "telegram",
      "inputDataShape" : {
        "kind" : "java",
        "type" : "java.lang.String"
      },
      "outputDataShape" : {
        "kind" : "none"
      },
      "propertyDefinitionSteps" : [ {
        "description" : "Chat id",
        "name" : "chatId",
        "properties" : {
          "chatId" : {
            "kind" : "parameter",
            "displayName" : "Chat Id",
            "type" : "string",
            "javaType" : "String",
            "description" : "The telegram's Chat Id, if not set will use CamelTelegramChatId from the incoming exchange."
          }
        }
      } ],
      "configuredProperties" : {
        "type" : "bots"
      }
    },
    "actionType" : "connector",
    "pattern" : "To"
  } ],
  "properties" : {
    "authorizationToken" : {
      "kind" : "property",
      "displayName" : "Authorization Token",
      "group" : "security",
      "label" : "security",
      "required" : true,
      "type" : "string",
      "javaType" : "java.lang.String",
      "secret" : true,
      "description" : "Telegram Bot Authorization Token"
    }
  }
}

如果自定义连接器需要额外的依赖项，请将它们添加到项目的 pom.xml 文件中。依赖项的默认范围是 runtime。如果您添加了红帽提供的依赖项，请自行定义其范围，例如：
```
<dependencies>
    <dependency>
          <groupId>org.apache.camel</groupId>
          <artifactId>camel-telegram</artifactId>
          <scope>provided</scope>
    </dependency>
      </dependencies>
```

完成自定义连接器的代码编写后，构建 .jar 文件，如第 10.5 节 “构建 Fuse Online 扩展 JAR 文件” 所述。

10.4. 创建自定义步骤

创建 Fuse Online 扩展项目后，您可以编写根据 Fuse Online 用户为您提供所需功能的描述来定义自定义步骤的代码。在单一扩展中，您可以定义多个自定义步骤，您可以使用 Camel 路由或使用 Java Bean 定义每个自定义步骤。

10.4.1. 为自定义步骤创建 Fuse 在线扩展项目

要创建 Fuse 工具 Fuse 在线扩展项目，请按照以下步骤操作：

在 Red Hat CodeReady Studio 中，选择 New → Project → Red Hat Fuse → Fuse Online Extension Project。
New Fuse Online Extension Project 向导将打开。
输入项目的名称和位置，然后单击 Next。
选择 Fuse Online 版本。
指定以下扩展详情：
- 在 Fuse Online 环境中定义且在 Fuse Online 环境中是唯一的 ID criu-wagonA 值。当 Fuse Online 用户导入扩展 .jar 文件时，该值将在 Fuse Online 中可见。
- 名称扩展名为 wagon-wagon。这个值将在 Fuse Online 作为扩展名称中看到。在 Fuse Online 中，在 Customizations → Extensions 选项卡中，用户可以看到上传到 Fuse Online 的扩展的名称和描述。
- 描述扩展内容的可选描述。
- 版本 criu-MAPPINGThe version of the extension.例如，如果这是初始版本，您可以键入 1.0。如果要更新版本，您可以键入 1.1 或 2.0。
为您要创建的 Fuse 在线扩展选择 Custom Step。
为自定义步骤选择模板：
- Camel route criu-wagonProvides 示例 Camel 路由。
- Java bean criu-wagonProvides 一个 Java bean 示例。
  注意
  您选择的模板为您的项目提供一个起点。如果要基于 Camel 路由创建一个或多个自定义步骤，以及基于同一扩展中的 Java Bean 的一个或多个自定义步骤，请从其中一个模板开始，然后为其他类型的自定义步骤添加所需的文件和依赖项。
点 Finish。

新项目会出现在 Red Hat CodeReady Studio Project Explorer 视图中。它包括以下文件，具体取决于您为自定义步骤选择的模板：

在 src/main/resources/META-INF/syndesis 文件夹中：
- 描述符文件： syndesis-extension-definition.json
  这是您编辑的文件： * 添加一个或多个操作。'.json 'file 中的操作成为 Fuse Online 的自定义步骤。在操作元素中，'.json 'file 中的属性成为 Fuse Online 中的 step 配置参数。* 更改 Extension Id, Name, Version, 或 Description 值。
- 对于 Camel 路由模板，Camel 上下文文件： extensions/log-body-action.xml
  此文件包含带有日志组件的示例路由。您可以在此文件中自定义 Camel 路由。
- 对于 Java bean 模板，Java 文件： extensions/extension.java
  此文件包含基于 POJO 的日志记录扩展示例。

Maven 项目对象模型文件： pom.xml

<dependency>
    <groupId>io.syndesis.extension</groupId>
    <artifactId>extension-api</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <scope>provided</scope>
</dependency>

10.4.2. 为自定义步骤编写代码

创建 Fuse Online 扩展项目后，您编写了根据 Fuse Online 用户为您提供所需功能的描述自定义步骤的代码。

表 10.2 “自定义步骤元素” 显示您在 Fuse 工具中创建的自定义步骤元素如何与 Fuse Online 中的元素对应。

表 10.2. 自定义步骤元素
Fuse Tooling 元素	Fuse Online 元素	描述
操作	自定义步骤	在 Fuse Online 中，在用户导入步骤扩展后，在 Choose a step 页面中显示自定义步骤。
操作中定义的属性	自定义步骤配置参数	在 Fuse Online 中，当用户选择自定义步骤时，Fuse Online 会提示输入配置参数的值。

要编写为 Fuse Online 实现自定义步骤的代码：

对于基于 Camel 路由的步骤，在 extension.xml 文件中，创建处理扩展目的的路由。每个路由的入口点必须与您在 syndesis-extension-definition.json 文件中定义的入口点匹配，如第 2 步所述。
对于基于 Java bean 的步骤，编辑 java 文件。
在 syndesis-extension-definition.json 文件中，编写定义操作及其属性的代码。每个入口点都需要一个新的操作。
您创建的每个操作都与 Fuse Online 中的自定义步骤对应。您可以为每个操作使用不同类型的代码。也就是说，您可以对一个操作使用 Camel 路由，并将 Java bean 用于另一个操作。
每个属性都对应一个 Fuse Online step 配置参数。在 Fuse Online 中，当用户选择自定义步骤时，Fuse Online 会提示输入配置参数的值。例如，自定义日志步骤可能有一个 level 参数，它指示要发送到日志的信息量。
以下是包含扩展元数据的 .json 文件模板，包括用户在 Fuse Online 中用户填充的属性，并在上传扩展并将其自定义步骤添加到集成后：
```
{
  "actions": [
    {
      "actionType": "extension",
      "id": "${actionId}",
      "name": "Action Name",
      "description": "Action Description",
      "tags": [
           "xml"
      ],
      "descriptor": {
        "kind": "ENDPOINT|BEAN|STEP",
        "entrypoint": "direct:${actionId}",
        "inputDataShape": {
          "kind": "any"
        },
        "outputDataShape": {
          "kind": "any"
        },
        "propertyDefinitionSteps": []
      }
    }
  ],
  "tags": [
    "feature",
    "experimental"
  ]
}
```
注意
本发行版本中会忽略标签。保留它们供以后使用。
要编辑扩展依赖项，请在编辑器中打开 'pom.xml 'file。如果添加依赖项，则必须定义其范围。

完成自定义步骤的代码编写后，构建 .jar 文件，如第 10.5 节 “构建 Fuse Online 扩展 JAR 文件” 所述。

10.5. 构建 Fuse Online 扩展 JAR 文件

为扩展构建 .jar 文件：

在 Project Explorer 视图中，右键单击项目。
在上下文菜单中，选择 Run As → Maven clean verify。
在 Console 视图中，您可以监控构建的进度。
构建完成后，在 Project Explorer 视图中刷新目标文件夹（选择项目，然后按 F5）。

在 Project Explorer 视图中，打开目标文件夹来查看生成的 .jar 文件：

.jar 文件的名称遵循 Maven 默认值 ：${artifactId}-${version}.jar

例如： custom:step-camel-1.0.0.jar

此 .jar 文件定义扩展、其所需依赖项及其元数据：Extension Id, Name, Version, Tags, 和 Description。例如：

{
    "schemaVersion" : "v1",
    "name" : "Example Fuse Online Extension",
    "description" : "Logs a message body with a prefix",
    "extensionId" : "fuse.online.extension.example",
    "version" : "1.0.0",
    "actions" : [ {
        "id" : "Log-body",
        "name" : "Log Body",
        "description" : "A simple xml Body Log with a prefix",
        "descriptor" : {
            "kind" : "ENDPOINT",
            "entrypoint" : "direct:log-xml",
            "resource" : "classpath:META-INF/syndesis/extensions/log-body-action.xml",
            "inputDataShape" : {
                "kind" : "any"
            },
            "outputDataShape" : {
                "kind" : "any"
            },
            "propertyDefinitionSteps" : [ {
                "description" : "Define your Log message",
                "name" : "Log Body",
                "properties" : {
                    "prefix" : {
                        "componentProperty" : false,
                        "deprecated" : false,
                        "description" : "The Log body prefix message",
                        "displayName" : "Log Prefix",
                        "javaType" : "String",
                        "kind" : "parameter",
                        "required" : false,
                        "secret" : false,
                        "type" : "string"
                    }
                }
            } ]
        },
        "tags" : [ "xml" ],
        "actionType" : "step"
    } ],
    "dependencies" : [ {
        "type" : "MAVEN",
        "id" : "io.syndesis.extension:extension-api:jar:1.3.0.fuse-000014"
    } ],
    "extensionType" : "Steps"
}

10.6. 为 Fuse Online 用户提供 JAR 文件

为 Fuse Online 用户提供以下内容：

.jar 文件
描述扩展的文档。对于步骤扩展，包括有关步骤扩展中的每个操作的数据信息，需要作为输入或提供作为输出（用于数据映射）的输入。

在 Fuse Online 中，用户上传 .jar 文件，如 Integrating Applications with Fuse Online 所述。

第 11 章创建新 Camel XML 文件

概述

Apache Camel 将路由存储在包含 camelContext 元素的 XML 文件中。当您创建新的 Fuse 集成项目时，工具默认提供 Apache Camel 上下文(XML)文件。

您还可以添加新的 Camel XML 文件，其中包含预配置和模板 camelContext 元素的所有所需命名空间。

流程

在项目中添加新的 Apache Camel 上下文文件：

从主菜单中选择 File → New → Camel XML File，以打开 Camel XML File 向导，如图 11.1 “Camel XML File 向导” 所示。
图 11.1. Camel XML File 向导
在 RouteContainer 中，输入新文件的位置，或者接受默认值。
您可以点搜索适当的位置。
重要
Spring 框架和 OSGi 蓝图框架要求将所有 Apache Camel 文件放在项目的 META-INF 或 OSGI-INF 文件夹下的特定位置：
- Spring - projectName/src/main/resources/META-INF/spring/
- OSGi Blueprint - projectName/src/main/resources/OSGI-INF/blueprint/
在 File Name 中，输入新上下文文件的名称，或者接受默认值(camelContext.xml)。
文件的名称不能包含空格或特殊字符，且它在 JVM 中必须是唯一的。
在框架中，接受默认值，或者选择路由要使用的框架：
- Spring ProductShortName-unmarshal[default] 用于要在 Spring 容器、非OSGi 容器中部署的路由，或作为独立应用程序
- OSGi Blueprint mvapich- iwlfor 将要在 OSGi 容器中部署的路由
- 路由可以加载并添加到现有 camelContexts 的路由
点 Finish。
新上下文文件添加到项目中，并在路由编辑器中打开。

第 12 章更改 Camel 版本

使用 Fuse 工具项目时，您可能想要更改其使用的 Camel 版本。例如，如果您想要使用最新 Camel 版本支持的功能，或者想要使用社区版本，这非常有用。

更改项目使用的 Camel 版本：

在 Project Explorer 中，右键单击您要更改 Camel 版本的项目，然后选择 Configure → Change Camel Version。
在 Change Camel Version 窗口的 Camel Version 字段右侧，单击 down caret 以显示可用的 Camel 版本。
要使用 Apache Camel 的社区版本，请输入其版本号，例如 2.19.2。
选择或输入您想要的版本并点 Finish。

Fuse Tooling 检查您选择的版本是否可用，并被 Fuse Tooling 支持。如果是 Fuse Tooling，则 Fuse Tooling 会更改 Camel 版本，并保存项目的更新的 pom.xml 文件。如果您选择的 Camel 版本不可用或不支持，您会收到错误消息。

您可以在其 pom.xml 文件中检查项目的 Camel 版本（在 < camel.version> 元素中）。

第 13 章导入现有的 Maven 项目

概述

您可能想要导入现有项目，例如，用作模板或开发应用程序的起点。

例如，新建 Fuse Integration Project 向导将指向以下 Github 存储库作为示例的源：

下载示例项目后，您可以将其导入到 CodeReady Studio。

流程

导入现有的 Maven 项目：

选择 File → Import → Maven → Existing Maven Projects，然后点 Next。
对于 Root Directory，选择包含下载的示例项目的文件夹。
在项目列表中，检查您要导入的项目，然后单击 Finish。

部分 II. 调试路由上下文

Camel 调试器包含许多用于本地和远程运行路由上下文调试的功能：

在路由编辑器中的节点上设置条件和无条件断断点
自动启动调试器并切换到 Debug 透视图
与正在运行的路由上下文交互：
- 在断点间切换，以快速比较消息实例的变量值
- 检查并更改感兴趣的变量值
- 将感兴趣的变量添加到 watch 列表中，以便在 debug 会话中跟踪它们
- 禁用并重新启用断点
- 在路由上下文运行时以图形方式跟踪消息流
- 检查控制台日志来跟踪 Camel 和调试器操作

注意

在运行 Camel 调试器前，您必须在路由编辑器显示的节点上设置断点。然后，您可以在项目的路由上下文 .xml 文件上运行 Camel 调试器，以查找其中的逻辑错误并修复它们。调用 Camel 调试器在调试模式下运行路由上下文，并打开 Debug Perspective。

第 14 章设置 Breakpoints

概述

要设置断点，必须在路由编辑器的 Design 选项卡中打开您的项目的路由上下文 .xml 文件。

Camel 调试器支持两种类型的断点：

在调试会话中遇到时，无条件断断点s iwl- iwltriggered
只有在调试会话中满足了断点指定条件时，条件断点才会被触发

注意

您不能对消费者端点或节点 设置 断点。

设置无条件断点

在 Design 选项卡中显示您的路由上下文：

选择您要在调试会话期间检查的状态的节点。
点击其图标设置无条件断点。
对您要在其上设置无条件断点的每个节点重复这些步骤。

设置条件断点

在 Design 选项卡中显示您的路由上下文：

选择一个您要在调试会话中检查的状态的节点。
点击其图标设置一个条件断点，并打开 Edit the condition 和您的 breakpoint… 对话框的语言 ：
单击 Language 下拉菜单，再选择要使用的表达式语言来创建将触发断点的条件。
Fuse 工具支持 twenty-four 表达式语言。其中一些语言提供用于创建条件表达式的变量，而其他语言则没有。
Click Variables 以显示所选语言支持的变量的列表。
如果出现列表，请选择一个或多个变量，以创建触发断点的条件。您选择的变量会出现在 Condition 文本框中。
如果出现，在 Condition 文本框中直接输入表达式。
对您要为其设置条件断点的每个节点重复 [condBpFirst] 到 [condBpLast] 的步骤。

禁用断点

您可以临时禁用断点，将其保留原位，然后再次启用它。 resume co 按钮会在调试会话过程中跳过禁用的断点。

要禁用断点，请选择 canvas 上的节点并点击其 gray dot 图标。断点会打开灰色，表示它已被禁用。

要启用禁用的断点，请选择 canvas 中的节点并点击其 green dot 图标。根据禁用的断点是条件还是无条件，它会分别打开 yellow 或 red，以指示它已被重新启用。

注意

您还可以在调试会话过程中禁用和重新启用断点。详情请查看第 19 章 在运行上下文中禁用断点。

删除断点

您可以删除单独的断点或所有断点。

要删除单个断点点(Route container)，请选择您要删除的断点的节点，然后点其图标。
要删除特定路由中的所有断点，点目标路由的容器，然后选择 Delete all breakpoints。
要删除所有路由的所有断点，点 canvas，然后选择 Delete all breakpoints。

第 15 章运行 Camel Debugger

您可以在本地运行路由上下文上运行 Camel 调试器。

注意

不再支持远程调试。对于远程调试，您必须配置 Jolokia，并通过 Jolokia 创建特定的 JMX 连接。
如果您的项目包含 Java 代码，您可以使用标准的 Eclipse Java 调试工具对其进行调试。

在启动 Camel 调试器前，您必须在路由上下文文件中设置断点。

流程

在 Project Explorer 视图中，选择要调试的路由上下文文件。
右键单击所选文件以打开上下文菜单，然后选择 Debug As → Local Camel Context。
Fuse Tooling 构建 Camel 路由，启动 Apache Camel，启动路由上下文，启用 JMX，在路由上下文中启动路由，将断点添加到节点，并启用 Camel 调试器。
Camel 调试器会在第一个断点命中（接收消息）挂起路由上下文的执行，并提示您指示它是否要打开 Debug 透视图。
单击 Yes 以打开 Debug 透视图。
Debug 透视图会打开，并在运行的路由上下文中遇到的第一个断点时暂停路由上下文。
重要
断点在最多五分钟内，等待最多五分钟，然后调试自动恢复，进入下一个断点或路由上下文的末尾。
注意
要查看控制台输出，请在切换视角时打开 Console 视图。
注意
默认情况下，Debug 透视图显示 outline 视图，它提供了在正在运行的路由上下文中切换独立路由的方法。如果您的路由上下文包含单一路由，请关闭 outline 视图可释放空间来扩展其他视图，从而使访问和检查调试器输出变得更加容易。

通过路由上下文监视消息交换进度

点 stepover co (Step Over)在路由上下文中跳到下一个执行节点。点 resume co （恢复）在路由上下文中的下一个活跃断点继续执行。

第 16 章停止 Camel Debugger

概述

要停止 Camel 调试器，如果调试会话终止，点菜单栏上的 Terminate button 。否则，点两次：终止当前运行的节点线程，一次终止 Camel 上下文 线程（在 Debug 视图中显示）。

注意

终止 Camel 调试器也会终止控制台，但不会清除其输出。要清除输出，请点击 Console 视图菜单栏中的 clear co (Clear Console )。

关闭 Camel 调试器

调试完项目后，您可能希望关闭 Debug 透视图，为您的工作台提供更多空间。

要做到这一点，请右键单击 CodeReady Studio 工具右侧的 Debug perspective icon ，然后选择 Close。

第 17 章更改变量值

概述

当 Camel 调试器到达断点时，变量视图会在路由上下文中显示该点上所有可用变量的值。有些变量可以被编辑，允许您更改其值。这可让您查看应用程序如何处理程序状态的更改。

注意

并非所有变量都可以编辑。可编辑变量的上下文菜单显示 Change Value… 选项。

流程

更改变量的值：

如有必要，启动 debugger。请参阅第 15 章 运行 Camel Debugger。
在 Variables 视图中，选择要更改的值的变量，然后点其 Value 字段。
变量的值 字段将打开一个更轻的蓝色形象，表示它处于编辑模式。
注意
或者，您也可以右键单击变量以打开其上下文菜单，然后选择 Change Value… 以编辑其值。
输入新值，然后点 Enter。
Console 视图显示 INFO 级别日志条目，而不是在变量的值中修改（例如，节点 to1 的明点在 exchangeId: ID-dhcp-97-16-bos-redhat-com-52574-1417298894070-0-2 with header: Destination 和 value: UNITED KINGDOM ）上更新消息标头。
继续分步到断点，并检查消息是否按预期处理。在每一步，检查 Debug 视图、变量视图和 控制台输出。

第 18 章在 Watch 列表中添加变量

概述

通过在监视列表中添加变量，您可以专注于特定的变量，查看其值在路由上下文上按预期更改。

流程

在 watch 列表中添加一个变量：

如有必要，启动 debugger。请参阅第 15 章 运行 Camel Debugger。
在 Variables 视图中，右键单击您要跟踪的变量以打开上下文菜单。
选择 Watch。
一个新的视图 Expressions 在 Breakpoints 视图旁边打开。Expressions 视图显示正在监视的变量的名称及其当前值，例如：
重复 [watch1] 和 [watch2]，将额外变量添加到监视列表中。
注意
您添加的变量在监视列表中保留，直到您删除为止。要停止观察变量，请在列表中右键单击它以打开上下文菜单，然后单击 Remove。
打开 Expressions 视图后，逐步浏览路由上下文，以跟踪 watch 列表中每个变量的值在到达路由中的每个步骤时如何变化。

第 19 章在运行上下文中禁用断点

概述

您可以在 Breakpoints 视图中的正在运行的路由上下文中禁用和重新启用断点。

当禁用断点时， resume co 按钮会导致调试器在调试会话过程中跳过它。

在 Breakpoints 视图中禁用并启用断点

这会打开 Breakpoints 视图，并启用了所有 set breakpoints。

要禁用断点，请清除其复选框。

对于您禁用的每个断点，Console 视图会显示一个 INFO 级别日志条目，表示它已被禁用（例如，删除断点 log2）。同样，对于您重新启用的每个断点，Console 视图会显示一个 INFO 级别日志条目，表示它已被启用（例如，添加断点 log2）。

注意

要重新启用禁用的断点，请单击其复选框。Console 视图显示一个 INFO 级别日志条目，表示断点已添加到所选节点。

部分 III. 监控和测试应用程序

JMX Navigator 视图提供了多种监控和测试 Fuse 应用程序的方法。

注意

您还可以使用 Fuse 控制台监控 Fuse 应用程序，如管理 Fuse 所述。

第 20 章 JMX Navigator

图 20.1 “JMX Navigator 视图” 中显示的 JMX Navigator 视图显示所有应用程序中运行的进程，并驱动与监控和测试功能的所有交互。Fuse Integration 视角的其他区域适应显示与 JMX Navigator 视图中选择的节点相关的信息。在 JMX Navigator 视图中，其上下文菜单提供了激活路由追踪和添加 JMS 目的地所需的命令。

图 20.1. JMX Navigator 视图

默认情况下，JMX Navigator 视图发现所有在本地机器上运行的 JMX 服务器，并在以下类别下列出它们：

本地进程
服务器连接
用户定义的连接

注意

您可以使用服务器的 JMX URL 添加其他 JMX 服务器。详情请查看第 20.2 节 “添加 JMX 服务器”。

20.1. 查看 JMX 中的进程

概述

JMX Navigator 视图列出了一系列树中的所有已知进程。每个树的根是一个 JMX 服务器。

列表中的第一个树是特殊的本地进程树，包含本地计算机上运行的所有 JMX 服务器。您必须连接到 JMX 服务器之一才能查看其包含的进程。

查看本地 JMX 服务器中的进程

查看本地 JMX 服务器中的进程信息：

在 JMX Navigator 视图中，展开 Local Process。
在 Local process 下，双击顶级条目之一以连接它。
点条目旁的图标显示它在 JVM 中运行的组件列表。

查看备用 JMX 服务器中的进程

查看备用 JMX 服务器中的进程信息：

第 20.2 节 “添加 JMX 服务器” JMX Navigator 视图的 JMX 服务器.
在 JMX Navigator 视图中，使用条目旁边出现的图标扩展服务器条目。这将显示 JMX 服务器的组件列表，这些组件在 JVM 中运行。

20.2. 添加 JMX 服务器

概述

在 JMX Navigator 视图中，在树的本地进程分支下，您可以看到所有本地 JMX 服务器的列表。您可能需要连接到特定的 JMX 服务器，以查看其他计算机上部署的组件。

要添加 JMX 服务器，您必须知道要添加的服务器的 JMX URL。

流程

要在 JMX Navigator 视图中添加 JMX 服务器：

在 JMX Navigator 视图中，点 New Connection 。
在 Create a new JMX connection 向导中，选择 Default JMX Connection。
点击 Next。
选择 Advanced 选项卡。
在 Name 字段中输入 JMX 服务器的名称。
名称可以是任意字符串。它用于标记 JMX Navigator 树中的条目。
在 JMX URL 字段中，输入服务器的 JMX URL。
如果 JMX 服务器需要身份验证，请在 Username 和 Password 字段中输入您的用户名和密码。
点 Finish。
新的 JMX 服务器作为分支出现在 用户定义的连接 树中。

第 21 章查看组件的 JMX 统计

概述

该工具收集 Fuse 组件报告的所有 JMX 统计，并在 Properties 视图中显示它们。此统计信息可对您的集成应用程序中发生的情况提供重大洞察。

JMX 统计数据分为三种类别：属性、Wi ler 和 Profile。

流程

查看 Fuse 组件的统计信息：

在 JMX Navigator 视图中，找到组件的节点。
您可能需要扩展树上的节点以查找低级别组件。
选择您要查看其统计的 Fuse 组件的节点。
打开 Properties 视图。
Properties 页面显示所选组件的 JMX 属性：
点 Processors 检查所选组件的交换指标：
点 Profile 检查所选节点及其子节点的消息指标：

第 22 章浏览消息

概述

在分布式环境中调试应用中的关键工具是查看应用中存储在 JMS 目的地和路由端点中的所有消息。工具可浏览以下内容：

JMS 目的地
JMS 路由端点
Apache Camel 路由端点
SEDA 路由端点
浏览路由端点
模拟路由端点
VM 路由端点
Dataset 路由端点

流程

浏览信息：

在 JMX Navigator 视图中，选择您要浏览的 JMS 目标或端点。
消息列表会出现在 Messages View 中。
在 Messages View 中，选择要检查的单个消息。
在 Properties 视图中显示消息详情和内容：

第 23 章追踪路由

调试路由通常涉及解决两个问题之一：

消息被错误地转换。
消息无法访问其目标端点。

通过路由跟踪一个或多个测试消息是发现此类问题来源的最简单方法。

工具的路由追踪功能可让您监控消息通过路由的路径，并查看消息在从处理器传递给处理器时如何转换。

图表视图显示路由的图形表示，可让您查看消息通过的路径。对于路由中的每个处理器，它还显示自路由启动以来处理的所有消息的平均处理时间（以毫秒为单位），以及路由启动以来处理的消息数量。

Messages 视图显示由 JMX Navigator 树中选择的 JMS 目的地或路由端点处理的消息。在 Messages View 中选择单个消息跟踪会在 Properties 视图中显示消息的完整详情和内容，并突出显示 Diagram View 中的 correspoding 节点。

通过路由追踪信息涉及以下步骤：

第 23.1 节 “为路由追踪创建测试消息”
第 23.2 节 “激活路由追踪”
第 23.3 节 “通过路由上下文追踪消息”
第 23.4 节 “停用路由追踪”

23.1. 为路由追踪创建测试消息

概述

路由追踪可用于任何类型的消息结构。Fuse Message 向导会创建一个空的 .xml 消息，保留信息的结构。

注意

如果要存储测试消息的文件夹不存在，则需要在创建消息前创建它。

创建新文件夹以存储测试消息

要创建新文件夹，请执行以下操作：

在 Project Explorer 视图中，右键单击项目 root 以打开上下文菜单。
选择 New → Folder 以打开 New Folder 向导。
项目 root 显示在 Enter 或选择父文件夹 字段中。
在项目层次结构的图形表示中扩展节点，然后选择您要作为父文件夹的节点。
在 Folder name 字段中，输入新文件夹的名称。
点 Finish。
新文件夹会出现在所选父文件夹下的 Project Explorer 视图中。
注意
如果没有显示新文件夹，请右键单击父 foler，然后选择 Refresh。

创建测试信息

创建测试信息：

在 Project Explorer 视图中，右键单击项目以打开上下文菜单。
选择 New → Fuse Message 来打开 New File 向导。
在项目层次结构的图形表示中展开节点，再选择要存储新测试消息的文件夹。
在 File name 字段中，输入消息的名称，或者接受默认(message.xml)。
点 Finish。
新消息在 XML 编辑器中打开。
输入消息内容，包括正文和标头文本。
注意
根据您输入的标头文本，您可能会看到 文档中引用的警告、No grammar 约束(DTD 或 XML Schema)。您可以安全地忽略这个警告。

23.2. 激活路由追踪

概述

您必须激活路由上下文的路由追踪，然后才能通过该路由上下文跟踪消息。

流程

在路由上下文中激活追踪：

在 JMX Navigator 视图中，选择要在其上启动追踪的运行路由上下文。
注意
您可以在上下文中选择任何路由，以便在整个上下文中启动追踪。
右键单击所选路由上下文以打开上下文菜单，然后选择 Start Tracing 以启动 trace。
如果在上下文菜单中启用了 Stop Tracing Context，则追踪已激活。

23.3. 通过路由上下文追踪消息

概述

查看路由上下文中发生的情况的最佳方法是监控每次停止消息时发生的情况。该工具提供了一种将消息丢弃到正在运行的路由上下文的机制，并追踪消息通过的路径。

流程

通过路由上下文跟踪信息：

如第 23.1 节 “为路由追踪创建测试消息” 所述，创建一个或多个测试信息。
在 Project Explorer 视图中，右键单击项目的 Camel 上下文文件以打开上下文菜单，然后选择 Run As → Local Camel Context (without Tests)。
注意
除非已为项目创建了全面的 JUnit 测试，否则不要将其作为 Local Camel Context 运行。
激活正在运行的路由上下文的追踪，如第 23.2 节 “激活路由追踪” 所述。
将其中一个测试消息从 Project Explorer 视图拖到 JMX Navigator 视图中的路由上下文起点。
在 JMX Navigator 视图中，选择 traced 的路由上下文。
这些工具会填充 Messages View，其中包含代表 traced 上下文中的每个阶段的消息实例。
图表视图 显示所选路由上下文的图形表示。
在 Messages View 中，选择一个消息实例。
Properties 视图显示消息实例的详情和内容。
在 图视图 中，突出显示与所选消息实例对应的路由步骤。如果路由步骤是一个处理步骤，工具会使用时间和处理指标标记退出路径。
根据需要重复此计划。

23.4. 停用路由追踪

概述

在路由上下文中调试路由后，您应该取消激活追踪。

重要

停用追踪会停止追踪并清除路由上下文中所有路由的 trace 数据。这意味着您无法查看任何以前的追踪会话。

流程

停止路由上下文的追踪：

在 JMX Navigator 视图中，选择要取消激活追踪的运行路由上下文。
注意
您可以在上下文中选择任何路由来停止上下文的追踪。
右键单击所选路由上下文以打开上下文菜单，然后选择 Stop Tracing Context。
如果上下文菜单中出现 Start Tracing，则不会为路由上下文激活追踪。

第 24 章管理 JMS 目的地

JMX Navigator 视图允许您在红帽 Fuse 的运行实例中添加或删除 JMS 目的地。

重要

这些更改不会在代理重启后保留。

24.1. 添加 JMS 目的地

概述

测试新场景时，可以方便地将新的 JMS 目的地添加到您的其中一个代理。

流程

将 JMS 目的地添加到代理中：

在 JMX Navigator 视图中，在您要添加目的地的代理节点中，选择 Queues 子或主题子项。
右键单击所选节点以打开上下文菜单，然后选择 Create Queue 或 Create Topic。
在 Create Queue 或 Create Topic 对话框中，为新目的地输入一个名称。
点击确定。
右键单击 Queues 或 Topics 子级，然后选择 Refresh。
新目的地会出现在 Queues 子子或主题子下的 JMX Navigator 视图中。

24.2. 删除 JMS 目的地

概述

在测试故障转移方案或其他涉及处理故障的情况时，可以轻松地删除 JMS 目的地会很有帮助。

流程

删除 JMS 目的地：

在 JMX Navigator 视图中，在 Queues 子或主题子级下，选择您要删除的 JMS 目的地。
右键单击所选目的地以打开上下文菜单，然后选择 Delete Queue/Topic。

第 25 章管理路由端点

JMX Navigator 视图允许您添加或删除路由端点。

重要

这些更改不会在路由上下文重启后保留。

25.1. 添加路由端点

概述

在测试新场景时，您可能想要在路由上下文中添加新端点。

流程

将端点添加到路由上下文：

在 JMX Navigator 视图中，在路由上下文节点上，选择要向其添加端点的 Endpoints 子级。
右键单击所选节点以打开上下文菜单，然后选择 Create Endpoint。
在 Create Endpoint 对话框中，输入定义新端点的 URL，例如 file://target/messages/validOrders。
点击确定。
右键单击路由上下文节点，然后选择 Refresh。
新目的地会出现在 Endpoints 节点下的 JMX Navigator 视图中，它对应于它的端点类型，例如文件。

25.2. 删除路由端点

概述

当测试故障转移场景或其他涉及处理故障的情况时，可以从路由上下文中删除端点会很有帮助。

流程

删除路由端点：

在 JMX Navigator 视图中，选择您要删除的端点。
右键单击所选端点以打开上下文菜单，然后选择 Delete Endpoint。
这些工具会删除端点。
要从视图中删除已删除的端点，请右键单击 Endpoints 节点，然后选择 Refresh。
端点会从 JMX Navigator 视图中消失。
注意
要从 Project Explorer 视图中删除端点的节点，而无需重新运行项目，您需要通过右键单击节点并选择 Delete 来显式删除它。要从视图中移除，请刷新项目显示。

第 26 章编辑运行的路由

概述

您可以试验对正在运行的路由的更改，而无需更改项目的路由上下文。

要做到这一点：

在 JMX Navigator 视图中，在运行的路由上下文上启用 Edit Routes 选项。
这会打开一个内存中的 in-memory model of it iwl- Remote CamelContext:<camelContextId&gt; iwl-osgi in the route editor。
在路由编辑器中，对路由上下文的内存中模型进行更改。同时，您可以在相关节点上设置断点，以使用 Camel 调试器及其所有功能。
您可以编辑内存模型来添加、删除或重新安排节点；要添加或删除现有节点的属性；以及修改现有节点上设置的属性值。您必须保存对内存模型所做的更改以更新正在运行的上下文，并在设置了断点时查看 Debug 透视图的结果。
在 JMX Navigator 视图中，丢弃正在运行的路由上下文的消息，或者等待消息到达计时器、ActiveMQ、文件或其他持续输入节点。
在 Debug 透视图中，评估结果并使用 Camel 调试器深入了解您的路由上下文。

修改正在运行的路由并评估结果

在 JMX Navigator 视图中，选择包含您要编辑的路由的路由上下文。
右键单击所选路由上下文以打开上下文菜单，然后选择 Edit Routes。
路由编辑器打开路由上下文的内存中模型 Remote CamelContext:<contextId& gt;，并在上下文中显示所有路由，例如：
注意
<contextId > 是项目路由上下文 .xml 文件中的 camelContext 元素的 ID。在本例中，基于 Fuse → Content Based Router built-in 模板，ID 是 cbr-example-context。
按照第 2 章 在路由编辑器中编辑路由上下文 所述编辑路由，然后选择 File → Save 以保存您对内存模型所做的更改，并更新正在运行的路由上下文。
在相关节点上设置断点，如第 14 章 设置 Breakpoints 所述。
在 JMX Navigator 视图中，丢弃正在运行的路由上下文输入节点的信息。
如果您的项目不包括测试信息，您可以创建它们，如第 23.1 节 “为路由追踪创建测试消息” 所述。
单击 Yes 以确认切换到 Debug 透视图。
在 Camel 调试器中，像您通常一样通过断点（请参阅第 15 章 运行 Camel Debugger）生成消息，以查看您生成的更改的结果。
Camel 调试器在 Edit Routes 模式中的行为与正常调试模式相同，因此您可以在消息传输路由上下文时使用任何 Camel 调试器的功能。
注意
当消息到达路由上下文的末尾时，调试器会被暂停。要继续调试，请切换到 Fuse 集成 视角，并在 JMX Navigator 视图中输入节点上丢弃另一条消息。每次这样做时，工具都会要求您确认切换到 Debug 视角。
注意
在路由编辑会话期间，可能会丢失与正在运行的路由上下文的连接。如果发生这种情况，那么在 JMX Navigator 视图中，您会看到如下内容： Local Processes → maven[xxxx][Disconnected]。要继续会话，您必须重新连接到正在运行的路由上下文，在 JMX Navigator 视图中选择它，然后重新选择 Edit Routes。

终止路由编辑会话

在 Debug 透视图的 Debug 视图中，选择 Remote Camel Debug - camelContext--<contextId>--xxxxxxxxxxxxxxxxxx.xml [Remote Camel Context] 线程，然后点菜单栏中的终止调试会话。
在 Console 视图的菜单栏中，点终止路由上下文。
如果要清除控制台输出，请在 Console 视图的菜单栏中点。
切换到 Fuse Integration 视角，在路由编辑器中点 Remote CamelContext:<contextId& gt; 标签页来关闭路由上下文文件的内存中模型。

第 27 章管理路由上下文

JMX Navigator 视图可让您挂起和恢复运行的路由上下文。

27.1. 挂起路由上下文的操作

概述

这些工具可让您在 JMX Navigator 视图中暂停路由上下文的操作。暂停上下文操作会正常关闭上下文中的所有路由，但将它们加载到内存中，以便可以恢复操作。

流程

挂起路由上下文的操作：

在 JMX Navigator 视图中，展开项目的 Camel 上下文 节点，然后选择您要暂停的操作的路由上下文。
右键单击所选路由上下文以打开上下文菜单，然后选择 Suspend Camel Context。
注意
如果 Resume Camel Context 出现在上下文菜单中，则上下文的操作已被暂停。

27.2. 恢复路由上下文的操作

概述

这些工具可让您恢复 JMX Navigator 视图中暂停的路由上下文的操作。恢复上下文操作会重启其中的所有路由，以便它们可以处理消息。

流程

恢复路由上下文的操作：

在 JMX Navigator 视图中，展开项目的 Camel 上下文 节点，然后选择您要恢复的操作的路由上下文。
右键单击所选上下文以打开上下文菜单，然后选择 Resume Camel Context。
注意
如果 Suspend Camel Context 出现在上下文菜单中，上下文及其路由正在运行。

部分 IV. 将应用程序发布到容器

要将 Fuse 集成项目发布到服务器容器，您必须首先将服务器及其 runime 定义添加到工具的 Servers 列表中。然后，您可以将项目分配到服务器运行时，并为它设置发布选项。

第 28 章管理服务器

Servers 视图允许您在 Red Hat CodeReady Studio 环境中运行和管理服务器。

注意

有关如何将 Camel 项目发布到红帽 Fuse 的逐步说明，请参阅第 29 章 将 Fuse 集成项目发布到服务器。

28.1. 添加服务器

概述

对于管理服务器的工具，您需要将服务器添加到服务器列表中。添加后，服务器会出现在 Servers 视图中，您可以在其中连接到它并发布您的 Fuse 集成项目。

注意

如果添加红帽 Fuse 服务器，建议您编辑其 installDir/etc/users.properties 文件，并以 user=password,role 的形式添加用户信息，以启用工具来建立与服务器的 SSH 连接。

流程

向 Servers 视图添加新服务器的方法有三种：

在 Servers 视图中，点 No servers are available.点击此链接来创建新 server…。
注意
只有在没有定义任何服务器时，此链接才会出现在 Servers 视图中。如果您在首次创建项目时定义并添加了服务器，则 Servers 视图会显示该服务器。
在 Servers 视图中，右键单击以打开上下文菜单，然后选择 New → Server。
在菜单栏中，选择 File → New → Other → Server → Server。

在 Define a New Server 对话框中，添加新服务器：

扩展 Red Hat JBoss Middleware 节点，以公开可用服务器选项列表：
点要添加的服务器。
在 服务器的主机名 字段中，接受默认值(本地主机)。
注意
localhost 的地址为 0.0.0.0。
在 Server name 字段中，接受默认值，或者为运行时服务器输入不同的名称。
对于 服务器运行时环境，接受默认值或点击 Add 来打开服务器的运行时定义页面：
注意
如果服务器尚未安装在您的机器上，点 Download and install runtime… 并按照站点的下载说明安装它。根据站点，您可能需要提供有效的凭证，然后才能继续下载过程。
接受安装名称的默认值。
在 Home Directory 字段中，输入安装服务器运行时的路径，或者点击 Browse 找到并选择它。
在 Execution Environment 旁边，从下拉菜单中选择运行时 JRE。
如果列表中没有显示您想要的版本，点 Environments 并从出现的列表中选择版本。必须在您的机器上安装您选择的 JRE 版本。
注意
如需所需的 Java 版本，请参阅 Red Hat Fuse 支持的配置。
将 Alternate JRE 选项保留原样。
点 Next 保存服务器的运行时定义并打开其配置 详情页面 ：
接受 SSH 端口 的默认端口(8101)。
运行时使用 SSH 端口来连接服务器的 Karaf shell。如果您的设置此默认不正确，您可以通过查看服务器的 installDir/etc/org.apache.karaf.shell.cfg 文件来发现正确的端口号。
在 User Name 字段中输入用于登录到服务器的名称。
对于 Red Hat Fuse，这是存储在 Red Hat Fuse installDir/etc/users.properties 文件中的用户名。
注意
如果在 /etc/users.properties 文件中激活了默认用户（未提供），工具会使用默认用户名和密码自动填充 User Name 和 Password 字段，如 [servCnfigDetails] 所示。
如果用户尚未设置，您可以使用 user=password,role （如 joe=secret,Administrator）格式向该文件添加一个，也可以使用 karaf jaas 命令设置它：
- jaas:realms mvapich-DESTINATIONto 列出域
- JAAS:manage --index 1 mvapich-wagon 以编辑第一个(server)域
- JAAS:useradd <username> <password > mvapich-mvapichto 添加用户和关联的密码
- JAAS:roleadd <username> Administrator mvapich-wagonto 指定新用户的角色
- JAAS:update mvapich-wagonto 使用新用户信息更新域
如果已经为服务器选择了 jaas 域，您可以通过发出 JBossFuse:karaf@root>jaas:users 命令来发现用户名。
在 Password 字段中，输入 User Name 登录服务器所需的密码。
点 Finish 保存服务器的配置详情。
服务器运行时会出现在 Servers 视图中。
扩展服务器节点会公开服务器的 JMX 节点：

28.2. 启动服务器

概述

当您启动配置的服务器时，工具会在 Terminal 视图中打开服务器的远程管理控制台。这样，您可以在测试应用程序时轻松管理容器。

流程

启动服务器：

在 Servers 视图中，选择要启动的服务器。
点击。
- Console 视图会打开并显示一条消息，要求您在容器启动时等待，例如：
  注意
  如果您没有正确配置用户名和密码来打开远程控制台，则会打开一个对话框，要求您输入正确的凭证。请参阅第 28.1 节 “添加服务器”。
- 容器启动后，Terminal 视图将打开以显示容器的管理控制台。
- 正在运行的服务器会出现在 Servers 视图中：
- 运行的服务器也会在 Server Connections 下的 JMX Navigator 视图中出现：
  注意
  如果服务器与工具在同一台计算机上运行，服务器也会在本地进程下也有一个条目。

28.3. 连接到正在运行的服务器

概述

启动配置的服务器后，它会出现在 Servers 视图，并在 Server Connections 节点下的 JMX Navigator 视图中显示。您可能需要扩展 服务器连接节点 来查看服务器。

要在运行的服务器上发布并测试您的 Fuse 项目应用，您必须首先连接到它。您可以在 Servers 视图中或 JMX Navigator 视图中连接到正在运行的服务器。

注意

服务器 视图和 JMX Navigator 视图与服务器连接同步。也就是说，连接到 Servers 视图中的服务器也会在 JMX Navigator 视图中连接它，反之亦然。

在 Servers 视图中连接到正在运行的服务器

在 Servers 视图中，扩展服务器运行时以公开其 JMX[Disconnected] 节点。
双击 JMX[Disconnected] 节点：

连接到 JMX Navigator 视图中正在运行的服务器

在 JMX Navigator 视图中，在 Server Connections 节点下选择要连接的服务器。
双击所选服务器：

查看在连接的服务器上安装的捆绑包

在 Servers 视图或 JMX Navigator 视图中，展开 server runtime tree 以公开 Bundles 节点，然后选择它。
这些工具使用服务器上安装的捆绑包列表填充 Properties 视图：
使用 Properties 视图的 搜索工具，您可以根据它们的 Symbolic Name 或其 标识符 搜索捆绑包（如果知道它）。当您输入符号名称或标识符时，列表更新，只显示与当前搜索字符串匹配的捆绑包。
注意
或者，您可以在 Terminal 视图中发出 osgi:list 命令，以查看 Red Hat Fuse 服务器运行时上安装的已生成捆绑包列表。该工具为 osgi:list 命令显示的 OSGi 捆绑包使用不同的命名方案。
在项目的 pom.xml 文件的 < build > 部分中，您可以找到 maven-bundle-plugin 条目中列出的捆绑包符号名称及其捆绑包名称(OSGi)。如需了解更多详细信息，请参阅 “验证项目是否已发布到服务器”一节。

28.4. 断开与服务器的连接

概述

完成测试应用程序后，您可以在不停止的情况下断开与服务器的连接。

注意

服务器 视图和 JMX Navigator 视图与服务器连接同步。也就是说，与 Servers 视图中的服务器断开连接也会在 JMX Navigator 视图中断开连接，反之亦然。

在 Servers 视图中断开与服务器的连接

在 Servers 视图中，扩展服务器运行时以公开其 JMX[Connected] 节点。
右键单击 JMX[Connected] 节点以打开上下文菜单，然后选择 Disconnect。

在 JMX Navigator 视图中断开与服务器的连接

在 JMX Navigator 视图中，在 Server Connections 下选择要断开连接的服务器。
右键单击所选服务器以打开上下文菜单，然后选择 Disconnect。

28.5. 停止服务器

概述

您可以在 Servers 视图中关闭服务器，或者在 Terminal 视图中的服务器的远程控制台中关闭服务器。

使用 Servers 视图

停止服务器：

在 Servers 视图中，选择要停止的服务器。
点击。

使用远程控制台

停止服务器：

打开托管服务器远程控制台的 Terminal 视图。
按： CTRL+D

28.6. 删除服务器

概述

完成配置的服务器后，或者错误配置服务器，您可以将其删除及其配置。

首先，从 Servers 视图或从 JMX Navigator 视图中删除服务器。接下来，删除服务器的配置。

删除服务器

在 Servers 视图中，右键单击您要删除的服务器以打开上下文菜单。
选择 Delete。
点击确定。

删除服务器的配置

在菜单栏中，选择 CodeReady Studio → Preferences → Server。
注意
在 Linux 和 Windows 机器上，选择 Window → Preferences。
展开 Server 文件夹，然后选择 Runtime Environments 以打开 Server Runtime Environments 页面。
从列表中选择您之前从 Servers 视图中删除的服务器的运行时环境，然后点 Remove。
点击确定。

第 29 章将 Fuse 集成项目发布到服务器

您可以使用 Eclipse 发布机制将 Fuse 集成项目部署到服务器运行时。要做到这一点，您必须在 Fuse 集成 视角中定义服务器并将服务器添加到 Servers 视图中。有关逐步演示，请参阅。

概述

您可以设置支持的服务器来自动发布分配的 Fuse 项目，或者仅在手动调用 publish 命令时发布它们。

每个添加到 Servers 视图的服务器运行时都有自己的 Overview 页面，其中包含其配置、连接和发布详情：

您可能需要扩展 Publishing 来公开服务器运行时发布选项和默认设置：

永不会发布自动发布 criu-criuYou，您必须选择这个选项来手动发布项目。
重要
您还必须禁用 If server started，在服务器的 Add 和 Remove 页面中立即发布更改 （详情请参阅 “手动发布 Fuse 项目”一节。
当资源更改 iwl-wagon[default] 启用此选项时 ，自动发布或重新发布 Fuse 项目（在保存对其所做的更改时）。发布项目的速度取决于 发布间隔 （默认为 15 秒）。
在构建事件 mvapich- iwlFor Fuse 项目后自动发布 ，与资源更改时自动 发布时的自动发布 相同。

在资源更改时自动发布 Fuse 项目

服务器运行时的默认发布选项是 自动发布资源何时更改。

如有必要，启动您要发布 Fuse 项目的服务器运行时。详情请查看第 28.2 节 “启动服务器”。
在 Servers 视图中，双击服务器运行时以打开其 Overview 页面。
展开 Publishing，然后选择 Automatically publish when resources change。
要增加或减少发布周期之间的间隔，请单击根据情况 发布间隔（以秒为单位） 旁边的单选按钮。
在 Servers 视图中，右键单击服务器运行时以打开上下文菜单，然后选择 Add 和 Remove。
所有可用于发布的资源都会出现在 Available 列中。
要为服务器运行时分配资源（本例中为 CBRroute Fuse 项目）：
- 双击它，或者
- 选择它，然后单击添加。
  所选资源移至 Configured 列中：
  在这个阶段，实际发布分配的资源的时间取决于服务器运行时是否正在运行以及 发布间隔 设置。但是，如果服务器停止了，则必须在启动服务器后手动发布项目（详情请参阅 “手动发布 Fuse 项目”一节）。
点击 If server started，立即发布更改 以启用它：
此选项可确保在单击 Finish 后，配置的项目会立即发布。在服务器运行时 Overview 页面上的 Automatically publish when resources change 选项可确保在保存对本地项目所做的更改时重新发布配置的项目。
点 Finish。
该项目会出现在服务器运行时节点的 Servers 视图中，服务器运行时状态报告 [Started,Publishing…]。
发布后，服务器运行时和项目报告的状态都是 [Started,Synchronized]:
注意
对于服务器运行时，Synchronized 表示服务器上的所有发布资源都与其本地对应的资源相同。对于已发布的资源，Synchronized 表示它与其本地对应项相同。

手动发布 Fuse 项目

如有必要，启动您要发布 Fuse 项目的服务器运行时。详情请查看第 28.2 节 “启动服务器”。
在 Servers 视图中，双击服务器运行时以打开其 Overview 页面。
展开 Publishing，然后选择 Never publish。
点 File → Save 保存发布选项更改。
如果 Fuse 项目已经分配给服务器运行时，请确保禁用此选项：如果服务器 启动，请立即发布更改 ：
1. 在 Servers 视图中，右键单击服务器运行时以打开上下文菜单。
2. 点 Add and Remove… 打开服务器的 Add 和 Remove 页面。
3. 如果启用了以下选项，请禁用它： 如果服务器启动，请立即发布更改。
4. 跳至 [finish]。
如果 Fuse 项目尚未分配给服务器运行时，请立即分配它：
1. 按照 [startAssignResource] 中的 [stopAssignResource] 遵循 “在资源更改时自动发布 Fuse 项目”一节。
2. 不要启用 If server started，请立即发布更改。
单击完成。
该项目会出现在服务器运行时节点的 Servers 视图中，服务器运行时状态报告 [Started]:
在 Servers 视图中，右键单击项目的节点。在本例中，选择 CBRroute Fuse 项目以打开上下文菜单：
选择 Full Publish。
在发布操作期间，服务器运行时和项目的状态都报告 [Started,Republish]。
发布后，服务器运行时的状态和项目报告 [Started,Synchronized]:
注意
这些工具不支持 Incremental Publish 选项。单击 Incremental Publish 的结果会完全发布。

验证项目是否已发布到服务器

将 Fuse 项目发布到服务器运行时后，您可以连接到服务器并检查其上是否已安装了项目的捆绑包。

连接到服务器运行时。详情请查看 “在 Servers 视图中连接到正在运行的服务器”一节。
在 Servers 视图中，展开服务器运行时树，以公开 Bundles 节点并选择它。
这些工具使用服务器上安装的捆绑包列表填充 Properties 视图：
要查找项目的捆绑包，可向下滚动到列表的底部，或者在 Properties 视图的 Search 框中输入捆绑包的 Symbolic Name。捆绑包的 Symbolic Name 是您在创建时为您提供的名称。
注意
或者，您可以在 Terminal 视图中发出 osgi:list 命令，以查看 Fuse 服务器运行时上安装的已生成捆绑包列表。该工具为 osgi:list 命令显示的 OSGi 捆绑包使用不同的命名方案。
在项目的 pom.xml 文件的 < build > 部分中，您可以找到捆绑包的符号链接名称及其 捆绑包 名称(OSGi)，例如：

附录 A. Fuse Integration Perspective

使用 Fuse Integration 视角设计、监控、测试和发布您的集成应用程序。

您可以使用以下方法打开 Fuse 集成 视角：

当您创建新的 Fuse 集成项目（请参阅第 1 章 创建新的 Fuse 集成项目）时，工具会切换到 Fuse 集成 视角。
点 CodeReady Studio 工具栏右侧的。如果工具栏中没有图标，点，然后从可用视角列表中选择 Fuse Integration。
选择 Window → Perspective → Open Perspective → Fuse Integration。

Fuse 集成 视角由 9 个主要区域组成：

Project Explorer 视图
显示工具已知的所有项目。您可以查看组成每个项目的所有工件。Project Explorer 视图还在其 Camel 上下文节点下显示项目的所有路由上下文 .xml. 文件。这可让您查找并打开项目中包含的路由上下文文件。在每个路由上下文 .xml 文件下，Project Explorer 视图会显示上下文中定义的所有路由。对于多路由上下文，这可让您专注于 canvas 的特定路由。
路由编辑器
提供主要的设计时工具，它由三个标签页组成：
- 设计 criu-wagonDisplays 一个大型网格区域，它构建路由，并从哪个企业级集成模式(EIP)和 Camel 组件中选择，然后在 canvas 上连接以形成路由。
  canvas 是路由编辑器的工作台，以及执行大部分工作的位置。它显示一个或多个路由的图形表示，这些路由由连接的 EIP 和 Camel 组件组成（在它们放置在 canvas 上后调用它们）。
  在 canvas 上选择一个节点会为 Properties 视图填充应用到所选节点的属性，以便您可以编辑它们。
  panel 中包含构建路由所需的所有模式和 Camel 组件，并根据功能为 Components、路由、控制流、转换和其它 组件 来分组。
- 源
  显示路由编辑器上构建的路由的 .xml 文件的内容。
  您可以在 Source 选项卡中以及 Design 选项卡中编辑路由上下文。Source 选项卡可用于编辑并将任何配置、注释或 Bean 添加到路由上下文文件中。内容辅助功能可帮助您使用配置文件。在 Source 选项卡中，按 Ctrl+Space 查看可插入到项目中的可能值的列表。
- 配置
  提供了一种简单的方法，可以将共享配置（全局端点、数据格式、Bean）添加到多路由路由上下文。详情请查看第 2.6 节 “添加全局端点、数据格式或 Bean”。
- REST
  提供 Rest DSL 组件的图形表示。
属性视图
显示 canvas 上所选节点的属性。
JMX Navigator 视图
列出 JMX 服务器及其监控的基础架构。它可让您浏览 JMX 服务器及其监控的 poceses。它还可识别红帽进程的实例。
JMX Navigator 视图会在 Fuse 集成 视角中驱动所有监控和测试活动。它决定了在 Diagram View、Properties 视图和 Messages View 中显示哪些路由。它还提供了用于激活路由追踪、添加和删除 JMS 目的地以及启动和暂停路由的菜单命令。也是将消息拖放到路由的目标。
默认情况下，JMX Navigator 视图显示所有在本地机器上运行的 Java 进程。您可以根据需要添加 JMX 服务器来查看其他机器上的基础架构。
图视图
显示代表 JMX Navigator 视图中选择的节点的图形树。当您选择进程、服务器、端点或其他节点时，Diagram View 将所选节点显示为 root 用户，并将分支显示为其子级和 grandchildren。
当您选择代理时，Diagram View 会显示最多三个子对象：连接、主题和队列。它还显示配置的连接和目的地为 grandchildren。
当您选择路由时，Diagram View 显示路由中的所有节点，并显示消息通过路由处理的不同路径。它还会在启用路由追踪时显示路由中每个处理步骤的时间指标。
消息视图
列出在启用路由追踪时通过所选 JMS 目的地或通过 Apache Camel 端点传递的消息。
当在 JMX Navigator 视图中选择了 JMS 目的地时，视图会列出位于目的地的所有消息。
启用路由追踪时，Messages View 会列出从追踪开始通过路由中的节点传递的所有消息。您可以配置 Messages View，以仅显示您感兴趣的数据以及您首选的序列。
当选择了 Messages View 中的消息追踪时，其详情（消息正文和所有消息标头）会出现在 Properties 视图中。在 图表 View 中，突出显示与所选消息追踪关联的路由中的步骤。
服务器 视图
显示由工具管理的服务器列表。它显示其运行时状态，并提供添加、启动和停止它们的控制，并为它们发布项目。
终端视图
显示连接的容器的命令控制台。您可以通过在 Terminal 视图中输入命令来控制容器。
控制台 视图
显示最近执行操作的控制台输出。

附录 B. 调试视角

使用 Debug 透视图来监控和调试正在运行的 Camel 上下文。

debug 视图
对于正在运行的 Camel 上下文，Debug 视图会显示 debug 堆栈。
您可以在同一消息流中的断点之间切换，列在 service:jmx:rmi://jndi/rmi://localhost:1099/jmxrmi/camel 条目下，来查看和比较 Variables 视图中的变量值。
消息流由其唯一的面包包 ID 标识，后续每个消息流的面包 ID 由 2 递增。例如，如果第一个消息流的面包面 ID 是 ID-janemurpheysmbp-home-54620-1470949590275-0-1，第二个消息流的 breadcrumbID 为 ID-janemurpheysmbp-home-54620-1470949590275-0-3。
变量视图
对于设置了断点集的路由上下文中的每个节点，变量视图会在达到断点时显示可用变量的值。由于前面的断点突出显示了黄色，因此每个变量都会改变。
您可以更改可编辑变量的值，以检查此类更改是否产生预期结果并测试路由上下文的稳健性。
您还可以在监视器列表中添加变量，以便您可以快速轻松地看到它们的值在消息流的预期点改变。
断点视图
显示路由上下文中设置的断点列表，并显示它们是否启用或禁用。您可以通过检查（禁用）或取消选中（禁用）或取消选中（禁用）它们来启用和禁用单独的断点。这可让您临时专注于路由环境中有问题的节点。
按钮跳过禁用的断点，以跳到路由上下文中的下一个活跃断点。相反，按钮会在路由上下文中跳到下一个执行节点，而不考虑断点。
Camel Context.xml view
以图形模式显示正在运行的路由上下文文件。对于使用断点设置的节点，它会显示 breakpoint 设置的类型，以及断点是 enabled 或 disabled。当达到断点时，其在 canvas 中对应的节点以红色概述。
要检查节点的配置，请打开 Properties 视图，然后在 camel Context.xml 中选择 canvas 的节点。
控制台 视图
在执行路由上下文时，显示 Camel 调试器生成的日志输出。
属性视图
显示为 CamelContext.xml 中的 canvas 中选择的节点设置的属性。

法律通告

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.

工具用户指南