ฉันไม่เข้าใจสิ่งที่อูฐทำ

หากคุณสามารถให้คำแนะนำแก่อูฐได้ 101 คำ:

• มันคืออะไรกันแน่?
• มันทำงานอย่างไรกับแอปพลิเคชันที่เขียนด้วย Java?
• มันเป็นสิ่งที่ไปพร้อมกับเซิร์ฟเวอร์หรือไม่
• มันเป็นโปรแกรมอิสระหรือไม่?

โปรดอธิบายว่าอูฐคืออะไร

หากคุณมีเวลา 5 ถึง 10 นาทีโดยทั่วไปฉันแนะนำให้คนอ่านการรวมกับ Apache Camelโดย Jonathan Anstey มันเป็นงานที่เขียนได้ดีซึ่งให้คำแนะนำสั้น ๆ และภาพรวมเกี่ยวกับแนวคิดของ Camel บางอย่างและใช้กรณีตัวอย่างพร้อมโค้ดตัวอย่าง ในนั้นโจนาธานเขียน:

Apache Camel เป็นเฟรมเวิร์ก Java แบบโอเพ่นซอร์สที่มุ่งเน้นในการทำให้การรวมง่ายขึ้นและเข้าถึงได้ง่ายขึ้นสำหรับนักพัฒนา มันทำได้โดยการให้:

• การใช้งานที่เป็นรูปธรรมของทั้งหมดที่ใช้กันอย่างแพร่หลายในองค์กรบูรณาการรูปแบบ (EIPs)
• การเชื่อมต่อกับการขนส่งและ API ที่หลากหลาย
• ง่ายต่อการใช้ Domain Specific Languages ​​(DSLs) เพื่อเชื่อมโยง EIP และการขนส่งเข้าด้วยกัน

นอกจากนี้ยังมีบทฟรีของCamel in Actionที่แนะนำ Camel ในบทแรก โจนาธานเป็นผู้ร่วมเขียนหนังสือเล่มนี้กับฉัน

ฉันใช้เพื่ออธิบายสิ่งนี้ในวิธีที่เข้าถึงได้ง่ายขึ้น ...

เพื่อที่จะเข้าใจว่า Apache Camel คืออะไรคุณต้องเข้าใจว่า Enterprise Integration Patterns คืออะไร

มาเริ่มกันที่สิ่งที่เรารู้กันดีอยู่แล้ว: รูปแบบของซิงเกิล, รูปแบบของโรงงาน, ฯลฯ ; พวกเขาเป็นเพียงวิธีในการจัดการกับปัญหาของคุณ แต่พวกเขาไม่ได้แก้ปัญหาด้วยตนเอง รูปแบบเหล่านี้ถูกนำมาวิเคราะห์และสกัดสำหรับส่วนที่เหลือของเราโดยแก๊งสี่เมื่อพวกเขาตีพิมพ์หนังสือของพวกเขา: รูปแบบการออกแบบ พวกเขาช่วยเราบางคนพยายามอย่างมากในการคิดว่าจะจัดโครงสร้างรหัสของเราอย่างไร

เหมือนกับ Greg of Four, Gregor Hohpe และ Bobby Woolf เขียนหนังสือEnterprise Integration Patterns (EIP) ที่พวกเขาเสนอและจัดทำเอกสารชุดรูปแบบใหม่และพิมพ์เขียวสำหรับวิธีที่เราสามารถออกแบบระบบส่วนประกอบขนาดใหญ่ได้ดีที่สุดทำงานในกระบวนการเดียวกันหรือในเครื่องอื่น

โดยพื้นฐานแล้วพวกเขาเสนอว่าเราจัดโครงสร้างระบบของเราให้เน้นข้อความ - ซึ่งส่วนประกอบต่างๆสื่อสารกันโดยใช้ข้อความเป็นอินพุตและเอาต์พุตและไม่มีอะไรอื่นอีกแล้ว พวกเขาแสดงให้เราเห็นชุดรูปแบบที่สมบูรณ์ที่เราอาจเลือกและนำไปใช้ในส่วนประกอบต่าง ๆ ของเราที่จะรวมกันเป็นทั้งระบบ

Apache Camel คืออะไร

Apache Camel ให้คุณอินเทอร์เฟซสำหรับ EIPs วัตถุพื้นฐานการใช้งานทั่วไปที่จำเป็นเครื่องมือในการดีบักระบบการกำหนดค่าและผู้ช่วยอื่น ๆ ซึ่งจะช่วยให้คุณประหยัดเวลาได้มากเมื่อคุณต้องการใช้โซลูชันของคุณเพื่อติดตาม EIP

ใช้ MVC MVC นั้นค่อนข้างง่ายในทางทฤษฎีและเราสามารถนำไปใช้ได้โดยไม่ต้องมีการช่วยเหลือใด ๆ แต่เฟรมเวิร์ก MVC ที่ดีนั้นทำให้เรามีโครงสร้างที่พร้อมใช้งานและได้ผ่านไปแล้วและคิดสิ่งอื่น ๆ ทั้งหมดที่คุณต้องการเมื่อคุณสร้างโครงการ MVC ขนาดใหญ่และนั่นคือเหตุผลที่เราใช้มันเป็นส่วนใหญ่

