前言

通過本教程學習 Apache Camel 的基礎知識并在 Spring Boot 項目上創建您的第一個 Camel。

想開始使用Apache Camel嗎？這是我關于這個流行的 Java 集成框架的教程。

我為完整的初學者編寫了這個 Apache Camel 教程。它向您介紹了 Camel 的核心概念，并向您展示了如何使用 Maven 構建和運行您的第一個 Camel 項目，該項目在 Spring Boot 上運行。

歡迎！

歡迎來到這個初學者的 Apache Camel 教程。Apache Camel 是一個非常流行的 Java 集成框架。

有多受歡迎？好吧，Stack Overflow 上的這個問題，Apache Camel 究竟是什么，已經被查看了超過一百萬次。

那是巨大的！因此，不僅人們對 Camel 產生了濃厚的興趣，而且人們也渴望了解它的功能。

您來到這里是因為您想開始使用 Apache Camel 并了解基礎知識。

無論您的背景如何，本教程都將幫助您掌握 Apache Camel 的基礎知識，并讓您快速上手。

享受！

PS：如果你喜歡這個教程，請分享給你的朋友，它有助于傳播關于Camel的信息！🐪

你會學到什么

在本教程結束時，您將：

• 了解 Apache Camel 是什么，以及它可以做什么
• 使用 Maven 創建一個基本的 Apache Camel 項目
• 了解 Camel 如何與 Spring Boot 配合使用
• 查看如何使用日志記錄
• 運行您的應用程序并對其進行測試

本教程適合您：

• 你想學習Apache Camel
• 您想知道如何創建 Camel 項目
• 您剛剛開始使用Red Hat Fuse并想知道如何構建 Camel 路由
• 您剛開始使用 Talend ESB并想了解基本概念，以便了解中介路由。
• 您是一名 Java 開發人員，并且希望通過一個強大的框架來提升您的技能
• 你是一名建筑師，你想更多地了解 Camel 的含義

您應該有一點 Java 經驗，并且熟悉使用命令行。

Apache Camel 簡介

apache camel官網：Home - Apache Camel

那么什么是 Apache Camel 以及它的用途是什么？

Apache Camel 是一個Java集成庫。它是一組 Java API，可幫助您在不同的計算機系統之間集成和處理數據。

換句話說，駱駝是像不同的應用程序之間的膠水。

Camel 帶有200 多個組件，可讓您集成許多不同的應用程序。Camel 可以集成從 Web 服務到在磁盤上讀寫文件的任何內容。您甚至可以將 Camel 與 Twitter、Facebook 和 Salesforce 等網絡應用程序連接起來。

您可以將 Apache Camel視為 Java的管道工具包。就像真正的管道一樣，Camel 從一個點獲取數據，并將其通過管道傳輸到另一個點。在此過程中，數據可以更改、轉換或通過其他管道發送。

您的管道工具包中包含一系列適用于各種不同應用程序和軟件系統的適配器。有了一系列可供您使用的工具，您就可以選擇如何建造管道了。

Camel 的創意從何而來？

Camel 受到Enterprise Integration Patterns一書的啟發，這是一本關于集成軟件系統的學術教科書。這本書的作者（現在被認為是“經典”！）采用了許多常見的集成用例，將它們提煉成可重用的模式并記錄下來。書中描述了每種模式，在某些情況下，還有一些示例代碼。

Camel 開發人員認為構建一個代表本書理想的 Java 框架是一個好主意。因此 Apache Camel 大量借鑒了本書。

Camel事實

希望您已經開始了解 Camel 是什么。

以下是有關 Camel 的一些事實，可幫助您了解有關項目本身的更多信息：

• 它是 用 Java 構建的——這可能看起來很明顯，但是一旦你理解了這一點，你就會發現你可以使用 Java 的全部功能
• 整個代碼是完全開源的——在 Github 上查看——沒有什么隱藏在昂貴的閉源產品后面。您可以為項目做出貢獻并回饋社區。（您不必成為編碼員即可做出貢獻）
• 它 不僅適用于 Web 服務——它還是一個通用的集成框架。這意味著您可以選擇使用 Camel 來構建與 Web 服務相關的內容，但您不必這樣做。
• 它帶有一個 龐大的組件庫——如果你能想到一個你想要與之交互的系統，那么可能已經有人為它編寫了一個組件；您可以做任何事情，從推送文件到 AWS到發送推文。
• 它已經 成熟——Apache Camel 是一些商業集成產品的基礎，如Red Hat Fuse和Talend ESB。在這些公司工作的工程師將代碼貢獻回開源 Camel 項目，以使其對每個人都更好。

Camel 的常見用例

幾乎任何時候您需要將數據從A移動到B，您都可以使用 Camel。可以使用Camel實現以下任何場景：

• 從 FTP?服務器獲取發票并將其通過電子郵件發送到您的會計部門
• 從文件夾中提取文件并將其推送到 Google Drive
• 從ActiveMQ 隊列中獲取消息并將它們發送到 Web 服務
• 制作允許用戶從數據庫中檢索客戶詳細信息的 Web 服務

這些只是幾個例子。有了 Camel 中可用的各種組件，天空就是極限。

為什么使用?Camel

?1 ，我們要解決的問題以及解決方案

我們要解決的問題

1. 完成組織內外的各種異構系統、應用、數據源之間共享和交換信息。
2. 優化現有結構，使整個系統易于拓展和維護。
3. 保證多個系統各自獨立互不干擾。

總結發現我們實際要解決的問題是：企業應用集成（Enterprise Application Integration，EAI）?是完成在組織內、外的各種異構系統，應用和數據源之間共享和交換信息和協作的途徑，方法學，標準和技術。

2，EAI的常用解決方案

