Menggunakan Apache Camel dengan Spring

1. Ikhtisar

Artikel ini akan mendemonstrasikan cara mengkonfigurasi dan menggunakan Apache Camel dengan Spring.

Apache Camel menyediakan cukup banyak komponen berguna yang mendukung pustaka seperti JPA, Hibernate, FTP, Apache-CXF, AWS-S3 dan tentu saja banyak lainnya - semuanya untuk membantu mengintegrasikan data antara dua sistem yang berbeda.

Misalnya, dengan menggunakan komponen Hibernate dan Apache CXF, Anda dapat mengambil data dari database dan mengirimkannya ke sistem lain melalui panggilan REST API.

Dalam tutorial ini, kita akan membahas contoh Camel sederhana - membaca file dan mengubah isinya menjadi huruf besar dan kemudian kembali ke huruf kecil. Kita akan menggunakan komponen File Camel dan Spring 4.2.

Berikut detail lengkap dari contoh tersebut:

  1. Baca file dari direktori sumber
  2. Ubah konten file menjadi huruf besar menggunakan Prosesor kustom
  3. Tulis keluaran yang dikonversi ke direktori tujuan
  4. Ubah konten file menjadi huruf kecil menggunakan Camel Translator
  5. Tulis keluaran yang dikonversi ke direktori tujuan

2. Tambahkan Dependensi

Untuk menggunakan Apache Camel dengan Spring, Anda memerlukan dependensi berikut di file POM Anda:

 2.16.1 4.2.4.RELEASE    org.apache.camel camel-core ${env.camel.version}   org.apache.camel camel-spring ${env.camel.version}   org.apache.camel camel-stream ${env.camel.version}   org.springframework spring-context ${env.spring.version}  

Jadi kita punya:

  • camel-core - ketergantungan utama untuk Apache Camel
  • unta-pegas - memungkinkan kita menggunakan Unta dengan Pegas
  • camel-stream - ketergantungan opsional, yang dapat Anda gunakan (misalnya) untuk menampilkan beberapa pesan di konsol saat rute sedang berjalan
  • konteks musim semi - ketergantungan Musim semi standar, diperlukan dalam kasus kami karena kami akan menjalankan rute Unta dalam konteks Musim Semi

3. Konteks Unta Musim Semi

Pertama, kita akan membuat file Spring Config dimana kita nantinya akan menentukan rute Camel kita.

Perhatikan bagaimana file tersebut berisi semua namespace Apache dan Spring yang diperlukan serta lokasi skema:

Itu elemen mewakili (tidak mengherankan) konteks Unta, yang dapat dibandingkan dengan konteks aplikasi Musim Semi. Sekarang file konteks Anda siap untuk mulai menentukan rute Camel.

3.1. Rute Unta Dengan Prosesor Kustom

Selanjutnya kita akan menulis rute pertama kita untuk mengubah konten file menjadi huruf besar.

Kita perlu menentukan sumber dari mana rute akan membaca data. Ini bisa berupa database, file, konsol, atau sejumlah sumber lainnya. Dalam kasus kami, itu akan menjadi file.

Kemudian kita perlu menentukan prosesor dari data yang akan dibaca dari sumbernya. Untuk contoh ini, kita akan menulis kelas prosesor khusus. Kelas ini akan menjadi kacang Spring yang akan mengimplementasikan Antarmuka Prosesor Camel standar.

Setelah data diproses, kita perlu memberi tahu rute ke mana mengarahkan data yang diproses. Sekali lagi, ini bisa menjadi salah satu dari berbagai macam output, seperti database, file, atau konsol. Dalam kasus kami, kami akan menyimpannya dalam sebuah file.

Untuk mengatur langkah-langkah ini, termasuk input, prosesor, dan output, tambahkan rute berikut ke file konteks Unta:

Selain itu, kita harus mendefinisikan kacang myFileProcessor :

3.2. Prosesor Huruf Besar Kustom

Sekarang kita perlu membuat prosesor file kustom yang kita definisikan di bean kita. Itu harus mengimplementasikan antarmuka Camel Processor , mendefinisikan metode proses tunggal , yang mengambil objek Exchange sebagai inputnya. Objek ini memberikan detail data dari sumber input.

Metode kami harus membaca pesan dari Exchange , huruf besar konten, dan kemudian mengatur konten baru itu kembali ke objek Exchange :

public class FileProcessor implements Processor { public void process(Exchange exchange) throws Exception { String originalFileContent = (String) exchange.getIn().getBody(String.class); String upperCaseFileContent = originalFileContent.toUpperCase(); exchange.getIn().setBody(upperCaseFileContent); } }

Metode proses ini akan dijalankan untuk setiap masukan yang diterima dari sumber.

3.3. Prosesor Huruf Kecil

Sekarang kita akan menambahkan keluaran lain ke rute Unta kita. Kali ini, kami akan mengubah data file input yang sama menjadi huruf kecil. Namun kali ini, kami tidak akan menggunakan prosesor ubahsuaian; kami akan menggunakan fitur Penerjemah Pesan Apache Camel. Ini adalah rute Unta yang diperbarui:

     ${body.toLowerCase()}   

4. Menjalankan Aplikasi

Agar rute kita diproses, kita hanya perlu memuat file konteks Camel ke dalam konteks aplikasi Spring:

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("camel-context.xml"); 

Setelah rute berhasil dijalankan, dua file akan dibuat: satu dengan konten huruf besar, dan satu dengan konten huruf kecil.

5. Kesimpulan

Jika Anda melakukan pekerjaan integrasi, Apache Camel pasti dapat membuat segalanya lebih mudah. Pustaka menyediakan komponen plug-and-play yang akan membantu Anda mengurangi kode boilerplate dan fokus pada logika utama pemrosesan data.

Dan jika Anda ingin menjelajahi konsep Pola Integrasi Perusahaan secara mendetail, Anda harus melihat buku yang ditulis oleh Gregor Hohpe dan dan Bobby Woolf ini, yang mengkonsep EIP dengan sangat rapi.

Contoh yang dijelaskan dalam artikel ini tersedia dalam sebuah proyek di GitHub.