นั่นคือสิ่งที่ Apache Camel ใช้สำหรับ EIP เป็นกรอบการผลิตที่สมบูรณ์สำหรับผู้ที่ต้องการใช้โซลูชันของพวกเขาเพื่อติดตาม EIP

การสร้างคำอธิบายโครงการไม่ควรซับซ้อน

ฉันพูด:

Apache Camel เป็นกาวเทคโนโลยีการส่งข้อความด้วยการกำหนดเส้นทาง มันรวมจุดเริ่มต้นและจุดสิ้นสุดการส่งข้อความร่วมกันช่วยให้การส่งข้อความจากแหล่งที่แตกต่างกันไปยังปลายทางที่แตกต่างกัน ตัวอย่างเช่น: JMS -> JSON, HTTP -> JMS หรือช่องทาง FTP -> JMS, HTTP -> JMS, JSON -> JMS

Wikipedia พูดว่า:

Apache Camel เป็นเครื่องมือกำหนดเส้นทางและการไกล่เกลี่ยตามกฎซึ่งให้การใช้งาน Java ตามรูปแบบการรวมองค์กรโดยใช้ API (หรือภาษาเฉพาะโดเมน Java ประกาศ) เพื่อกำหนดค่ากฎการกำหนดเส้นทางและการไกล่เกลี่ย ภาษาเฉพาะโดเมนหมายความว่า Apache Camel สามารถรองรับกฎการกำหนดเส้นทางใน IDE ของคุณอย่างชาญฉลาดโดยใช้รหัส Java ปกติโดยไม่มีไฟล์การกำหนดค่า XML จำนวนมาก แม้ว่าสนับสนุนการกำหนดค่า XML ใน Spring ด้วย

ดู? มันไม่ยากใช่ไหม?

ในระยะสั้น:

เมื่อมีข้อกำหนดในการเชื่อมต่อ / รวมระบบคุณอาจจำเป็นต้องเชื่อมต่อกับแหล่งข้อมูลบางส่วนแล้วประมวลผลข้อมูลนี้เพื่อให้ตรงกับความต้องการทางธุรกิจของคุณ

ในการทำเช่นนั้น:

1) คุณสามารถพัฒนาโปรแกรมแบบกำหนดเองที่จะทำ (อาจใช้เวลานานและยากต่อการทำความเข้าใจดูแลสำหรับผู้พัฒนารายอื่น)

2) อีกทางหนึ่งคุณสามารถใช้ Apache Camel เพื่อทำมันในแบบมาตรฐาน (มีตัวเชื่อมต่อส่วนใหญ่ที่พัฒนาแล้วสำหรับคุณคุณเพียงแค่ต้องตั้งค่าและเสียบลอจิกของคุณ - เรียกกระบวนการ):

อูฐจะช่วยคุณในการ:

1. ใช้ข้อมูลจากแหล่ง / รูปแบบใด ๆ
2. ประมวลผลข้อมูลนี้
3. ส่งออกข้อมูลไปยังแหล่ง / รูปแบบใด ๆ

ด้วยการใช้ Apache Camel คุณจะสามารถทำความเข้าใจ / ดูแลรักษา / ขยายระบบของคุณไปยังผู้พัฒนารายอื่นได้ง่าย

Apache Camel ได้รับการพัฒนาด้วย Enterprise Integration Patterns รูปแบบช่วยให้คุณรวมระบบในทางที่ดี :-)

Camel ส่งข้อความจาก A ถึง B:

ทำไมกรอบทั้งหมดสำหรับสิ่งนี้ ถ้าคุณมี:

• ผู้ส่งจำนวนมากและผู้รับจำนวนมาก
• โหลของโปรโตคอล ( ftp, http, jmsฯลฯ )
• กฎที่ซับซ้อนมากมาย
  • ส่งข้อความ A ถึงผู้รับ A และ B เท่านั้น
  • ส่งข้อความ B เพื่อรับสัญญาณ C เป็น XMLแต่ส่วนหนึ่งแปลมันประเทืองมัน (เมตาดาต้าเพิ่ม) และถ้าเงื่อนไข Xแล้วส่งไปยังผู้รับ D เกินไป แต่เป็น CSV

ดังนั้นตอนนี้คุณต้องการ:

• แปลระหว่างโปรโตคอล
• ส่วนประกอบกาวเข้าด้วยกัน
• กำหนดเส้นทาง - อะไรจะไปที่ไหน
• กรองบางสิ่งในบางกรณี

อูฐให้คุณได้มากกว่าและมากกว่า:

ด้วยภาษา DSL ที่ยอดเยี่ยมสำหรับคุณในการกำหนดสิ่งที่และวิธีการ:

  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");
}

ดูสิ่งนี้และสิ่งนี้และ Camel in Action (อย่างที่คนอื่นพูดว่าเป็นหนังสือที่ยอดเยี่ยม!)

ไดอะแกรมดีกว่าคำอธิบายหลายพันคำ แผนภาพนี้แสดงให้เห็นถึงสถาปัตยกรรมของอูฐ

ขึ้นอยู่กับอะนาล็อก

การกำหนดเส้นทางตามอูฐสามารถเข้าใจได้ง่ายมากโดยใส่ตัวคุณเองในรองเท้าของเจ้าของสายการบิน (เช่น: American Airlines, Jet Airways)

