Meneroka Ciri Teras dan Komponen Apache Camel

Hello kawan-kawan! Dalam perbincangan kami sebelum ini, kami menyelidiki integrasi Apache Camel dengan Quarkus, menunjukkan cara membuat aplikasi dunia sebenar menggunakan Apache Camel. Sambil kami meneruskan siri kami, kami berhasrat untuk menyelami lebih mendalam komponen penting dan butiran intrinsik Apache Camel.

Corak Integrasi Perusahaan

Pada terasnya, Apache Camel disusun mengikut konsep yang diperkenalkan dalam buku Corak Integrasi Perusahaan (EIP) oleh Gregor Hohpe dan Bobby Woolf. Buku ini menggariskan pelbagai corak yang telah menjadi piawaian untuk mereka bentuk dan mendokumentasikan penyelesaian integrasi yang mantap merentas aplikasi perusahaan
atau sistem. Berikut ialah gambaran keseluruhan beberapa corak penting yang digunakan dalam Apache Camel:

• Pengagregat

Corak Agregator(Rajah 1) adalah penting untuk mengumpul dan menyatukan mesej yang berkaitan menjadi satu mesej tunggal yang padu, memudahkan pemprosesan menyeluruh. Ia bertindak sebagai penapis khusus, mengumpul mesej berkorelasi sehingga satu set lengkap data diterima, pada ketika itu ia menerbitkan output terkumpul
untuk pemprosesan selanjutnya.

Rajah 1 – Corak Agregator (enterpriseintegrationpatterns.com)

• Penghala Berasaskan Kandungan

Corak ini(Rajah 2) menghalakan mesej secara dinamik berdasarkan kandungannya kepada penerima yang sesuai. Keputusan penghalaan boleh bergantung pada pelbagai atribut mesej seperti kehadiran medan atau nilai medan tertentu.

Rajah 2 – Corak Penghala Berasaskan Kandungan (enterpriseintegrationpatterns.com)

• Penghala Dinamik

Penghala Dinamik(Rajah 3) memudahkan keputusan penghalaan yang dibuat pada masa jalan, menyesuaikan secara dinamik berdasarkan peraturan yang ditakrifkan secara luaran atau melalui input pengguna, menyokong seni bina berorientasikan perkhidmatan moden.

Rajah 3 – Corak Penghala Dinamik (enterpriseintegrationpatterns.com)

• Penapis Mesej

Penapis Mesej(Rajah 4) menghalakan mesej ke saluran output atau membuangnya berdasarkan kriteria yang ditetapkan, memastikan hanya mesej yang memenuhi syarat tertentu diproses selanjutnya.

Rajah 4 – Corak Penapis Mesej (enterpriseintegrationpatterns.com)

• Pengurus Proses

Corak ini(Rajah 5) mengatur urutan langkah dalam proses perniagaan, mengendalikan kedua-dua perintah pelaksanaan dan sebarang pengecualian yang berlaku. Ia menyokong aliran kerja yang kompleks di mana pemprosesan berjujukan dan pengurusan ralat adalah kritikal.

Rajah 5 – Corak Pengurus Proses (enterpriseintegrationpatterns.com)

• Normalizer

Corak Normalizer(Rajah 6) ialah alat kritikal dalam Apache Camel yang menangani cabaran percanggahan format mesej antara sistem yang berbeza. Ia memerlukan mesej masuk dalam pelbagai format dan menukarkannya kepada format piawai sebelum diproses selanjutnya, memastikan ketekalan merentas saluran pengendalian data. Corak ini amat berfaedah dalam persekitaran di mana mesej berasal daripada pelbagai sumber dengan format yang berbeza-beza.

Rajah 6 – Corak penormal (enterpriseintegrationpatterns.com)

• Pecah

Mengendalikan mesej kompleks yang terdiri daripada berbilang item data diperkemas oleh corak Pemisah(Rajah 7). Corak ini dengan cekap membahagikan mesej majmuk kepada unsur konstituennya, membolehkan setiap elemen diproses secara bebas. Ini amat berguna dalam senario di mana bahagian berlainan mesej perlu dihalakan atau diproses secara berbeza berdasarkan ciri individunya.

Rajah 7 – Corak pemisah (enterpriseintegrationpatterns.com)