SOA（Service Oriented Architecture）?中文釋義為 “面向服務的架構”它是一種設計理念，其中包含多個服務， 服務之間通過相互依賴最終提供一系列完整的功能。各個服務通常以獨立的形式部署運行，服務之間通過網絡進行調用。要求各個服務遵循統一的規范和契約。

ESB企業服務總線

ESB（Enterprise Service Bus，即企業服務總線）?就是一根管道，用來連接各個服務節點。ESB的存在是為了集成基于不同協議的不同服務，ESB 做了消息的轉化、解釋以及路由的工作，以此來讓不同的服務互聯互通

3，如何實現ESB

當前實現ESB比較成熟的模型為EIP（Enterprise Integration Patterns）1。他的包含如下規范：

• 集成方式（Integration Styles）：EIP規定所有集成模式要基于消息傳送模式。
• 通道模式（Channel Patterns）：消息通過通道進行傳遞。
• 消息體模式（Message Construction Patterns）：描述了在消息系統中交互的消息的規范。
• 路由模式（Routing Patterns）：消息如何從發送者分發到正確的接收者，中間一般不進行修改。
• 轉換模式（Transformation Patterns）：將消息體的內容修改為接收者可以理解的結構，中間可能要對數據進行修改或者篩選。
• 終端模式（Endpoint Patterns）：生成或者接收消息的客戶。
• 系統管理模式（System Management Patterns）：提供監控整個系統狀態的工具，包括錯誤處理，壓力測試或者監控系統變化。

Camel概念解釋

?Camel 就是企業信息集成框架，它提供了很多簡單好用而又強大的組件，用戶可以根據場景來選擇不同的EIP（企業集成模式）來實現自己的需求，以響應快速變化的業務。可以把它當成企業信息總線（ESB）的輕量級實現。

你如何像駱駝一樣思考？下圖顯示了 Camel 中的一些核心概念。

可視化駱駝路線

在本節中，我將依次查看每一個：

Route

在駱駝最基本的概念是route。路由是您在 Camel 中配置的對象，它將您的數據從A移動到 B。

使用前面的管道示例，Route是將數據從一個地方移動到另一個地方的管道。它在稱為Endpoints事物之間移動數據。

您可以使用 Java 語法或 XML 語法在 Camel 中創建路由。這是一個用 Java 語法編寫的非常簡單的路由。這會將文件從一個文件夾移動到另一個文件夾：

// 這是一個完整的 Camel 路由定義！
// Camel 將文件從一個文件夾移動到另一個文件夾 
from("file:home/customers/new").to("file:home/customers/old");　

Endpoints

在 Camel 中，endpoint是一個接口，Camel 通過它與另一個系統交換消息。Camel 可以從端點接收消息，也可以向端點發送消息。

端點是路線中沿途的步驟。您可以通過幾種不同的方式聲明它們，但最常見的方法是使用類似于 URI 的語法來聲明它們，如下所示：

prefix:mainpart?option1=xxx&option2=xxx...

…prefix?端點引用的組件在哪里，是?mainpart?端點需要的一些配置。

例如：在路由的開始處，Camel 收到來自端點的消息。如果此端點為 file:/myfolder，則 Camel 將使用 File 組件讀取?/myfolder.

Components

為了讓 Camel 創建端點，它附帶了一個組件庫。組件就像一個插件，允許您連接到外部系統，

例如: 磁盤上的文件、郵箱或 Dropbox 或 Twitter 等應用程序。

您可以將組件視為創建端點的工廠。

每當您需要將數據放入或取出應用程序時，您可能會發現已經存在一個 Camel 組件來為您完成這項工作。這意味著您無需浪費時間編寫自己的代碼來讀取文件或調用 Web 服務。您只需找到您需要的組件并使用它。

Camel 組件是可重用的、開源的，您甚至可以貢獻自己的組件。以下是一些最常見的組件，以及如何在端點中引用它們：

您可以在此處找到所有 Camel 組件的列表。

可以看到，每個組件通常都可以讀寫：

• 配置為寫入內容的組件稱為生產者——例如，寫入磁盤上的文件，或寫入消息隊列。
• 配置為讀取某些內容的組件稱為使用者——例如，從磁盤讀取文件，或接收 REST 請求。

在每個端點之間，還可以通過將數據傳遞到另一個端點或使用 EIP 來轉換或修改數據。

企業集成模式 (EIP)

EIP是 Camel 的另一個重要組成部分。它們根據我之前提到的《企業集成模式》一書中定義的模式對消息進行特殊處理。

當您想對消息執行一些常見活動時，例如轉換、拆分和日志記錄，您將使用 EIP。以下是 Camel 中一些常見的 EIP：

（是的，from 和 to 也是 EIP！)

From 端點類型

Apache Camel 提供了豐富的?from?端點，適用于不同的消息來源和場景。選擇合適的端點可以優化消息處理的效率和靈活性。

例如：

• 自動觸發：使用?timer、file、jms?等端點。
• 手動觸發：使用?direct?端點，通過代碼調用。

1.?Timer 端點

• 功能：定時觸發消息，類似于定時任務。
• 使用場景：需要周期性執行的任務，例如每分鐘檢查一次數據。
• 示例：

from("timer:myTimer?period=1000") // 每秒觸發一次 
.to("direct:processData");

• 特點：可以配置觸發頻率（如?period）或使用 Cron 表達式。

2.?File 端點

• 功能：監聽指定目錄，當有文件出現或更新時觸發消息。
• 使用場景：文件處理任務，例如從指定目錄讀取文件并解析內容。
• 示例：

from("file:input?noop=true") // 監聽 input 目錄，不刪除文件 
.to("direct:processFile");

• 特點：支持監聽目錄、過濾文件名、是否刪除文件等選項。

3.?Direct 端點