วัตถุประสงค์ของ 'สายการบินของคุณ' คือ 'พก' 'ผู้โดยสาร' จาก 'เมือง' หนึ่งไปยังอีกที่หนึ่งในโลก คุณใช้เครื่องบินจาก 'บริษัท อากาศยาน' ที่แตกต่างกันเช่นโบอิ้งแอร์บัส HAL เพื่อบรรทุกผู้โดยสาร

สายการบินของคุณจัดการผู้โดยสารโดยใช้ 'สนามบิน' จากเมืองและยกเลิกการผู้โดยสารโดยใช้สนามบินของเมือง ผู้โดยสารอาจ 'เดินทาง' ไปยังหลายเมือง แต่ทุกที่ที่พวกเขาต้องผ่านสนามบินเพื่อเดินทางระหว่างเครื่องบินของสายการบินและเมือง

โปรดทราบว่าผู้โดยสารที่ 'ออกเดินทาง' จากเมืองนั้นโดยหลักแล้วจะมาถึง 'ลงในเครื่องบิน' ของสายการบินของคุณ และผู้เดินทางที่เดินทางมาถึงในเมืองก็กำลังออกเดินทางจากเครื่องบิน เนื่องจากเราอยู่ในรองเท้าของเจ้าของสายการบินคำว่า 'ผู้โดยสารขาเข้า' และ 'ผู้โดยสารขาออก' จึงกลับด้านจากแนวคิดทั่วไปของเราซึ่งขึ้นอยู่กับมุมมองของเมือง

โครงสร้างพื้นฐานเดียวกัน 'สนามบิน' ของแต่ละเมืองนั้นใช้สำหรับผู้โดยสารขาออกและผู้โดยสารขาเข้า สนามบินให้ 'โครงสร้างพื้นฐานการแยกออก' สำหรับผู้โดยสารขาออกซึ่งแตกต่างจาก 'โครงสร้างพื้นฐานขาเข้า' ที่มีให้สำหรับผู้โดยสารขาเข้า

ผู้โดยสารสามารถทำกิจกรรมของพวกเขาต่อเนื่องได้เนื่องจากสายการบินของคุณให้บริการในขณะที่เดินทาง

ยิ่งไปกว่านั้นสายการบินของคุณยังมีสิ่งอำนวยความสะดวกเลานจ์สำหรับการบำบัดพิเศษเช่น 'ทำความเข้าใจภาษาท้องถิ่น' และหรือเตรียมความพร้อมสำหรับ 'การเดินทาง'

ให้แทนที่คำ / วลีที่ใช้ด้านบนด้วย:

สายการบินของคุณ: Apache Camel

บริษัท อากาศยาน: กลไกการขนส่ง

เครื่องบินของสายการบินของคุณ: กลไกการขนส่งพื้นฐานของ Apache Camel

พกพา: เส้นทาง

ผู้โดยสาร: ข้อความ;

เมือง: ระบบ;

สนามบิน: องค์ประกอบอูฐ;

การทำความเข้าใจภาษาท้องถิ่น: การแปลงประเภท;

ออกเดินทาง: การผลิตการผลิต

มาถึง: บริโภคบริโภค

travel: เส้นทาง

สิ่งอำนวยความสะดวก:

หลังจากแทนที่คำศัพท์นี่คือสิ่งที่คุณจะได้รับ:

วัตถุประสงค์ของ 'Apache Camel'คือเพื่อกำหนดเส้นทาง 'ข้อความ' จากระบบ 'หนึ่ง' ไปยังอีกระบบหนึ่งในโลก Apache อูฐใช้กลไกการขนส่งที่แตกต่างกันสำหรับการกำหนดเส้นทางข้อความ

Apache Camel เลือกข้อความโดยใช้ 'Camel based Component' ของระบบ 'from' และปล่อยมันโดยใช้ 'Camel based Component' ของระบบ 'to' ข้อความอาจส่งไปยังหลาย ๆ ระบบ แต่ทุกที่พวกเขาต้องผ่าน 'ส่วนประกอบพื้นฐานของอูฐ' เพื่อเดินทางระหว่าง 'กลไกการขนส่งพื้นฐานของ Apache Camel' และระบบ

โปรดทราบว่าข้อความ 'ที่สร้างขึ้น' จากระบบนั้นเป็น 'การบริโภค' เป็นหลักในกลไกการขนส่งพื้นฐานของ Apache Camel ' และข้อความที่ถูกใช้โดยระบบผลิตขึ้นโดยกลไกการขนส่งพื้นฐานของ Apache Camel

เนื่องจากเราพยายามทำความเข้าใจกับอูฐเราต้องคิดจากมุมมองของอูฐที่นี่เป็นต้นไป ดังนั้นความหมายของคำว่า 'ข้อความของผู้บริโภค' และ 'ข้อความจากผู้ผลิต' จึงเปลี่ยนจากแนวคิดทั่วไปของเราซึ่งอยู่บนพื้นฐานของมุมมองของระบบ

โครงสร้างพื้นฐานการเข้ารหัส 'Camel based Component' เดียวกันใช้โดย 'ข้อความผู้ผลิต' และ 'ข้อความผู้บริโภค' 'องค์ประกอบตามอูฐ' ให้ 'ปลายทางผู้ผลิต' สำหรับ 'ข้อความผู้ผลิต' และ 'จุดสิ้นสุดของผู้บริโภค' สำหรับ 'ข้อความผู้บริโภค'