Saya perlu menyatakan bahawa ini hanyalah beberapa corak yang digunakan dalam Apache Camel. Terdapat banyak lagi corak yang digunakan dalam Apache Camel. Tetapi saya menganggap corak ini adalah yang paling penting.

Asas Unta

Pada asasnya, rangka kerja Apache Camel tertumpu pada enjin penghalaan yang berkuasa, atau lebih tepat, pembina enjin penghalaan. Enjin ini memberi kuasa kepada pembangun untuk merangka peraturan penghalaan yang dipesan lebih dahulu, menentukan sumber untuk menerima mesej dan mentakrifkan cara mesej tersebut harus diproses dan dihantar ke pelbagai destinasi. Apache Camel menyokong takrif peraturan penghalaan yang kompleks melalui bahasa penyepaduan yang serupa dengan yang terdapat dalam proses perniagaan yang rumit.

Salah satu prinsip utama Camel ialah sifat agnostik datanya. Fleksibiliti ini penting kerana ia membolehkan pembangun berinteraksi dengan mana-mana jenis sistem tanpa keperluan ketat untuk menukar data kepada format kanonik yang telah ditetapkan. Keupayaan untuk mengendalikan borang data yang pelbagai dengan lancar menjadikan Camel sebagai alat serba boleh dalam kit alat mana-mana penyepadu sistem.

Mesej

Di alam Apache Camel, mesej ialah entiti asas yang memudahkan komunikasi antara sistem melalui saluran pemesejan. Komponen ini digambarkan dalam (Rajah 8). Semasa pelaksanaan laluan, mesej boleh mengalami pelbagai transformasi—ia boleh diubah, diduplikasi,
atau diganti sepenuhnya bergantung pada keperluan khusus proses. Mesej secara semula jadi mengalir secara sehala daripada pengirim kepada penerima dan terdiri daripada beberapa komponen:

• Badan (Muatan Muatan): Kandungan utama mesej.

• Pengepala: Metadata yang dikaitkan dengan mesej yang boleh termasuk kunci dan nilai masing-masing.

• Lampiran: Fail pilihan yang boleh dihantar bersama dengan mesej.

Rajah 8 – Struktur Mesej Unta Apache

Mesej dalam Apache Camel dikenal pasti secara unik oleh pengecam jenis java.lang.String. Keunikan pengecam ini dikuatkuasakan oleh pencipta mesej dan bergantung pada protokol yang digunakan, walaupun format itu sendiri tidak diseragamkan. Untuk protokol yang tidak mempunyai skema pengenalan mesej yang unik, Camel menggunakan penjana IDnya sendiri.

Pengepala dalam mesej Camel berfungsi sebagai pasangan nilai kunci yang mengandungi metadata seperti pengecam penghantar, pembayang tentang pengekodan kandungan, data pengesahan dan banyak lagi. Setiap nama pengepala ialah rentetan yang unik, tidak peka huruf besar-besaran, manakala nilainya boleh berupa sebarang objek (java.lang.Object), mencerminkan pengendalian fleksibel jenis pengepala Camel. Semua pengepala disimpan dalam mesej sebagai peta.

Selain itu, mesej mungkin termasuk lampiran pilihan, biasanya digunakan dalam konteks yang melibatkan perkhidmatan web dan transaksi e-mel. Badan mesej, juga jenis java.lang.Object, adalah serba boleh, menampung sebarang bentuk kandungan. Fleksibiliti ini memberi mandat bahawa pereka aplikasi memastikan kebolehfahaman kandungan merentas sistem yang berbeza. Untuk membantu dalam hal ini, Camel menyediakan pelbagai mekanisme, termasuk penukaran jenis automatik apabila perlu, untuk mengubah data menjadi format yang serasi untuk kedua-dua penghantar dan penerima, memudahkan penyepaduan data yang lancar merentas pelbagai persekitaran.

Pertukaran

Dalam Apache Camel, Exchange ialah bekas mesej penting yang menavigasi data melalui laluan Camel. Seperti yang digambarkan dalam (Rajah 9), ia merangkum mesej, menyokong transformasi dan pemprosesannya melalui satu siri langkah yang dipratentukan dalam laluan Camel. Exchange melaksanakan antara muka org.apache.camel.Exchange berikut.

Rajah 9 – Pertukaran Unta Apache