• 功能：內存中的端點，用于同一 JVM 內的路由間通信。
• 使用場景：需要手動觸發消息的路由，例如通過代碼調用。
• 示例：

from("direct:start") 
.to("direct:nextStep");

• 特點：需要手動調用?ProducerTemplate?發送消息，同步執行。

4.?SEDA 端點

• 功能：基于內存隊列的異步端點，適用于線程池處理。
• 使用場景：需要異步處理消息的路由，例如高并發場景。
• 示例：

from("seda:myQueue") 
.to("direct:processQueue");

• 特點：支持線程池，消息處理不阻塞調用方。

5.?VM 端點

• 功能：類似于 SEDA，但允許跨多個 Camel 應用通信。
• 使用場景：需要跨 JVM 實例的路由通信。
• 示例：

from("vm:myQueue") 
.to("direct:processVm");

• 特點：支持跨 JVM，但需確保所有實例使用相同的 VM 端點名稱。

6.?JMS 端點

• 功能：與 Java 消息服務（JMS）集成，用于消息隊列或主題。
• 使用場景：分布式系統中的消息傳遞，例如訂單處理。
• 示例：

from("jms:queue:orderQueue") 
.to("direct:processOrder");

• 特點：支持隊列和主題，需要 JMS 提供者（如 ActiveMQ）。

7.?HTTP 端點

• 功能：監聽 HTTP 請求，處理 Web 服務調用。
• 使用場景：REST API 或 SOAP 服務。
• 示例：

from("http://localhost:8080/api") 
.to("direct:processHttp");

• 特點：支持 GET、POST 等多種 HTTP 方法。

8.?Quartz 端點

• 功能：基于 Quartz 定時器的高級定時任務。
• 使用場景：復雜的定時任務，例如基于 Cron 表達式的調度。
• 示例：

from("quartz://report?cron=0 0 9 * * ?") // 每天早上 9 點觸發.to("direct:processDailyReport");

• 特點：支持更復雜的調度邏輯。

9.?FTP 端點

• 功能：監聽 FTP 服務器，處理文件傳輸。
• 使用場景：需要從 FTP 服務器獲取或上傳文件。
• 示例：

from("ftp://user:password@host/path?noop=true") 
.to("direct:processFtpFile");

• 特點：支持文件過濾、是否刪除文件等選項。

10.?ActiveMQ 端點

• 功能：與 ActiveMQ 消息隊列集成。
• 使用場景：需要高可靠性的消息傳遞。
• 示例：

from("activemq:queue:highPriority") 
.to("direct:processHighPriority");

• 特點：支持事務和持久化。

Direct 端點

在 Apache Camel 中， direct?端點用于同步調用，確保消息從一個路由直接傳遞到另一個路由。您提到的場景涉及從一個? .to("direct:pro_pre_CommonSDR_csl")?跳轉到另一個? from("direct:pro_pre_CommonSDR_csl")?定義的獨立路由。

詳細解析和實現方式：

1.?direct?端點的特性

2.?跳轉邏輯實現

XML DSL 示例

<camelContext xmlns="http://camel.apache.org/schema/spring"><!-- 路由 A --><route><from uri="direct:start"/><log message="Processing in Route A"/><to uri="direct:pro_pre_CommonSDR_csl"/> <!-- 跳轉到路由 B --><log message="Continuing in Route A after B"/></route><!-- 路由 B --><route><from uri="direct:pro_pre_CommonSDR_csl"/><log message="Processing in Route B"/><to uri="mock:resultB"/></route>
</camelContext>

Java DSL 示例