Camel สามารถประมวลผลข้อความได้เมื่อมีการกำหนดเส้นทาง

ด้านบนของเส้นทางนี้อูฐมีคุณสมบัติพิเศษเช่น 'การแปลงแบบ' และอีกมากมาย ...

หนึ่งในสิ่งที่คุณต้องเข้าใจก่อนที่คุณจะเข้าใจ Apache Camel คือรูปแบบการรวมองค์กร ไม่ใช่ทุกคนที่อยู่ในสนามจริง ๆ แล้วรู้ถึงพวกเขา ในขณะที่คุณแน่นอนสามารถอ่านหนังสือรูปแบบบูรณาการขององค์กรเป็นวิธีที่รวดเร็วในการได้รับขึ้นอยู่กับความเร็วที่พวกเขาจะอ่านสิ่งที่ชอบบทความวิกิพีเดียในองค์กรรวมโปรแกรม

เมื่อคุณอ่านและทำความเข้าใจกับหัวข้อแล้วคุณจะมีแนวโน้มที่จะเข้าใจวัตถุประสงค์ของ Apache Camel มากขึ้น

HTH

หากคุณทราบเกี่ยวกับรูปแบบการรวมองค์กร Apache Camel เป็นกรอบการรวมหนึ่งที่ใช้ EIP ทั้งหมด

และคุณสามารถปรับใช้ Camel เป็นแอปพลิเคชันแบบสแตนด์อโลนในเว็บคอนเทนเนอร์

โดยทั่วไปหากคุณต้องรวมแอพพลิเคชั่นหลายตัวเข้ากับโปรโตคอลและเทคโนโลยีที่แตกต่างกันคุณสามารถใช้ Camel ได้

คำนิยามจากมุมมองอื่น:

Apache Camel เป็นกรอบการรวม ประกอบด้วยไลบรารี Java บางส่วนซึ่งช่วยให้คุณสามารถใช้ปัญหาการรวมบนแพลตฟอร์ม Java สิ่งนี้มีความหมายอย่างไรและแตกต่างจาก API ในด้านใดด้านหนึ่งและ Enterprise Service Bus (ESB) ในอีกด้านหนึ่งอธิบายไว้ในบทความของฉัน " เมื่อใดควรใช้ Apache Camel "

มันคืออะไรกันแน่?

Apache Camelเป็นเฟรมเวิร์กการรวมที่มีน้ำหนักเบาซึ่งใช้รูปแบบ Enterprise Integration ทั้งหมดคุณสามารถรวมแอ็พพลิเคชันต่าง ๆ ได้อย่างง่ายดายโดยใช้รูปแบบที่ต้องการ

คุณสามารถใช้ Java, Spring XML, Scala หรือ Groovy เกือบทุกเทคโนโลยีที่คุณนึกออกมีให้เช่น HTTP, FTP, JMS, EJB, JPA, RMI, JMS, JMX, LDAP, Netty เป็นต้น

ดูที่บทความนี้และบทความรูปแบบ EIP

มันทำงานอย่างไรกับแอปพลิเคชันที่เขียนด้วย Java?

Camel ใช้ภาษาเฉพาะโดเมน Java หรือ DSLสำหรับสร้างรูปแบบการรวมองค์กรหรือเส้นทางในภาษาเฉพาะโดเมน (DSL) ที่หลากหลายดังแสดงด้านล่าง

Java DSL - DSLจาก Java ใช้รูปแบบการสร้างที่คล่องแคล่ว

เรื่องราวของรูปแบบการผนวกรวมขององค์กรจะช่วยแก้ไขแนวคิดเหล่านี้:

ข้อความ End Point, ผู้ผลิต, ผู้บริโภค, การกำหนดเส้นทาง, รถประจำทาง, Transform และกระบวนการ

ดูบทความนี้โดย Anirban Konar สำหรับกรณีการใช้งานแบบเรียลไทม์

มันเป็นสิ่งที่ไปพร้อมกับเซิร์ฟเวอร์หรือไม่

มันทำหน้าที่เป็นสะพานข้ามระบบย่อยหลายองค์กร

มันเป็นโปรแกรมอิสระหรือไม่?

Apache Camel เป็นเฟรมเวิร์กการรวมเข้าด้วยกันรวมแอปพลิเคชันอิสระ

ข้อได้เปรียบที่สำคัญของ Camel : คุณสามารถรวมแอปพลิเคชันที่แตกต่างกับเทคโนโลยีที่แตกต่างกัน (และโปรโตคอลที่แตกต่างกัน) โดยใช้แนวคิดเดียวกันที่เหมือนกันสำหรับทุกการรวม

สิ่งที่ "ใหม่" ในการคำนวณส่วนใหญ่ไม่ได้ใหม่เลยมันเป็นเพียงเสื้อคลุมลึกลับรอบสิ่งที่เข้าใจอยู่แล้ว เมื่อพวกเขากำลังยากที่จะเข้าใจก็มักจะเป็นเพราะคนที่ตัดสินใจที่จะคิดค้นแง่ภาษาใหม่หรือตั้งรกรากเงื่อนไขที่มีอยู่เพื่อวัตถุประสงค์ที่แตกต่างกัน (ตัวอย่างที่ดีของที่เป็นความผกผันพัฒนา X ของสิ่งที่ 'ลูกค้า' และ 'เซิร์ฟเวอร์' หมายถึง.)