Pertukaran direka bentuk untuk menampung gaya pemesejan yang berbeza, terutamanya menekankan corak permintaan-balas. Ia cukup teguh untuk membawa maklumat tentang kesalahan atau ralat, sekiranya pengecualian timbul semasa pemprosesan mesej.

• ID Pertukaran: Ini ialah pengecam unik untuk pertukaran, dijana secara automatik oleh Camel untuk memastikan kebolehkesanan..

• Corak Pertukaran Mesej MEP: Menyatakan gaya pemesejan, sama ada InOnly atau InOut. Untuk InOnly, transaksi hanya melibatkan mesej masuk. Untuk InOut, mesej keluar tambahan (Mesej Keluar) wujud untuk menyampaikan respons kembali kepada pemula.

• Pengecualian - Exchange menangkap pengecualian yang berlaku semasa penghalaan, memusatkan pengurusan ralat untuk pengendalian dan pengurangan yang mudah.

• Badan: Setiap mesej (Masuk dan Keluar) mengandungi muatan jenis java.lang.Object, membenarkan jenis kandungan yang pelbagai.

• Pengepala: Disimpan sebagai peta, pengepala termasuk pasangan nilai kunci yang dikaitkan dengan mesej, membawa metadata seperti isyarat penghalaan, kunci pengesahan dan maklumat kontekstual lain.

• Sifat: Sama seperti pengepala tetapi bertahan untuk keseluruhan pertukaran, sifat memegang data peringkat global yang berkaitan sepanjang kitaran hayat pemprosesan mesej.

• Dalam mesej: Komponen asas, elemen wajib ini merangkum data permintaan masuk daripada saluran masuk.

• Mesej keluar: Komponen pilihan yang wujud dalam pertukaran InOut, membawa data respons ke saluran keluar.

Dalam Apache Camel, Exchange ialah bekas mesej yang membawa data melalui laluan Camel. Ia merangkum mesej dan membolehkannya diubah dan diproses merentasi satu siri langkah pemprosesan yang ditakrifkan dalam laluan Camel. Exchange juga memudahkan corak pemesejan permintaan-balas dan mungkin membawa maklumat kesalahan atau ralat jika pengecualian berlaku semasa pemprosesan mesej.

Konteks Unta

Konteks Apache Camel ialah elemen penting dalam Apache Camel, berfungsi sebagai rangka kerja teras yang mengatur kefungsian rangka kerja penyepaduan. Di sinilah peraturan penghalaan, konfigurasi, komponen dan elemen penyepaduan tambahan berkumpul. Konteks Unta(Rajah 10) memulakan, mengkonfigurasi dan mengawasi kitaran hayat semua komponen dan laluan yang terkandung di dalamnya.

Rajah 10 – Konteks Apache Camel

Dalam Konteks Unta, operasi kritikal berikut dipermudahkan:

• Memuatkan Komponen dan Format Data: Ini melibatkan pengurusan permulaan dan ketersediaan komponen dan format data yang digunakan merentas pelbagai laluan.

• Mengkonfigurasi Laluan: Ia menyediakan mekanisme untuk menentukan laluan yang diikuti oleh mesej, termasuk peraturan untuk cara mesej diproses dan dimediasi merentas titik akhir yang berbeza.

• Memulakan dan Menghentikan Laluan: Konteks Unta menguruskan pengaktifan dan penyahaktifan laluan, memastikan operasi ini dilakukan dengan cara selamat benang.

• Pengendalian Ralat: Melaksanakan mekanisme pengendalian ralat terpusat yang boleh digunakan merentasi semua laluan dalam konteks.

• Mengurus Sumber: Ia memastikan pengurusan sumber yang cekap seperti kumpulan benang atau sambungan, melepaskannya dengan sewajarnya apabila tidak diperlukan lagi.

Konteks Unta boleh dikonfigurasikan sama ada secara atur cara atau deklaratif. Contohnya, dalam persediaan berasaskan Java:

import org.apache.camel.CamelContext;
import org.apache.camel.impl.DefaultCamelContext;

public class MainApp {
    public static void main(String[] args) {
        CamelContext camelContext = new DefaultCamelContext();
        try {
            // Add routes, components, etc.
            camelContext.start();
            Thread.sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                camelContext.stop();
            } catch (Exception e) {
               // Handle exception
            }
        }
    }
}