import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;@Component
public class MyRoute extends RouteBuilder {@Overridepublic void configure() throws Exception {// 路由 Afrom("direct:start").log("Processing in Route A").to("direct:pro_pre_CommonSDR_csl") // 跳轉到路由 B.log("Continuing in Route A after B");// 路由 Bfrom("direct:pro_pre_CommonSDR_csl").log("Processing in Route B").to("mock:resultB");}
}

3.?關鍵點說明

4.?常見問題排查

簡單類比:

想象一下你在寫一個程序：

// 路由 A
public void processA() {System.out.println("Starting Route A");// ... 一些處理 ...// 調用另一個方法processB();// ... 路由 A 的后續處理 ...System.out.println("Continuing Route A after B");
}// 路由 B
public void processB() {System.out.println("Hello from Camel! 1 (Inside Route B)");// ... 一些處理 ...
}// 主程序
public static void main(String[] args) {MyCamelApp app = new MyCamelApp();app.processA();
}

在這個 Java 例子中，processA?執行到?processB?時，會暫停自己的執行，跳轉到?processB?去執行。processB?執行完畢后，控制權會回到?processA，繼續執行?processB?之后的代碼。

總結:

路由 A 之所以會“跑到”路由 B，是因為??是一個同步調用。它強制路由 A 的執行流程暫停，并將消息傳遞給?direct:propreCommonSDRcsl?對應的入口（即路由 B），等待路由 B 處理完成后再繼續路由 A 的后續步驟。路由 B 就是處理?direct:propreCommonSDRcsl?端點消息的那個獨立路由。

在這里 ?路由B 的 路由名（pro_pre_CommonSDR_csl）？

Camel Context

最后，為了運行和管理你的路由，Camel 有一個名為 Camel Context 的容器。您的路線在此引擎內運行。你幾乎可以把它想象成一個迷你應用服務器。

當 Camel啟動時，它會讀取您的路由定義（在 Java 或 XML 中），創建路由，將它們添加到 Camel 上下文，并啟動 Camel 上下文。

當 Camel終止時，它會關閉您的路由，并關閉 Camel 上下文。

Route是什么樣的？

所以。現在您知道，當您在 Camel 中進行開發時，您會使用組件創建在端點之間移動數據的路由。

通過查看一些代碼可能最容易理解所有這些，對嗎？

盡管 Camel 是 Java 庫，但可以使用兩種語言之一進行配置 -?Java或XML。用駱駝的話說，這些被稱為DSL（領域特定語言）。

每條路線開始于from，具有URI，它定義了數據來自哪里。

一條路線可以由多個步驟組成——例如轉換數據或記錄數據。但路由通常結束于to步驟，其描述數據將被傳遞to哪里。

Camel 的 Java DSL 中一個非常簡單的路由可能如下所示：

from("file:home/customers/new") 
.to("file:home/customers/old");

在此示例中，我們使用File 組件（由file:前綴標識）將文件customers/new夾中的所有傳入文件移動到該customers/old文件夾。

上面的相同路徑可以用 Camel 的 XML DSL 表示，如下所示：

<route><from uri="file:home/customers/new"/><to uri="file:home/customers/old"/>
</route>

但是......如果我們想在我們的路線中添加另一個步驟怎么辦？假設我們想在收到文件時記錄一條消息。然后我們只需要在現有步驟之間添加我們的新步驟。像這樣：

from("file:home/customers/new") 
.log("Received a new customer!") 
.to("file:home/customers/old");

在上面的代碼中，一條消息從新文件夾移動到舊文件夾。在中間，我們使用名為 的企業集成模式 (EIP)?log，它將簡單的日志消息寫入控制臺。

在 XML DSL 中，它看起來像這樣：

<route> <from uri="file:home/customers/new"/> <log message="Received a new customer!"/> <to uri="file:home/customers/old"/> 
</route>

現在您知道路由的樣子了，讓我們快速看看數據如何流經路由。

Camel中的數據是什么樣的？

?

駱駝的消息模型

Camel 將數據視為單獨的消息——就像通過郵局對信件進行分類一樣。

每條消息都是一個單獨的對象。一條消息可以很大，也可以很小。Camel 有一個對象來表示消息，它被稱為Message.

A Message有一個 body，其中包含消息內容。它還具有標頭，可用于保存與消息關聯的值。該Message對象然后沿 Route 傳遞。

A Message是另一個名為?Exchange?的 Camel 對象的一部分。您會經常看到 Camel 文檔中提到的術語 Exchange。Exchange 只是當前在 Camel 路由中發生的消息或交互。

了解 Camel 消息模型的重要一點是消息體可以包含幾乎任何類型的 Java 對象，例如List、Map或String。正文不必是字符串，如 JSON 或 XML。

?

Camel不同體型的例子

當您開始使用這些不同類型的對象時，Camel的真正力量就變得顯而易見了。Camel 具有強大的內置支持，可以在常見對象類型之間進行轉換。

事實上，對于許多常見的文件類型，您甚至可能幾乎不需要編寫任何轉換代碼。（減少編寫樣板代碼的時間？聽起來不錯，不是嗎？）

隨著您對 Camel 的體驗越來越多，您將了解更多關于 Camel 的消息模型的知識！

你的第一個Camel項目

在教程的這一部分中，我將向您展示如何使用 Maven 創建一個新的 Apache Camel 項目，即使您以前從未使用過 Camel。到本節結束時，您將已經創建并運行第一個項目，并開始了解 Camel 的強大功能。

我們將使用Maven 原型來做到這一點。Maven 原型就像新 Java 項目的模板。Camel 在每個版本中都提供了很多。這使您可以輕松開始新項目。

對于本教程，您將需要：

• Java 開發工具包 (JDK)
• Apache Maven

Mac 用戶注意事項：如果您使用的是 Mac，我建議您使用?Homebrew?包管理器來幫助您安裝 Maven。按照?http://brew.sh?上的說明進行安裝。然后，安裝 Homebrew 后，通過?brew?install?maven從終端窗口鍵入來安裝 Maven 。

使用 Maven 創建 Camel 項目

1. 從您的桌面，拖放到終端或命令提示符。
2. 鍵入此命令（全部在一行上）：