Camel เป็น wrapper / API บน Java สำหรับมิดเดิลแวร์ระหว่างแอ็พพลิเคชัน

Middleware เป็นคำทั่วไปสำหรับซอฟต์แวร์ที่ให้บริการตีความระหว่างเอนทิตีที่ไม่แชร์ภาษาหรือชนิดข้อมูลทั่วไป

นั่นคือสิ่งที่อูฐอยู่ด้านล่าง เราสามารถแยกคำอธิบายออกได้โดยสังเกตว่ามันมีไว้สำหรับมิดเดิลแวร์ประเภท EIP

มันไม่ได้ให้มิดเดิลแวร์ของตัวเองเพราะมันไม่สามารถรู้รายละเอียดของสิ่งที่แอพพลิเคชั่นต้องการในการสื่อสาร แต่ให้ API สำหรับการสร้างชิ้นส่วนที่ไม่เปลี่ยนแปลงของมิดเดิลแวร์นั้น (สร้างจุดเริ่มต้นสร้างจุดสิ้นสุดสร้างเงื่อนไขสำหรับการเริ่มต้นและสิ้นสุด ฯลฯ )

หวังว่าจะช่วย

นี่คือความพยายามอีกครั้ง

คุณรู้ว่ามี / สิ่งต่างๆเช่น Webmethods, ICAN Seebeyond, Tibco BW, IBM Broker อย่างไร พวกเขาทุกคนช่วยแก้ไขปัญหาการรวมระบบในองค์กร เครื่องมือเหล่านี้เป็นที่รู้จักกันทั่วไปในชื่อเครื่องมือ Enterprise Application Integration (EAI)

มีเครื่องมือลากวางส่วนใหญ่สร้างขึ้นรอบ ๆ เทคโนโลยีเหล่านี้และในบางส่วนคุณจะต้องเขียนอะแดปเตอร์ใน Java รหัสอะแดปเตอร์เหล่านี้ไม่ได้ทดสอบหรือมีเครื่องมือ / ระบบอัตโนมัติรอบการทดสอบไม่ดี

เช่นเดียวกับรูปแบบการออกแบบในการเขียนโปรแกรมคุณมีรูปแบบ Enterprise Integration สำหรับโซลูชันการรวมทั่วไป พวกเขาสร้างชื่อเสียงจากหนังสือชื่อเดียวกันโดย Gregor Hohpe และ Bobby Woolf

แม้ว่าจะเป็นไปได้ค่อนข้างที่จะใช้โซลูชันการรวมที่ใช้ EIP หนึ่งหรือหลายตัว Camel เป็นความพยายามในการทำเช่นนี้ภายในรหัสฐานของคุณโดยใช้หนึ่งใน XML, Java, Groovy หรือ Scala

Camel สนับสนุนรูปแบบการรวมระบบขององค์กรทั้งหมดที่มีอยู่ในหนังสือผ่านทาง DSL ที่มีประสิทธิภาพและกลไกการกำหนดเส้นทาง

ดังนั้น Camel จึงเป็น technoloy ที่แข่งขันกับเครื่องมือ EAI อื่น ๆ ที่สนับสนุนการทดสอบโค้ดการรวมระบบของคุณได้ดีขึ้น รหัสสั้นกระชับเนื่องจาก Domain Specific Languages ​​(DSLs) มันสามารถอ่านได้โดยผู้ใช้ทางธุรกิจและเป็นอิสระและทำให้คุณมีประสิทธิผล

มีกรอบหลายอย่างที่อำนวยความสะดวกให้เราในการส่งข้อความและแก้ไขปัญหาในการส่งข้อความ หนึ่งในผลิตภัณฑ์ดังกล่าวคือ Apache Camel

ปัญหาที่พบบ่อยที่สุดได้พิสูจน์วิธีแก้ปัญหาที่เรียกว่าเป็นรูปแบบการออกแบบ รูปแบบการออกแบบสำหรับการส่งข้อความคือรูปแบบ Enterprise Integration (EIPs) ซึ่งอธิบายได้ดีที่นี่ที่นี่Apache อูฐช่วยเราในการปรับใช้โซลูชันของเราโดยใช้ EIP

จุดแข็งของกรอบการบูรณาการคือความสามารถในการอำนวยความสะดวกให้เราผ่าน EIP หรือรูปแบบอื่น ๆ จำนวนการขนส่งและส่วนประกอบและความสะดวกในการพัฒนาที่ Apache อูฐยืนอยู่ด้านบนของรายการ

แต่ละเฟรมเวิร์กมีข้อดีของมันเองคุณสมบัติพิเศษบางอย่างของอูฐ Apache มีดังต่อไปนี้

1. มันให้การเข้ารหัสที่จะอยู่ใน DSLs จำนวนมากเช่น Java DSL และ DSL DSL ตาม Spring ซึ่งเป็นที่นิยม
2. ใช้งานง่ายและใช้งานง่าย
3. Fuse IDE เป็นผลิตภัณฑ์ที่ช่วยให้คุณสามารถรหัสผ่าน UI

