Saya tidak mengerti apa sebenarnya yang dilakukan Unta .
Jika Anda bisa memberikan 101 kata pengantar untuk Unta:
Tolong jelaskan apa itu Unta.
Jawaban:
Jika Anda memiliki 5 hingga 10 menit, saya biasanya merekomendasikan orang untuk membaca Integrasi ini dengan Apache Camel oleh Jonathan Anstey. Ini adalah karya yang ditulis dengan baik yang memberikan pengantar singkat dan ikhtisar dari beberapa konsep Camel, dan mengimplementasikan kasus penggunaan dengan sampel kode. Di dalamnya, Jonathan menulis:
Apache Camel adalah kerangka kerja Java sumber terbuka yang berfokus pada membuat integrasi lebih mudah dan lebih mudah diakses oleh pengembang. Ini dilakukan dengan menyediakan:
- implementasi konkrit dari semua Pola Integrasi Enterprise (EIP) yang banyak digunakan
- konektivitas ke berbagai macam transportasi dan API
- Domain Specific Languages (DSLs) yang mudah digunakan untuk mentransfer EIP dan transportasi bersama
Ada juga bab gratis Unta Beraksi yang memperkenalkan Unta di bab pertama. Jonathan adalah penulis bersama buku itu dengan saya.
Saya mengambil untuk menggambarkan ini dengan cara yang lebih mudah diakses ...
Untuk memahami apa itu Apache Camel, Anda perlu memahami apa Pola Integrasi Perusahaan itu.
Mari kita mulai dengan apa yang mungkin sudah kita ketahui: Pola Singleton, pola Pabrik, dll; Mereka hanyalah cara mengatur solusi Anda untuk masalah, tetapi mereka bukan solusi itu sendiri. Pola-pola ini dianalisis dan diekstraksi untuk kita semua oleh Geng Empat, ketika mereka menerbitkan buku mereka: Pola Desain . Mereka menyelamatkan beberapa dari kita upaya luar biasa dalam memikirkan bagaimana cara terbaik menyusun kode kita.
Banyak seperti Gang of Four, Gregor Hohpe dan Bobby Woolf menulis buku Integrasi Enterprise Pola (EIP) di mana mereka mengusulkan dan mendokumentasikan satu set pola-pola baru dan cetak biru untuk bagaimana kita bisa terbaik desain sistem berbasis komponen besar, di mana komponen dapat berjalan pada proses yang sama atau di mesin yang berbeda.
Mereka pada dasarnya mengusulkan agar kami menyusun sistem kami agar berorientasi pada pesan - di mana komponen berkomunikasi satu sama lain menggunakan pesan sebagai input dan output dan sama sekali tidak ada yang lain. Mereka menunjukkan kepada kita seperangkat pola lengkap yang dapat kita pilih dan terapkan dalam komponen yang berbeda yang akan bersama-sama membentuk keseluruhan sistem.
Jadi apa itu Unta Apache?
Apache Camel menawarkan Anda antarmuka untuk EIP, objek dasar, implementasi yang biasanya dibutuhkan, alat debugging, sistem konfigurasi, dan banyak bantuan lain yang akan menghemat banyak waktu ketika Anda ingin mengimplementasikan solusi Anda untuk mengikuti EIP.
Ambil MVC. Secara teori MVC cukup sederhana dan kita bisa mengimplementasikannya tanpa bantuan kerangka kerja. Tapi kerangka kerja MVC yang baik memberi kita struktur yang siap digunakan dan telah bekerja keras dan memikirkan semua hal "sisi" lain yang Anda butuhkan ketika Anda membuat proyek MVC besar dan itulah sebabnya kami paling sering menggunakannya.
Itulah tepatnya Apache Camel untuk EIP. Ini adalah kerangka kerja siap produksi lengkap untuk orang-orang yang ingin menerapkan solusi mereka untuk mengikuti EIP.
Membuat deskripsi proyek seharusnya tidak rumit.
Saya katakan:
Apache Camel adalah lem teknologi pengiriman pesan dengan perutean. Ini bergabung bersama titik awal dan akhir olahpesan yang memungkinkan pemindahan pesan dari berbagai sumber ke tujuan yang berbeda. Misalnya: JMS -> JSON, HTTP -> JMS atau funneling FTP -> JMS, HTTP -> JMS, JSON -> JMS
Wikipedia mengatakan:
Apache Camel adalah mesin routing dan mediasi berbasis aturan yang menyediakan implementasi Java berbasis objek dari Pola Integrasi Enterprise menggunakan API (atau bahasa spesifik Domain Java deklaratif) untuk mengkonfigurasi aturan routing dan mediasi. Bahasa khusus domain berarti bahwa Apache Camel dapat mendukung penyelesaian aturan routing cerdas yang aman untuk tipe di IDE Anda menggunakan kode Java biasa tanpa sejumlah besar file konfigurasi XML; meskipun konfigurasi XML di dalam Spring juga didukung.
Lihat? Itu tidak sulit kan?
Pendeknya:
Ketika ada persyaratan untuk menghubungkan / mengintegrasikan sistem, Anda mungkin perlu menghubungkan ke beberapa sumber data dan kemudian memproses data ini agar sesuai dengan persyaratan bisnis Anda.
Untuk melakukan itu:
1) Anda dapat mengembangkan program khusus yang akan melakukannya (mungkin memakan waktu dan sulit dipahami, dipelihara untuk pengembang lain)
2) Atau, Anda dapat menggunakan Apache Camel untuk melakukannya dengan cara standar (sebagian besar konektor sudah dikembangkan untuk Anda, Anda hanya perlu mengaturnya dan menyambungkan logika Anda - disebut Proses):
Unta akan membantu Anda untuk:
Dengan menggunakan Apache Camel Anda akan membuatnya mudah untuk memahami / memelihara / memperluas sistem Anda ke pengembang lain.
Apache Camel dikembangkan dengan Pola Integrasi Perusahaan. Pola ini membantu Anda untuk mengintegrasikan sistem dengan cara yang baik :-)
Unta mengirim pesan dari A ke B:
Mengapa seluruh kerangka kerja untuk ini? Nah, bagaimana jika Anda memiliki:
ftp, http, jms, dll)Jadi sekarang Anda perlu:
Unta memberi Anda di atas (dan lebih banyak) di luar kotak:
dengan bahasa DSL yang keren bagi Anda untuk menentukan apa dan bagaimana:
new DefaultCamelContext().addRoutes(new RouteBuilder() {
public void configure() {
from("jms:incomingMessages")
.choice() // start router rules
.when(header("CamelFileName")
.endsWith(".xml"))
.to("jms:xmlMessages")
.when(header("CamelFileName")
.endsWith(".csv"))
.to("ftp:csvMessages");
}Lihat juga ini dan ini dan Unta dalam Tindakan (seperti yang orang lain katakan, buku yang bagus!)
Diagram lebih baik daripada ribuan deskripsi. Diagram ini menggambarkan arsitektur Unta.
BERDASARKAN ANALOGI
Perutean berbasis unta dapat dipahami dengan lebih mudah dengan menempatkan diri Anda pada posisi pemilik Maskapai Penerbangan (mis .: American Airlines, Jet Airways).
Tujuan dari 'maskapai Anda' adalah untuk 'membawa' 'penumpang' dari satu 'kota' ke kota lain di dunia. Anda menggunakan pesawat dari 'perusahaan pesawat' yang berbeda seperti Boeing, Airbus, HAL untuk mengangkut penumpang.
Maskapai Anda naik penumpang menggunakan 'bandara' dari kota dan men-debo mereka menggunakan bandara ke kota. Seorang penumpang dapat 'bepergian' ke beberapa kota, tetapi ke mana pun mereka harus melalui bandara untuk melakukan perjalanan antara pesawat maskapai dan kota Anda.
Perhatikan bahwa penumpang yang 'berangkat' dari kota pada dasarnya 'datang' ke pesawat maskapai Anda. Dan seorang pelintas yang 'tiba' ke kota, pada dasarnya berangkat dari pesawat. Karena kita berada dalam posisi pemilik maskapai penerbangan, istilah 'penumpang yang datang' dan 'penumpang yang berangkat' dibalik dari konsep konvensional yang didasarkan pada perspektif kota.
Infrastruktur 'bandara' yang sama di setiap kota digunakan oleh penumpang yang 'berangkat' dan penumpang 'kedatangan'. Bandara menyediakan 'infrastruktur keberangkatan' untuk penumpang yang berangkat, yang berbeda dari 'infrastruktur kedatangan' yang disediakan untuk penumpang yang tiba.
Penumpang dapat terus melakukan hari mereka untuk kegiatan mereka karena berbagai 'fasilitas' yang disediakan di dalam pesawat oleh maskapai Anda, saat bepergian.
Selain itu, maskapai Anda juga menyediakan fasilitas lounge untuk perawatan khusus seperti 'memahami bahasa lokal' dan atau mempersiapkan Anda untuk 'perjalanan'.
Mari kita ganti beberapa kata / frasa yang digunakan di atas dengan yang berikut:
maskapai Anda: Apache Camel
perusahaan pesawat: mekanisme transportasi
pesawat maskapai Anda: mekanisme transportasi yang mendasari Apache Camel
bawa: rute
penumpang: pesan;
kota: sistem;
bandara: Komponen Unta;
memahami bahasa lokal: Jenis Konversi;
berangkat: memproduksi, diproduksi
tiba: mengkonsumsi, dikonsumsi
perjalanan: dialihkan
fasilitas: disediakan
Setelah mengganti kata-kata, inilah yang Anda dapatkan:
Tujuan 'Apache Camel' adalah untuk merutekan 'pesan' dari satu 'sistem' ke sistem lainnya di dunia. Unta Apache menggunakan berbagai mekanisme transportasi untuk perutean pesan.
Apache Camel mengambil pesan menggunakan 'Komponen berbasis unta' dari 'dari' sistem dan menjatuhkannya menggunakan 'Komponen berbasis unta' dari sistem 'ke'. Sebuah pesan mungkin mengarahkan ke beberapa sistem, tetapi di mana pun mereka harus melalui 'Komponen berbasis unta' untuk melakukan perjalanan antara 'mekanisme transportasi yang mendasari Apache Camel' dan sistem.
Perhatikan bahwa pesan 'dihasilkan' dari sistem pada dasarnya 'dikonsumsi' ke dalam mekanisme transportasi yang mendasari Apache Camel '. Dan pesan yang dikonsumsi oleh suatu sistem, pada dasarnya diproduksi oleh 'mekanisme transportasi yang mendasari Apache Camel'.
Karena kita berusaha memahami Camel, kita harus berpikir dari perspektif Camel di sini dan seterusnya. Arti dari istilah 'pesan konsumen' dan 'pesan produsen', dengan demikian, dibalik dari pengertian konvensional kami yang didasarkan pada perspektif sistem.
'Infrastruktur pengkodean Komponen berbasis Camel' yang sama digunakan oleh 'pesan produsen' dan 'pesan konsumen'. 'Komponen berbasis unta' menyediakan 'titik akhir produsen' untuk 'pesan produsen' dan 'titik akhir konsumen' untuk 'pesan konsumen'.
Pesan dapat diproses oleh Camel saat sedang dirutekankan.
Di atas perutean ini, Camel menyediakan fitur-fitur khusus seperti 'Jenis Konversi' dan banyak lagi ...
Salah satu hal yang perlu Anda pahami, sebelum Anda mencoba memahami Apache Camel, adalah Pola Integrasi Perusahaan. Tidak semua orang di lapangan benar-benar menyadarinya. Meskipun Anda pasti bisa membaca buku Pola Integrasi Perusahaan, cara yang lebih cepat untuk mempercepatnya adalah dengan membaca sesuatu seperti artikel Wikipedia tentang Integrasi Aplikasi Perusahaan .
Jika Anda telah membaca dan memahami bidang subjek, Anda akan lebih mungkin memahami tujuan Apache Camel
HTH
Jika Anda mengetahui Pola Integrasi Perusahaan, Apache Camel adalah salah satu kerangka kerja integrasi yang mengimplementasikan semua EIP.
Dan Anda dapat menggunakan Camel sebagai aplikasi mandiri dalam wadah web.
Pada dasarnya, jika Anda harus mengintegrasikan beberapa aplikasi dengan berbagai protokol dan teknologi, Anda dapat menggunakan Unta.
Definisi dari perspektif lain:
Apache Camel adalah kerangka kerja integrasi. Ini terdiri dari beberapa perpustakaan Java, yang membantu Anda menerapkan masalah integrasi pada platform Java. Apa artinya ini dan bagaimana perbedaannya dari API di satu sisi dan Enterprise Service Bus (ESB) di sisi lain dijelaskan dalam artikel saya " Kapan menggunakan Apache Camel ".
Apa itu sebenarnya?
Apache Camel adalah kerangka kerja integrasi ringan yang mengimplementasikan semua pola Integrasi Perusahaan. Anda dapat dengan mudah mengintegrasikan berbagai aplikasi menggunakan pola yang diperlukan.
Anda dapat menggunakan Java, Spring XML, Scala atau Groovy. Hampir setiap teknologi yang dapat Anda bayangkan tersedia, misalnya HTTP, FTP, JMS, EJB, JPA, RMI, JMS, JMX, LDAP, Netty dll.
Lihat artikel ini dan artikel pola EIP
Bagaimana cara berinteraksi dengan aplikasi yang ditulis dalam Java?
Unta menggunakan Java Domain Specific Language atau DSL untuk membuat Pola atau Rute Integrasi Perusahaan dalam berbagai bahasa khusus domain (DSL) seperti yang tercantum di bawah ini.
Java DSL - berbasis Java menggunakan gaya pembangun yang lancar.
Kisah Pola Integrasi Perusahaan menyelesaikan seputar konsep-konsep ini:
Pesan, Titik Akhir, Produser, Konsumen, Perutean, Bus, Transformasi dan Proses .
Lihat artikel ini oleh Anirban Konar untuk salah satu kasus penggunaan waktu nyata.
Apakah ini sesuatu yang berjalan bersama dengan server?
Ini bertindak sebagai jembatan di beberapa sub sistem perusahaan.
Apakah ini program independen?
Apache Camel, kerangka integrasi, mengintegrasikan berbagai aplikasi independen.
Keuntungan utama Camel : Anda dapat mengintegrasikan berbagai aplikasi dengan berbagai teknologi (dan protokol berbeda) dengan menggunakan konsep yang sama untuk setiap integrasi.
Kebanyakan hal "baru" dalam komputasi sama sekali bukan hal baru, mereka hanya pembungkus yang membingungkan di sekitar sesuatu yang sudah dipahami dengan baik. Ketika mereka sulit dimengerti, biasanya karena seseorang memutuskan untuk menemukan istilah bahasa baru atau menjajah istilah yang ada untuk tujuan yang berbeda (contoh yang bagus untuk itu adalah pembalikan pengembang X dari apa yang 'klien' dan 'server' berarti.)
Camel adalah pembungkus / API berbasis Java untuk middleware antar-aplikasi.
Middleware adalah istilah umum untuk perangkat lunak yang menyediakan layanan interpretasi antara entitas yang tidak berbagi bahasa atau tipe data yang sama.
Itulah unta, di bagian bawah. Kita dapat menyempurnakan deskripsi dengan mencatat bahwa itu menyediakan middleware tipe EIP.
Itu tidak menyediakan middleware itu sendiri, karena ia tidak dapat mengetahui detail dari apa yang aplikasi perlu berkomunikasi. Tapi itu menyediakan API untuk membuat bagian invarian dari middleware itu (membuat titik awal, membuat titik akhir, membuat kondisi untuk memulai dan mengakhiri, dll)
Semoga itu bisa membantu.
Ini adalah upaya lain untuk itu.
Anda tahu bagaimana ada hal-hal seperti Metode Web, ICAN Seebeyond, Tibco BW, IBM Broker. Mereka semua memang membantu dengan solusi integrasi di perusahaan. Alat-alat ini umumnya dikenal dengan nama Enterprise Application Integration (EAI) tools.
Sebagian besar alat drag drop dibangun di sekitar teknologi ini dan di bagian Anda harus menulis adaptor di Jawa. Kode adaptor ini tidak teruji atau memiliki perkakas / otomatisasi yang buruk saat pengujian.
Seperti halnya pola desain dalam pemrograman, Anda memiliki pola Integrasi Perusahaan untuk solusi integrasi umum. Mereka menjadi terkenal oleh sebuah buku dengan nama yang sama oleh Gregor Hohpe dan Bobby Woolf.
Meskipun sangat mungkin untuk mengimplementasikan solusi integrasi yang menggunakan satu atau banyak EIP, Camel adalah upaya melakukan hal ini dalam basis kode Anda menggunakan salah satu dari XML, Java, Groovy atau Scala.
Camel mendukung semua Pola Integrasi Perusahaan yang tercantum dalam buku melalui DSL yang kaya dan mekanisme perutean.
Jadi Camel adalah teknisi yang bersaing dengan alat EAI lainnya dengan dukungan yang lebih baik untuk menguji kode integrasi Anda. Kode ini ringkas karena Domain Specific Languages (DSLs). Ini dapat dibaca oleh bahkan pengguna bisnis dan gratis dan membuat Anda produktif.
Ada banyak kerangka kerja yang memfasilitasi kami untuk pengiriman pesan dan memecahkan masalah dalam pengiriman pesan. Salah satu produk tersebut adalah Apache Camel.
Sebagian besar masalah umum memiliki solusi terbukti yang disebut pola desain. Pola desain untuk olahpesan adalah Pola Integrasi Perusahaan (EIP) yang dijelaskan dengan baik di sini . Unta Apache membantu kami menerapkan solusi kami menggunakan EIP.
Kekuatan kerangka integrasi adalah kemampuannya untuk memfasilitasi kami melalui EIP atau pola lainnya, jumlah transportasi dan komponen dan kemudahan pengembangan yang menjadi basis unta Apache di bagian atas daftar
Masing-masing Kerangka memiliki kelebihannya sendiri. Beberapa fitur khusus unta Apache adalah sebagai berikut.
Dalam bahasa Inggris biasa, unta menyelesaikan banyak hal tanpa banyak kode pelat ketel.
Hanya untuk memberi Anda perspektif, Java DSL yang diberikan di bawah ini akan membuat titik akhir REST yang akan dapat menerima XML yang terdiri dari Daftar Produk dan membaginya menjadi beberapa produk dan memanggil metode Proses dari BrandProcessor dengannya. Dan hanya dengan menambahkan .parallelProcessing (perhatikan bagian komentar) ia akan memproses semua Objek Produk secara paralel. (Kelas produk adalah JAXB / XJC dihasilkan rintisan Java dari XSD yang dibatasi oleh input xml.) Banyak kode ini (bersama dengan beberapa dependensi Camel) akan mendapatkan pekerjaan yang digunakan untuk mengambil 100-baris baris kode Java.
from("servlet:item-delta?matchOnUriPrefix=true&httpMethodRestrict=POST")
.split(stax(Product.class))
/*.parallelProcessing()*/
.process(itemDeltaProcessor);Setelah menambahkan ID rute dan pernyataan logging
from("servlet:item-delta?matchOnUriPrefix=true&httpMethodRestrict=POST")
.routeId("Item-DeltaRESTRoute")
.log(LoggingLevel.INFO, "Item Delta received on Item-DeltaRESTRoute")
.split(stax(Product.class))
.parallelProcessing()
.process(itemDeltaProcessor);Ini hanya sampel, Unta jauh lebih dari sekadar titik akhir REST. Lihatlah daftar komponen pluggable http://camel.apache.org/components.html
Unta membantu dalam perutean, transformasi, pemantauan.
Menggunakan Routes; yang dapat digambarkan sebagai:
Ketika service bus menerima pesan tertentu, itu akan merutekannya melalui no tujuan layanan / broker seperti antrian / topik. Jalur ini dikenal sebagai rute.
Contoh: aplikasi stok Anda telah mendapat beberapa input oleh analis, itu akan diproses melalui aplikasi / komponen web dan kemudian hasilnya akan dipublikasikan ke semua anggota yang tertarik / terdaftar untuk pembaruan stok tertentu.
Asumsikan Anda membuat perusahaan e-commerce seperti Amazon, dan Anda hanya ingin fokus pada strategi / pilihan produk yang akan dijual. tidak seperti armada pengiriman amazon, alih-alih Anda sendiri yang menangani pemindahan barang dari penjual ke gudang, buat perubahan di gudang seperti pengemasan dan kirim ke luar kota dan pelanggan. Anda menyewa perusahaan yang melakukan semua ini dan hanya memberi mereka info tentang semua lokasi gudang Anda, jenis kendaraan, lokasi pengiriman dan daftar kapan harus melakukan apa. Kemudian mereka menanganinya sendiri, itu adalah Apache Camel. Mereka mengurus hal-hal dari satu ujung ke ujung yang lain, begitu Anda menyerahkan barang kepada mereka, sehingga Anda bebas untuk fokus pada hal-hal lain.
Camel adalah kerangka kerja dengan API dan model pemrograman yang konsisten untuk mengintegrasikan aplikasi bersama. API didasarkan pada teori dalam Pola Integrasi Perusahaan - yaitu sekelompok pola desain yang cenderung menggunakan perpesanan. Ini menyediakan implementasi kotak dari sebagian besar pola-pola ini, dan juga kapal dengan lebih dari 200 komponen yang berbeda yang dapat Anda gunakan untuk dengan mudah berbicara dengan semua jenis sistem lain. Untuk menggunakan Camel, pertama-tama tulis logika bisnis Anda di POJO dan implementasikan antarmuka sederhana yang berpusat di sekitar pesan. Kemudian gunakan DSL Camel untuk membuat "Rute" yang merupakan seperangkat aturan untuk menempelkan aplikasi Anda bersama.
Di permukaan, fungsionalitas Camel menyaingi produk Bus Layanan Perusahaan tradisional. Kami biasanya menganggap Camel Route sebagai komponen "mediasi" (alias orkestrasi) yang hidup di sisi server, tetapi karena itu adalah pustaka Java yang mudah disematkan dan dapat hidup di aplikasi sisi klien juga dan membantu Anda mengintegrasikan dengan layanan point to point (alias koreografi). Anda bahkan dapat mengambil POJO Anda yang memproses pesan-pesan di dalam rute Camel dan dengan mudah mengubahnya menjadi proses konsumen jarak jauh mereka sendiri, misalnya jika Anda perlu mengukur hanya satu bagian secara mandiri. Anda dapat menggunakan Unta untuk menghubungkan rute atau prosesor melalui sejumlah transportasi / protokol jarak jauh yang berbeda tergantung pada kebutuhan Anda. Apakah Anda memerlukan protokol biner yang sangat efisien dan cepat, atau yang lebih mudah dibaca manusia dan mudah di-debug? Bagaimana jika Anda ingin beralih? Dengan Camel ini biasanya semudah mengubah satu atau dua baris dalam rute Anda dan tidak mengubah logika bisnis sama sekali. Atau Anda bisa mendukung keduanya - Anda bebas menjalankan banyak Rute sekaligus dalam Konteks Unta.
Anda tidak benar-benar perlu menggunakan Unta untuk aplikasi sederhana yang akan hidup dalam satu proses atau JVM - itu akan berlebihan. Tetapi secara konsep tidak lebih sulit daripada kode yang Anda tulis sendiri. Dan jika persyaratan Anda berubah, pemisahan logika bisnis dan kode lem membuatnya lebih mudah dipertahankan dari waktu ke waktu. Setelah Anda mempelajari API Unta, mudah digunakan seperti pisau Swiss-Army dan menerapkannya dengan cepat dalam berbagai konteks untuk mengurangi jumlah kode khusus yang harus Anda tulis. Anda dapat mempelajari satu rasa - Java DSL, misalnya, API yang lancar yang mudah disatukan - dan mengambil rasa lainnya dengan mudah.
Secara keseluruhan Camel sangat cocok jika Anda mencoba melakukan layanan microser. Saya telah menemukan itu sangat berharga untuk arsitektur evolusioner, karena Anda dapat menunda banyak keputusan sulit, "mudah-untuk-mendapatkan-salah" tentang protokol, transportasi dan masalah integrasi sistem lainnya sampai Anda tahu lebih banyak tentang domain masalah Anda. Fokus saja pada EIP dan logika bisnis inti Anda dan beralihlah ke Rute baru dengan komponen "benar" saat Anda mempelajari lebih lanjut.
Ya, ini mungkin agak terlambat. Tetapi satu hal untuk ditambahkan ke komentar orang lain adalah bahwa, Camel sebenarnya adalah kotak peralatan daripada serangkaian fitur lengkap. Anda harus mengingat hal ini ketika mengembangkan dan perlu melakukan berbagai transformasi dan konversi protokol.
Camel sendiri bergantung pada kerangka kerja lain dan karena itu kadang-kadang Anda perlu memahami itu juga untuk memahami mana yang paling cocok untuk kebutuhan Anda. Misalnya ada beberapa cara untuk menangani REST. Ini bisa sedikit membingungkan pada awalnya, tetapi setelah Anda mulai menggunakan dan menguji Anda akan merasa nyaman dan pengetahuan Anda tentang konsep yang berbeda akan meningkat.
Apache Camel adalah kerangka kerja Java untuk integrasi Perusahaan. Misalnya: - jika Anda membuat aplikasi web yang berinteraksi dengan banyak vendor API, kami dapat menggunakan unta sebagai alat integrasi eksternal. Kita bisa berbuat lebih banyak dengan itu berdasarkan use case. Unta dalam Tindakan dari publikasi Manning adalah buku yang bagus untuk mempelajari Unta. Integrasi dapat didefinisikan sebagai berikut.
Java DSL
from("jetty://0.0.0.0:8080/searchProduct").routeId("searchProduct.products").threads()
.log(LoggingLevel.INFO, "searchProducts request Received with body: ${body}")
.bean(Processor.class, "createSearchProductsRequest").removeHeaders("CamelHttp*")
.setHeader(Exchange.HTTP_METHOD, constant(org.apache.camel.component.http4.HttpMethods.POST))
.to("http4://" + preLiveBaseAPI + searchProductsUrl + "?apiKey=" + ApiKey
+ "&bridgeEndpoint=true")
.bean(Processor.class, "buildResponse").log(LoggingLevel.INFO, "Search products finished");Ini hanya untuk membuat titik akhir REST API yang pada gilirannya memanggil API eksternal dan mengirimkan permintaan kembali
Pegas DSL
<route id="GROUPS-SHOW">
<from uri="jetty://0.0.0.0:8080/showGroups" />
<log loggingLevel="INFO" message="Reqeust receviced service to fetch groups -> ${body}" />
<to uri="direct:auditLog" />
<process ref="TestProcessor" />
</route>Datang ke pertanyaan Anda
Semoga ini bisa membantu
Apache Camel adalah kerangka kerja integrasi ringan yang mengimplementasikan semua pola Integrasi Perusahaan. Anda dapat dengan mudah mengintegrasikan berbagai aplikasi menggunakan pola yang diperlukan. Anda dapat menggunakan Java, Spring XML, Scala atau Groovy.
Apache Camel berjalan di Java Virtual Machine (JVM). ... Fungsi inti dari Apache Camel adalah mesin peruteannya. Ini mengalokasikan pesan berdasarkan rute terkait. Rute berisi alur dan logika integrasi. Ini diimplementasikan menggunakan EIP dan DSL tertentu.
Ini seperti pipa penghubung
From---->ToDi antara Anda dapat menambahkan sebanyak mungkin saluran dan pipa. Keran dapat dari jenis apa pun otomatis atau manual untuk aliran data dan rute untuk menyalurkan aliran.
Ini mendukung dan memiliki implementasi untuk semua jenis dan jenis pemrosesan. Dan untuk pemrosesan yang sama banyak pendekatan karena memiliki banyak komponen dan masing-masing komponen juga dapat memberikan output yang diinginkan menggunakan metode yang berbeda di bawahnya.
Misalnya, transfer file dapat dilakukan di unta dengan jenis file yang dipindahkan atau disalin dan juga dari folder, server atau antrian.
-from-->To
- from-->process-->to
- from-->bean-->to
- from-->process-->bean-->to
-from-->marshal-->process-->unmarshal-->toDari / ke ---- folder, direct, seda, vm bisa apa saja
Sudut pandang lain (berdasarkan pada topik matematika yang lebih mendasar)
Platform komputasi yang paling umum adalah [ https://en.wikipedia.org/wiki/Turing_machine]
Ada masalah dengan mesin Turing. Semua data input / output tetap berada di dalam mesin turing. Di dunia nyata ada sumber input dan output sink eksternal untuk mesin Turing kami, dan secara umum diatur oleh sistem di luar kendali kami. Artinya, sistem eksternal itu akan mengirim / menerima data sesuka hati dalam format apa pun dengan penjadwal data apa pun yang diinginkan.
Pertanyaan: Bagaimana kita mengatur agar mesin turing independen saling berbicara dengan cara yang paling umum sehingga setiap mesin turing melihat rekan-rekan mereka sebagai sumber data input atau data output?
Jawaban: Menggunakan sesuatu seperti unta, bagal, BizTalk atau ESB lain yang mengabstraksi penanganan data antara menyelesaikan mesin turing "fisik" (atau perangkat lunak virtual) yang berbeda.