   mvn archetype:generate
   -DarchetypeGroupId=org.apache.camel.archetypes
   -DarchetypeArtifactId=camel-archetype-spring-boot
   -DarchetypeVersion=3.4.0

3. 然后在出現提示時回答問題：
   1. 定義屬性“groupId”的值：com.example
   2. 定義屬性“artifactId”的值：my-camel-app
   3. 定義屬性 'version' 1.0-SNAPSHOT 的值：（輸入 Enter）
   4. 定義屬性 'package' com.example 的值：（輸入 Enter）
   5. 最后，系統會提示您確認、輸入 Y 并按 Enter。

4. Maven 現在將創建您的新 Camel 項目。完成后，您會在新目錄中找到它?my-camel-app

看項目內部

從 camel-archetype-spring-boot 原型（v3.4.0）創建的Camel 項目將具有如下所示的文件夾結構：

my-camel-app
├── pom.xml
└── src├── main│   ├── java│   │   └── com│   │       └── example│   │           ├── MySpringBean.java│   │           ├── MySpringBootApplication.java│   │           └── MySpringBootRouter.java│   └── resources│       ├── application.properties│       └── META-INF│           ├── LICENSE.txt│           └── NOTICE.txt└── test├── java│   └── com│       └── example└── resources

RouteBuilder 類

有趣的代碼在MySpringBootRouter.java 中。這是一個RouteBuilderclass，這是您定義 Camel 路線的地方。Maven 原型包括一個示例路線，以幫助您入門：

package com.example;import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;@Component
public class MySpringBootRouter extends RouteBuilder {@Overridepublic void configure() {from("timer:hello?period=").routeId("hello").transform().method("myBean", "saySomething").filter(simple("${body} contains 'foo'")).to("log:foo").end().to("stream:out");}
}

在這里，您將路由定義添加到?configure()?描述您希望 Camel 創建的每條路由的方法中。

如果您查看代碼，您會看到 MyRouteBuilder 該類已經在其中定義了一個路由。

我們將很快查看路線。

utility類

Camel 路線取決于另一個類。在 Camel 路由中，使用 identifier 引用 bean（Java 對象）"myBean"。這實際上是通過在 Spring 上下文?中查找具有 ID 的任何 bean 來解決的 myBean。這意味著它實際上意味著這個類，MySpringBean：

@Component("myBean")
public class MySpringBean {@Value("${greeting}")private String say;public String saySomething() {return say;}
}

包含此實用程序類是為了向您展示如何從 Camel 路由調用 Java 代碼。該類有一個saySomething()?Camel 路由調用的方法。我們很快就會看到這一點。

bootstrap 類

為方便起見，該項目還包含另一個 Java 類 ，MySpringBootApplication 用于引導和運行應用程序。這是一個標準的 Spring Boot 主類：?

package com.example;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class MySpringBootApplication {/*** A main method to start this application.*/public static void main(String[] args) {SpringApplication.run(MySpringBootApplication.class, args);}}

現在讓我們看一下代碼，看看這個項目做了什么。

項目是做什么的？

演示項目使用以下代碼定義路由。代碼以特殊的 Camel 語法或DSL（域特定語言）給出：

from("timer:hello?period=").routeId("hello").transform().method("myBean", "saySomething").filter(simple("${body} contains 'foo'")).to("log:foo").end().to("stream:out");

這段代碼看起來很復雜，但它實際上只是生成消息并打印出來。

?

讓我們詳細看看路線的每個部分：

1. 它使用計時器 (?timer:...) 來啟動路線。Camel 的 Timer 組件可用于以特定時間間隔觸發路由。這里，間隔是timer.period，這是文件中定義的屬性?application.properties：

    from("timer:hello?period=")

   這展示了如何在 Camel 路由中使用 Spring Boot 屬性。
2. 該?transform()?EIP?指出，我們要改變消息的內容。在此示例中，我們使用 bean() 方法，該方法調用 Java bean（Java 類）上的方法。

   .transform().method("myBean", "saySomething")

   1. Camel 在名為 bean 的注冊表中查找 myBean。因為我們使用的是 Spring Boot，它會在 Spring 上下文中搜索 bean 并找到它，因為 MySpringBean 該類是用@Component("myBean").
   2. Camel 調用該 saySomethingbean 上的方法。
3. 的filter()EIP告訴Camel過濾消息，基于一些表達。在這種情況下，我們使用 Camel 的簡單表達式語言來檢查消息正文是否包含“foo”。如果是這樣，我們將當前的交換轉儲到日志中。

   .filter(simple("${body} contains 'foo'")) .to("log:foo") 
   .end()

4. 最后，將消息體的內容寫入輸出流（即標準輸出或 STDOUT）：