ในภาษาอังกฤษแบบธรรมดาอูฐสามารถทำสิ่งต่างๆได้โดยไม่ต้องใช้รหัสจานหม้อไอน้ำมากนัก

เพียงให้มุมมองแก่คุณ Java DSL ที่ให้ไว้ด้านล่างจะสร้างจุดปลายทาง REST ซึ่งจะสามารถยอมรับ XML ซึ่งประกอบด้วยรายการผลิตภัณฑ์และแยกออกเป็นหลายผลิตภัณฑ์และเรียกใช้กระบวนการ Process ของ BrandProcessor ด้วย และเพียงแค่เพิ่ม. ParallelProcessing (หมายเหตุส่วนที่ใส่ความเห็น) มันจะประมวลผลแบบขนานวัตถุผลิตภัณฑ์ทั้งหมด (คลาสผลิตภัณฑ์คือ JAXB / XJC สร้าง stub Java จาก XSD ซึ่งอินพุต xml ถูก จำกัด ) รหัสที่มาก (พร้อมกับการพึ่งพา Camel น้อย) จะทำงานให้เสร็จซึ่งใช้เวลา 100 บรรทัดของโค้ด Java

from("servlet:item-delta?matchOnUriPrefix=true&httpMethodRestrict=POST")
.split(stax(Product.class))
/*.parallelProcessing()*/
.process(itemDeltaProcessor);

หลังจากเพิ่ม ID เส้นทางและคำสั่งการบันทึก

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);

นี่เป็นเพียงตัวอย่างอูฐเป็นมากกว่าแค่จุดสิ้นสุด REST เพียงดูรายการส่วนประกอบที่เสียบปลั๊กได้http://camel.apache.org/components.html

อูฐช่วยในการกำหนดเส้นทางการแปลงการตรวจสอบ

มันใช้เส้นทาง ซึ่งสามารถอธิบายได้เป็น:

เมื่อบัสบริการได้รับข้อความเฉพาะมันจะส่งผ่านข้อความไปยังปลายทางของบริการ / นายหน้าเช่นคิว / หัวข้อ เส้นทางนี้เรียกว่าเส้นทาง

ตัวอย่าง: แอปพลิเคชันหุ้นของคุณได้รับการป้อนข้อมูลโดยนักวิเคราะห์มันจะถูกประมวลผลผ่านแอปพลิเคชัน / ส่วนประกอบของเว็บและจากนั้นผลลัพธ์จะถูกเผยแพร่ไปยังสมาชิกที่สนใจ / ลงทะเบียนทั้งหมดสำหรับการอัปเดตเฉพาะหุ้น

สมมติว่าคุณสร้าง บริษัท อีคอมเมิร์ซเช่น Amazon และคุณต้องการเน้นเฉพาะกลยุทธ์ / ตัวเลือกผลิตภัณฑ์ที่จะขาย แตกต่างจากกองเรือส่งมอบของ amazon แทนที่จะเป็นตัวคุณเองที่จัดการการเคลื่อนย้ายสินค้าจากผู้ขายไปยังคลังสินค้าทำการเปลี่ยนแปลงในคลังสินค้าเช่นบรรจุภัณฑ์และส่งออกไปยังเมืองอื่นและลูกค้า คุณจ้าง บริษัท ที่ทำสิ่งนี้ทั้งหมดและเพียงให้ข้อมูลเกี่ยวกับที่ตั้งคลังสินค้าประเภทยานพาหนะสถานที่จัดส่งและรายการสิ่งที่ต้องทำ จากนั้นพวกเขาจัดการเรื่องนั้นด้วยตัวเองนั่นก็คือ Apache Camel พวกเขาดูแลการเคลื่อนย้ายสิ่งต่าง ๆ จากปลายด้านหนึ่งไปอีกด้านหนึ่งเมื่อคุณส่งมอบสิ่งต่าง ๆ ให้กับพวกเขาเพื่อที่คุณจะได้มีอิสระในการจดจ่อกับสิ่งอื่น ๆ

101 คำแนะนำ

Camel เป็นเฟรมเวิร์กที่มี API และโมเดลการเขียนโปรแกรมที่สอดคล้องกันสำหรับการรวมแอพพลิเคชั่นเข้าด้วยกัน API จะยึดตามทฤษฎีในรูปแบบการรวมเข้าด้วยกันขององค์กร - กล่าวคือรูปแบบการออกแบบมากมายที่มักใช้การส่งข้อความ มันนำเสนอรูปแบบเหล่านี้โดยไม่ต้องใช้กล่องและยังมีส่วนประกอบต่างๆอีกกว่า 200 รายการที่คุณสามารถใช้เพื่อพูดคุยกับระบบอื่น ๆ ทุกประเภทได้อย่างง่ายดาย หากต้องการใช้ Camel อันดับแรกให้เขียนตรรกะทางธุรกิจของคุณใน POJO และใช้อินเทอร์เฟซพื้นฐานที่เน้นข้อความเป็นหลัก จากนั้นใช้ DSL ของ Camel เพื่อสร้าง "Routes" ซึ่งเป็นชุดของกฎสำหรับการติดแอปพลิเคชันของคุณเข้าด้วยกัน

แนะนำเพิ่มเติม