Untuk persekitaran seperti Quarkus, Konteks Unta biasanya diambil dan diuruskan seperti berikut:

@Inject CamelContext context;

if (context.isStarted()) {
  context.getRouteController().startRoute("start_route");
}

Apabila memanfaatkan Quarkus, Konteks Unta diperuntukkan dan diuruskan secara automatik:

@ApplicationScoped
public class DemoRoute extends RouteBuilder {

  @Override
  public void configure() throws Exception {

    from("direct:start_route")
        .log("Starting route: ${routeId}, headers: ${headers}")
        .setHeader("header_abc", constant("header_value"))
        .to("direct:route_1")
        .to("direct:route_3");
  }
}

Titik akhir

Dalam Apache Camel, titik akhir mewakili antara muka untuk menyambungkan aplikasi Camel dengan sistem atau perkhidmatan luaran. Ia adalah titik di mana laluan sama ada bermula (menggunakan) atau menamatkan (menghasilkan).

Beberapa jenis titik akhir yang biasa termasuk:

• Titik akhir fail Camel boleh digunakan untuk membaca dan menulis ke fail dalam direktori.

    // Route to read files from the directory "input" and move 
    processed files to "output"
    from("file:input?move=processed")
   .to("file:output");

• Titik akhir HTTP digunakan untuk menyepadukan dengan perkhidmatan HTTP.

    // Route to consume data from an HTTP service
    from("timer:foo?period=60000")
   .to("http://example.com/api/data")
   .to("log:result");

• Langsung dan SEDA Kedua-dua langsung dan seda digunakan untuk baris gilir mesej segerak dan tak segerak dalam ingatan dalam Camel.

// Using direct for synchronous call
from("direct:start")
    .to("log:info");

Laluan

Laluan dalam Camel mentakrifkan aliran mesej antara titik akhir, menggabungkan satu siri pemproses atau transformasi. Ia adalah penting untuk membina logik pemprosesan dalam aplikasi Camel.

Berikut ialah contoh yang menunjukkan satu siri laluan yang saling berkaitan:

@ApplicationScoped
public class DemoRoute extends RouteBuilder {

  @Override
  public void configure() throws Exception {

    from("direct:start_route")
        .log("Starting route: ${routeId}, headers: ${headers}")
        .setHeader("header_abc", constant("header_value"))
        .to("direct:route_1")
        .to("direct:route_3");

    from("direct:route_1")
        .log("Starting route_1: ${routeId}, headers: ${headers}, thread: ${threadName}")
        .process(
            exchange -> {
              exchange.getIn().setHeader("header_abc", "UPDATED_HEADER_VALUE");
            })
        .to("direct:route_2");

    from("direct:route_2")
        .log("Starting route_2: ${routeId}, headers: ${headers}, thread: ${threadName}");
  }
}

Di sini laluan pertama bermula dari titik tamat direct:start_route, log routeId dan pengepala, tetapkan pengepala baharu dengan kunci: header_abc, dan kemudian majukan mesej ke laluan seterusnya direct:route_1. Laluan kedua merekodkan routeId, pengepala dan nama utas, dan kemudian memajukan mesej ke laluan seterusnya direct:route_2. Laluan ketiga merekodkan routeId, pengepala dan nama urutan.

Kesimpulan

Dalam penerokaan terperinci Apache Camel ini, kami telah menelusuri konsep teras dan komponen penting yang menjadikannya alat yang amat diperlukan dalam bidang penyepaduan perusahaan. Bermula dengan pemeriksaan menyeluruh Corak Integrasi Perusahaan (EIP), kami memahami cara Camel menggunakan corak seperti Agregator, Splitters dan Normalizers untuk menangani cabaran integrasi biasa dengan berkesan.

Selanjutnya, kami menyelidiki asas seni bina Camel, menyerlahkan keupayaan penghalaan serba boleh, model mesej yang fleksibel dan peranan penting Konteks Camel dalam mengurus dan mengatur elemen ini. Kami juga merangkumi aspek praktikal, menunjukkan cara laluan ditakrifkan dan diurus, bersama-sama dengan melihat pelbagai jenis titik akhir yang memudahkan komunikasi dengan sistem luaran.

Atas ialah kandungan terperinci Meneroka Ciri Teras dan Komponen Apache Camel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!