   .to("stream:out")

現在讓我們運行路由，看看會發生什么。

運行 Camel 應用程序

讓我們運行應用程序。我們將使用 Maven 運行它。

從終端或命令提示符運行 Maven，spring-boot:run目標是：

mvn clean spring-boot:run

這將編譯您的應用程序并使用Spring Boot Maven 插件來運行您的應用程序。

如果您想從 Eclipse 或 IntelliJ 內部運行此項目，只需為該項目創建一個新的 Maven運行配置，并將其配置為執行目標：spring-boot:run.

當應用程序啟動時，您會看到日志如下所示：

?

來自我們的 Camel 應用程序的日志

上面的日志告訴我們 Apache Camel 已正確啟動。

然后，每隔幾秒鐘，您應該會在日志中看到文本Hello World。這是因為 Camel 每隔幾秒鐘就會觸發要執行的路由。

當路由執行時，消息體被轉換（設置為Hello world），然后寫入標準輸出流或控制臺。

要結束應用程序，您只需按 Ctrl+C。

如何使用 Camel 創建 REST 服務？

您現在可能已經知道 Camel 是一個用于在不同系統之間進行集成的框架。它通常不會自己做一些事情，而是創建和配置一些實際完成工作的東西（例如一個組件）。

在 Camel 中創建 REST 服務遵循幾乎相同的模式。為 Camel 編寫一些說明，它將使用一堆其他組件為您公開您的 REST 服務。您只需要準確選擇您希望服務實現的方式，Camel 將負責配置。

這意味著使用 Camel 創建 REST 服務有無數種不同的方式。因此，我不會涵蓋每一種不同的方法，而只是簡要提及您可以在 Apache Camel 中使用 REST 服務的主要方法。你可以：

• 使用 Camel 支持的組件之一公開一個 REST 服務：?您使用 Camel 的 REST DSL 或 REST 組件定義您的 REST 服務操作，并選擇一個將被配置為實現您的服務的組件。然后，Camel 將使用該信息來引導組件、創建您的服務及其操作、將其部署到 Web 服務器（如 Jetty 或 Undertow）中，并為您生成 Swagger/OpenAPI 文檔。（這非常簡單，這就是我將在本教程中介紹的方式。）
• 使用 Camel 來引導使用 JAX-RS 的服務：Camel 與 Apache CXF 緊密集成，這是 Java 的Web 服務JAX-RS 規范的一種實現。因此，如果您正在考慮使用 JAX-RS 標準來定義您的 REST 服務，那么您可以使用 Camel 使用 CXF 為您引導您的服務。查看CXFRS 組件以獲取更多信息。
• 使用 Camel 為現有的 REST 服務提供業務邏輯：如果您已經在應用程序的其他地方公開了 REST 服務 —— 例如使用JAX-RS或 Spring Rest?—— 那么您可以使用 Camel 來實現實際的業務邏輯，如果你喜歡。

例如，您可能已經編寫了一個包含使用 javax.ws.rs 注釋（@Path、@GET、@POST等）注釋的方法的服務類，并且已經配置了您的實現（例如 CXF、Jersey 或 Resteasy）。如果是這樣，那么在您的服務方法中，您可以使用 Camel 的 Java API（ProducerTemplate?等）將消息發送到 Camel 路由，然后使用來自 Camel 的響應傳遞回您的使用者。

但在本教程中，我將向您展示我的首選方法。我們將使用 Camel 的 REST DSL 來配置服務并將其部署到嵌入式 Web 服務器中，該服務器在 Spring Boot 中運行。

使用 REST DSL 創建 REST 服務

那么如何在 Camel 中定義 REST 服務呢？最好的方法是使用 REST DSL。

REST DSL 是 Camel 現有路由構建語法的擴展，但專門用于描述 REST 服務。編寫和配置很容易。

在幕后，Camel 使用您的 REST DSL 代碼來配置實際提供REST 服務的底層組件。您現在不需要擔心這些細節，因為 Camel 會為您設置大部分默認值。

REST DSL 可以輕松定義 REST 服務，而無需了解太多底層細節或任何復雜的布線。

在非常高的層次上，當使用 Camel 創建 REST 服務時，我們需要做以下事情：

1. 聲明我們的 RESTful 服務的端點和操作
2. 選擇哪個組件將實現該服務（有關支持的組件列表，請參見下文）
3. 添加代碼以使用參數
4. 添加配置以獲取 Camel 以幫助我們處理 JSON 或 XML。

定義endpoints端點和操作

為了定義我們服務的操作，我們可以使用 REST DSL 語法。Camel在 Camel 2.14 中引入了REST DSL。REST DSL 基本上是用于定義 REST 服務的 Camel 語法。

看起來有點像普通的 Camel route…… 除了它以rest(). 定義您使用的服務，rest(...)?然后是您的操作，其采用 HTTP 動詞的形式，例如?.get()?和?.post()?等。

在 Java DSL 中，它看起來像這樣：

rest("/api/customers") 
.get() .route() .to("direct:getCustomers") 
.post() .route() .to("file:output/customers");

在 Camel 的 XML DSL 中：

<rest path="/api/customers"> <get> <route> <to uri="direct:getCustomers"/> </route> </get> <post> <route> <to uri="file:output/customers"/> </route> </post> 
</rest>

?REST 消費者還是 REST 生產者？當 Camel 公開或提供 REST 服務時，Camel 使用術語consumer，因為 Camel 正在通過 REST 消費提供給它的數據。另一方面，REST生產者是 Camel 消費或調用外部 REST 服務的地方。

配置實現

現在我們需要設置一些關于服務本身的信息。我們需要選擇哪個組件將實現服務，并設置任何屬性，如主機名和端口。

第一件事是選擇 Camel 應該引導哪個組件來實現您的 REST 服務。在這里，您可以選擇：

• servlet
• spark-rest
• netty-http
• jetty

選擇哪個組件完全取決于您，但是對于 Spring Boot 應用程序，我會選擇servlet，因為您已經擁有一個 Camel 可以用于 servlet (Tomcat) 的嵌入式 Web 服務器。

然后您可以在 restConfiguration() 塊中設置此配置，如下所示：

// 定義實現組件 - 并接受默認主機和端口
restConfiguration().component("servlet");
?
// 定義組件和主機名和端口
restConfiguration().component("servlet").host("localhost").port(8080);

使用參數

您的 REST API 可能需要接受來自使用者的參數。無論您是在正文、URL 還是在查詢字符串中使用參數，都可以輕松做到這一點。

POST 正文

像POST這樣的操作很容易。請求的正文將存儲在 Camel Exchange Body 中。所以你可以像這樣訪問它：

rest("/customers").post().log("The body is ${body}!");

網址參數

當您需要從 URL 中讀取參數（例如客戶 ID 或產品 ID）時，您需要：

• 在您的操作的 URI 中定義一個占位符，例如 /customers/{id}
• 稍后獲取您的輸入，使用同名的Header?- 例如 ${header.id}

這是一個示例 - 一個采用客戶 ID 的 REST 刪除操作。該參數 {id} 在聲明uri-如 /customers/12345 。然后可以使用 ${header.id} 以下方法檢索它：

Java DSL

rest("/api/apartments").get("/search?country={country}").to("bean:searchBean?method=byCountry(${header.country})");

XML DSL

<rest path="/api/apartments"><get uri="/search?country={country}"><to uri="bean:searchBean?method=byCountry(${header.country})"/></get>
</rest>

設置 JSON 到 POJO 轉換

最后，我們需要弄清楚我們想要對我們的請求和響應消息做什么。如果您正在接收或發送 JSON，那么 Camel 如何提供幫助？

您可以手動編寫自己的 JSON 字符串，但它非常麻煩，而且編寫一大堆字符串連接也沒什么樂趣！

答案是對您的請求和響應類型使用 POJO。是的，Java 對象。當您將 POJO 用于輸入和輸出消息時，Camel 可以為您的 REST 服務使用者輕松地將這些消息與 JSON 進行相互轉換。如果 Jackson 在類路徑上，Camel 能夠做到這一點。

這是一個示例供您查看。首先，這是我編寫的一個名為 ResponseType 的類，它對來自我的 RESTful API 的響應進行建模。它包含一個字段，message：

public class ResponseType {
?private String message;
?public ResponseType(String message) {this.message = message;}
?public String getMessage() { }return message;}
?public void setMessage(String message) {this.message = message;}
}

?

為了讓 Camel 自動將其從我的 REST 服務編組為 JSON，我確保 .outType() 設置了它，并且它引用了我的自定義 ResponseType 類。這告訴 Camel 它應該期望將類型為?ResponseType?的消息返回給消費者：