การทำงานของ Camel นั้นเหนือกว่าผลิตภัณฑ์ Enterprise Service Bus แบบดั้งเดิม โดยทั่วไปเราคิดว่า Camel Route เป็นองค์ประกอบ "การไกล่เกลี่ย" (aka orchestration) ที่อยู่บนฝั่งเซิร์ฟเวอร์ แต่เนื่องจากเป็นห้องสมุด Java จึงง่ายต่อการฝังและสามารถใช้งานบนแอปฝั่งไคลเอ็นต์ได้เช่นกันและช่วยให้คุณรวมเข้าด้วยกัน บริการแบบจุดต่อจุด (ท่าเต้นอาคา) คุณยังสามารถนำ POJO ของคุณไปประมวลผลข้อความภายในเส้นทาง Camel และแยกพวกเขาออกเป็นกระบวนการผู้บริโภคระยะไกลของตนเองได้อย่างง่ายดายเช่นหากคุณต้องการปรับขนาดชิ้นเดียวอย่างอิสระ คุณสามารถใช้ Camel เพื่อเชื่อมต่อเส้นทางหรือโปรเซสเซอร์ผ่านการขนส่ง / โปรโตคอลระยะไกลที่แตกต่างกันจำนวนเท่าใดก็ได้ขึ้นอยู่กับความต้องการของคุณ คุณต้องการโปรโตคอลไบนารีที่มีประสิทธิภาพและรวดเร็วมากหรือไม่ หรืออันที่มนุษย์สามารถอ่านได้และง่ายต่อการดีบัก? ถ้าคุณต้องการเปลี่ยน ด้วย Camel สิ่งนี้จะง่ายเหมือนการเปลี่ยนบรรทัดหรือสองบรรทัดในเส้นทางของคุณและไม่เปลี่ยนแปลงตรรกะทางธุรกิจใด ๆ เลย หรือคุณสามารถรองรับได้ทั้งสองอย่าง - คุณมีอิสระที่จะใช้งาน Routes หลาย ๆ ตัวพร้อมกันในบริบทของอูฐ

คุณไม่จำเป็นต้องใช้ Camel สำหรับแอปพลิเคชันแบบง่าย ๆ ที่กำลังจะมีชีวิตอยู่ในกระบวนการเดียวหรือ JVM - มันจะเกินความจำเป็น แต่มันก็ไม่ยากที่จะคิดอะไรมากไปกว่าโค้ดที่คุณเขียนด้วยตัวเอง และหากความต้องการของคุณเปลี่ยนไปการแยกตรรกะทางธุรกิจและรหัสกาวทำให้ง่ายต่อการบำรุงรักษาเมื่อเวลาผ่านไป เมื่อคุณเรียนรู้ Camel API แล้วมันใช้งานง่ายเหมือนมีด Swiss-Army และนำไปใช้อย่างรวดเร็วในหลาย ๆ บริบทเพื่อลดจำนวนรหัสที่คุณกำหนดเองที่คุณต้องเขียน คุณสามารถเรียนรู้หนึ่งรสชาติ - Java DSL ตัวอย่างเช่น API ได้อย่างคล่องแคล่วซึ่งง่ายต่อการรวมเข้าด้วยกัน - และรับรสชาติอื่น ๆ ได้อย่างง่ายดาย

Camel โดยรวมนั้นเหมาะสมอย่างยิ่งหากคุณกำลังพยายามทำ microservices ฉันพบว่ามันมีค่ามากสำหรับสถาปัตยกรรมเชิงวิวัฒนาการเนื่องจากคุณสามารถยกเลิกการตัดสินใจที่ "ง่ายและผิด" ที่ยากลำบากมากเกี่ยวกับโปรโตคอลการขนส่งและปัญหาการรวมระบบอื่น ๆ จนกว่าคุณจะรู้เพิ่มเติมเกี่ยวกับโดเมนปัญหาของคุณ เพียงแค่มุ่งเน้นไปที่ EIP และตรรกะทางธุรกิจหลักของคุณและเปลี่ยนไปใช้เส้นทางใหม่ด้วยส่วนประกอบ "ถูกต้อง" เมื่อคุณเรียนรู้เพิ่มเติม

ใช่มันอาจจะสายไปสักหน่อย แต่สิ่งหนึ่งที่จะเพิ่มให้กับความคิดเห็นของคนอื่นก็คือจริง ๆ แล้ว Camel เป็นกล่องเครื่องมือแทนที่จะเป็นฟีเจอร์ที่ครบถ้วน คุณควรคำนึงถึงเรื่องนี้เมื่อมีการพัฒนาและจำเป็นต้องทำการแปลงรูปแบบต่าง ๆ และการแปลงโปรโตคอล

อูฐเองอาศัยกรอบงานอื่น ๆ ดังนั้นบางครั้งคุณต้องเข้าใจสิ่งเหล่านั้นด้วยเพื่อที่จะเข้าใจว่าสิ่งใดเหมาะสมที่สุดสำหรับความต้องการของคุณ มีตัวอย่างหลายวิธีในการจัดการกับ REST สิ่งนี้อาจทำให้สับสนเล็กน้อยในตอนแรก แต่เมื่อคุณเริ่มใช้และทดสอบคุณจะรู้สึกสบายใจและความรู้เกี่ยวกับแนวคิดต่าง ๆ จะเพิ่มขึ้น

Apache Camel เป็นเฟรมเวิร์ก Java สำหรับการรวมองค์กร เช่น: - หากคุณกำลังสร้างเว็บแอปพลิเคชันซึ่งโต้ตอบกับ API ของผู้ขายจำนวนมากเราสามารถใช้อูฐเป็นเครื่องมือการรวมภายนอก เราสามารถทำอะไรได้มากขึ้นตามกรณีการใช้งาน Camel in Action จาก Manning สิ่งพิมพ์เป็นหนังสือที่ดีสำหรับการเรียนรู้ Camel การรวมระบบสามารถกำหนดได้ดังนี้

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");

นี่เป็นเพียงการสร้าง REST API endpoint ซึ่งจะเรียก API ภายนอกและส่งคำขอกลับ

Spring 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>

มาถึงคำถามของคุณ

1. มันคืออะไรกันแน่? ตอบ: - เป็นกรอบซึ่งใช้รูปแบบการรวมองค์กร
2. มันทำงานอย่างไรกับแอปพลิเคชันที่เขียนด้วย Java? คำตอบ: - มันสามารถโต้ตอบกับโปรโตคอลใด ๆ ที่มีเช่น http, ftp, amqp ฯลฯ
3. มันเป็นสิ่งที่ไปพร้อมกับเซิร์ฟเวอร์หรือไม่ คำตอบ: - มันสามารถใช้งานในภาชนะเช่น Tomcat หรือสามารถนำไปใช้อย่างอิสระเป็นกระบวนการ java
4. มันเป็นโปรแกรมอิสระหรือไม่? ตอบ: - สามารถ

หวังว่ามันจะช่วย

Apache Camel เป็นเฟรมเวิร์กการรวมที่มีน้ำหนักเบาซึ่งใช้รูปแบบ Enterprise Integration ทั้งหมด คุณสามารถรวมแอพพลิเคชั่นต่าง ๆ ได้อย่างง่ายดายโดยใช้รูปแบบที่ต้องการ คุณสามารถใช้ Java, Spring XML, Scala หรือ Groovy

Apache Camel รันบน Java Virtual Machine (JVM) ... ฟังก์ชั่นหลักของ Apache Camel คือเอ็นจิ้นการกำหนดเส้นทาง มันจัดสรรข้อความตามเส้นทางที่เกี่ยวข้อง เส้นทางประกอบด้วยตรรกะการไหลและการรวม มีการใช้งานโดยใช้ EIP และ DSL ที่เฉพาะเจาะจง

มันเหมือนท่อเชื่อมต่อ

From---->To

ในระหว่างคุณสามารถเพิ่มได้หลายช่องทางและไปป์ faucet นั้นสามารถเป็นแบบอัตโนมัติหรือแบบแมนนวลสำหรับการไหลของข้อมูลและเส้นทางในการไหลของ channelize

สนับสนุนและมีการนำไปใช้สำหรับการประมวลผลทุกประเภทและทุกประเภท และสำหรับการประมวลผลแบบเดียวกันหลายวิธีเพราะมันมีองค์ประกอบมากมายและแต่ละองค์ประกอบยังสามารถให้ผลลัพธ์ที่ต้องการโดยใช้วิธีการที่แตกต่างกัน

ตัวอย่างเช่นการถ่ายโอนไฟล์สามารถทำได้ในอูฐด้วยไฟล์ประเภทย้ายหรือคัดลอกและจากโฟลเดอร์เซิร์ฟเวอร์หรือคิว

-from-->To
   - from-->process-->to
   - from-->bean-->to
   - from-->process-->bean-->to
   -from-->marshal-->process-->unmarshal-->to

จาก / ถึง ---- โฟลเดอร์ direct, seda, vm สามารถเป็นอะไรก็ได้

มุมมองอื่น (ขึ้นอยู่กับหัวข้อทางคณิตศาสตร์พื้นฐานเพิ่มเติม)

แพลตฟอร์มคอมพิวเตอร์ทั่วไปส่วนใหญ่คือ [ https://en.wikipedia.org/wiki/Turing_machine]

มีปัญหากับเครื่องทัวริง ข้อมูลอินพุต / เอาต์พุตทั้งหมดอยู่ภายในเครื่องทัวริง ในโลกแห่งความเป็นจริงมีแหล่งอินพุตและเอาท์พุทซิงค์ภายนอกจากเครื่องทัวริงของเราและโดยทั่วไปควบคุมโดยระบบที่อยู่นอกเหนือการควบคุมของเรา นั่นคือระบบภายนอกเหล่านั้นจะส่ง / รับข้อมูลที่จะอยู่ในรูปแบบใด ๆ กับตัวจัดตารางข้อมูลที่ต้องการ

คำถาม: เราจะจัดการให้ทัวริงเครื่องจักรอิสระพูดคุยกันด้วยวิธีทั่วไปได้อย่างไรเพื่อให้ทัวริงเครื่องจักรแต่ละเครื่องมองเห็นเพื่อนของพวกเขาว่าเป็นแหล่งข้อมูลอินพุตหรือซิงค์ข้อมูลขาออก

คำตอบ: การใช้บางอย่างเช่นอูฐล่อ BizTalk หรือ ESB อื่นใดที่แยกการจัดการข้อมูลระหว่างการทำให้เครื่องจักรทัวริง "กายภาพ" (หรือซอฟต์แวร์เสมือน) แตกต่างกัน