rest().path("/my-api")......get().outType(ResponseType.class).to("bean:helloBean"); // this sends the Body to the bean

由于我的 REST 操作的業務邏輯是在 Java bean 中實現的，我只需要確保我的業務邏輯方法返回一個類型為 ResponseType 的對象：

public class HelloBean {public ResponseType sayHello() {return new ResponseType("Hello, world!");}
}

最后，我需要給 Camel 一個提示，將 JSON 綁定到 Java 對象。這是使用 bindingMode 配置完成的，我添加到 restConfiguration 塊中：

restConfiguration().component("servlet").bindingMode(RestBindingMode.auto);

或者，如果您愿意，可以在 XML DSL 中：

<restConfiguration component="servlet" bindingMode="auto"/>

現在，當我使用curl測試服務時，HelloBean 將返回一個 ResponseType 對象。Camel 將使用 Jackson 為我自動將其編組為 JSON - 請注意我如何獲得包含一個字段 的 JSON 對象 message，這就像我上面的示例 POJO：

$ curl http://localhost:8080/services/my-api
{"message":"Hello, world!"}

示例 - 使用 REST DSL 在 Camel 中創建RESTful 服務

現在我們知道使用 Camel 創建 RESTful 服務需要什么——一個將實現服務的組件，以及一些 REST DSL 糖來配置它。這個例子將：

• 使用servlet組件托管 RESTful 服務
• 在默認的 Spring Boot Web 端口上運行，即 8080
• 在 JSON 和 Java 對象之間自動轉換，這樣我們就不必自己搞砸了

要創建服務，請按照下列步驟操作：

1. 創建一個新的 Camel Spring Boot 項目
2. 在您的 Maven POM 中，添加 camel-servlet-starter 為依賴項。這將允許 Camel 將我們的服務部署到嵌入式 Tomcat 容器中：

    <dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-servlet-starter</artifactId></dependency>

3. 添加 camel-jackson-starter 為依賴項。這將允許 Camel 編組到/從 JSON：

    <dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-jackson-starter</artifactId></dependency>

4. 在 RouteBuilder 新項目的 中，添加一個 restConfiguration() 元素。

   ?這將初始化將提供REST 服務的組件。在這個例子中，我們為此使用了 Servlet 組件。

   ?在為服務定義任何操作之前，我們首先執行此操作：

    public void configure() throws Exception {restConfiguration().component("servlet").bindingMode(RestBindingMode.auto);}

5. 定義一個 REST 端點，并為您的每個操作（GET、POST 等）添加框架。

   首先，使用服務的路徑 (URI)定義 REST 端點rest。然后附加您的每個操作- 這些是您的 HTTP 動詞。

   REST 動詞/操作的語法看起來就像熟悉的 Camel 路由。但是，from我們使用您要使用的HTTP 動詞（例如get、post和 ）開始每個操作，而不是delete。

   語言語言

    rest("/api/customers").get().route().to("...").post().route().to("...").delete().route().to("...");

   XML DSL

   <rest path="/api/customers"><get><route><to uri="..."/></route></get><post><route><to uri="..."/></route></post></rest>

   該在什么時候使用哪個 HTTP 動詞上？看到這篇文章的結尾，我寫了一個厚顏無恥的小備忘單。

6. 現在為您的 REST 操作構建您的駱駝路線！以下是已填寫的 REST 服務示例：

   Java DSL

    rest("/customers").get().route().to("bean:customerService?method=listCustomers").post().route().to("jms:queue:CUSTOMERS");

   XML DSL

    <rest path="/customers"><get><route><to uri="bean:customerService?method=listCustomers"/></route></get><post><route><to uri="direct:post"/></route></post></rest>

   正如你所看到的，GET操作通過一個bean為customerService傳遞服務的請求。但是POST操作將請求傳遞給一個直接分量，direct:post。

7. 要添加對自動將請求和響應轉換為 JSON 的支持，請定義代表您的請求和響應消息的 POJO，例如：

    public class CreateCustomerResponse {private String result;// Add some getters and setters here...}

   現在，聲明您的請求和響應類型，以便 Camel 知道如何將它們編組到 JSON 或從 JSON 編組：

    rest().post().route().type(Customer.class).outType(CreateCustomerResponse.class).to("direct:post");

   并確保您已在REST 配置中設置綁定模式：

   restConfiguration().component("servlet").bindingMode(RestBindingMode.auto);

   就是這樣！現在繼續使用您需要的盡可能多的端點和操作來構建您的 REST API。

只是想看看完整的、有效的例子？單擊下面的按鈕查看完整示例：

獲取示例代碼?在 GitHub 上

Apache Camel 實戰

Springboot 整合 Apache Camel 教程

一、Java配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.4</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.demo</groupId><artifactId>spring-boot-camel</artifactId><version>0.0.1-SNAPSHOT</version><name>apache-camel</name><description>spring-ai</description><properties><java.version>17</java.version><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><camel.version>4.5.0</camel.version></properties><dependencies><!-- Spring Boot Starter --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- Apache Camel Spring Boot Starter --><dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-spring-boot-starter</artifactId><version>${camel.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

# application.properties 示例
camel.springboot.main-route-or-bean-name = MyRouteBuilder
camel.springboot.main-run-controller = true

camel:springboot:main-route-or-bean-name: MyRouteBuildermain-run-controller: true

package com.example.camel;import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;@Component
public class MyRouteBuilder extends RouteBuilder {@Overridepublic void configure() throws Exception {from("timer:tick?period=5000") // 每5秒觸發一次.log("Hello from Camel! 1") // 打印日志.to("mock:result") // 發送到mock端點進行測試.log("Hello from Camel! 2");}
}

package com.example;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class SpringCamelDemoApplication {public static void main(String[] args) {SpringApplication.run(SpringCamelDemoApplication.class, args);}}

二、 Spring XML配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.4</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.demo</groupId><artifactId>spring-boot-camel</artifactId><version>0.0.1-SNAPSHOT</version><name>apache-camel</name><description>spring-ai</description><properties><java.version>17</java.version><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><camel.version>4.5.0</camel.version></properties><dependencies><!-- Spring Boot Starter --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- Apache Camel Spring Boot Starter --><dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-spring-boot-starter</artifactId><version>${camel.version}</version></dependency><dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-spring-boot-xml-starter</artifactId><version>${camel.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

# application.properties 示例
camel.springboot.main-run-controller = true

camel:springboot:main-run-controller: true

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:camel="http://camel.apache.org/schema/spring"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://camel.apache.org/schema/springhttp://camel.apache.org/schema/spring/camel-spring.xsd"><camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"><route><from uri="timer:tick?period=5000"/><log message="Hello from Camel! 1"/><to uri="mock:result"/><log message="Hello from Camel! 2"/></route></camelContext>
</beans>

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;@SpringBootApplication
@ImportResource("classpath:camel-config.xml") // 指定XML配置文件路徑
public class SpringCamelDemoApplication {public static void main(String[] args) {SpringApplication.run(SpringCamelDemoApplication.class, args);}}

三、Java配置 和 Spring XML配置 同時兼任

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.4</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.demo</groupId><artifactId>spring-boot-camel</artifactId><version>0.0.1-SNAPSHOT</version><name>apache-camel</name><description>spring-ai</description><properties><java.version>17</java.version><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><camel.version>4.5.0</camel.version></properties><dependencies><!-- Spring Boot Starter --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- Apache Camel Spring Boot Starter --><dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-spring-boot-starter</artifactId><version>${camel.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

# application.properties 示例
camel.springboot.main-route-or-bean-name = MyRouteBuilder
camel.springboot.main-run-controller = true

camel:springboot:main-route-or-bean-name: MyRouteBuildermain-run-controller: true

package com.example.camel;import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;@Component
public class MyRouteBuilder extends RouteBuilder {@Overridepublic void configure() throws Exception {from("file:C://Apps//testSDR").to("file:C://Apps//testSDR//outbox");}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:camel="http://camel.apache.org/schema/spring"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://camel.apache.org/schema/springhttp://camel.apache.org/schema/spring/camel-spring.xsd"><camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"><route><from uri="timer:tick?period=5000"/><log message="Hello from Camel! 1"/><to uri="mock:result"/><log message="Hello from Camel! 2"/></route></camelContext>
</beans>

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;@SpringBootApplication
@ImportResource("classpath:camel-config.xml") // 指定XML配置文件路徑
public class SpringCamelDemoApplication {public static void main(String[] args) {SpringApplication.run(SpringCamelDemoApplication.class, args);}}

四、 XML DSL 配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.4</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.demo</groupId><artifactId>spring-boot-camel</artifactId><version>0.0.1-SNAPSHOT</version><name>apache-camel</name><description>spring-ai</description><properties><java.version>17</java.version><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><camel.version>4.5.0</camel.version></properties><dependencies><!-- Spring Boot Starter --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- Apache Camel Spring Boot Starter --><dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-spring-boot-starter</artifactId><version>${camel.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

# turn off
camel.springboot.routes-include-pattern = false
# scan only in the com/foo/routes classpath
camel.springboot.routes-include-pattern = classpath:com/foo/routes/*.xml

camel:springboot:routes-include-pattern: falseroutes-include-pattern: classpath:com/foo/routes/*.xml

<?xml version="1.0" encoding="UTF-8"?>
<routes xmlns="http://camel.apache.org/schema/spring">
<route id="test"><from uri="timer:tick?period=5000"/><log message="Hello from Camel! 1"/><to uri="mock:result"/><log message="Hello from Camel! 2"/>
</route>
</routes>

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class SpringCamelDemoApplication {public static void main(String[] args) {SpringApplication.run(SpringCamelDemoApplication.class, args);}}

五、手動觸發路由

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.4</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.demo</groupId><artifactId>spring-boot-camel</artifactId><version>0.0.1-SNAPSHOT</version><name>apache-camel</name><description>spring-ai</description><properties><java.version>17</java.version><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><camel.version>4.5.0</camel.version></properties><dependencies><!-- Spring Boot Starter --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- Apache Camel Spring Boot Starter --><dependency><groupId>org.apache.camel.springboot</groupId><artifactId>camel-spring-boot-starter</artifactId><version>${camel.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

# application.properties 示例
camel.springboot.main-route-or-bean-name = MyRouteBuilder
camel.springboot.main-run-controller = true

camel:springboot:main-route-or-bean-name: MyRouteBuildermain-run-controller: true

import org.apache.camel.CamelContext;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;@Component
public class MyRouteBuilder extends RouteBuilder implements CommandLineRunner {@Autowiredprivate CamelContext camelContext;@Overridepublic void run(String... args) throws Exception {// 手動觸發 direct:starttry (ProducerTemplate template = camelContext.createProducerTemplate()) {template.sendBody("direct:start", "Hello Camel!");}}@Overridepublic void configure() throws Exception {// 路由 Afrom("direct:start").log("Processing in Route A").to("direct:pro_pre_CommonSDR_csl") // 跳轉到路由 B.log("Continuing in Route A after B");// 路由 Bfrom("direct:pro_pre_CommonSDR_csl").log("Processing in Route B").to("mock:resultB");}}

package com.example;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class SpringCamelDemoApplication {public static void main(String[] args) {SpringApplication.run(SpringCamelDemoApplication.class, args);}}