JBoss Fuse - คู่มือฉบับย่อ

ในบทนี้เราจะเริ่มต้นด้วยข้อมูลสำคัญของ Enterprise Service Bus ด้านล่างนี้เป็นคำอธิบายโดยละเอียดเกี่ยวกับ ESB พร้อมทั้งข้อดีข้อเสียและแผนภาพสองสามข้อเพื่อให้เข้าใจง่ายขึ้น

ESB คืออะไร?

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

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

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

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

ปัญหาการผสานรวม

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

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

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

ทำไมต้อง ESB

ต่อไปนี้เป็นประเด็นบางส่วนที่อธิบายว่าเหตุใด Enterprise Service Bus จึงมีความสำคัญ

  • ESB มีจุดมุ่งหมายเพื่อลดความซับซ้อนของปัญหาในการผสานรวมกับแอปพลิเคชันที่เข้ากันได้กับตัวแปร

  • ทำหน้าที่เป็นตัวกลางซึ่งทำหน้าที่เป็นสื่อกลางของแอปพลิเคชันทั้งหมดของคุณและอำนวยความสะดวกในการกำหนดเส้นทางข้อความระหว่างพวกเขา

  • แทนที่จะทุกแอปพลิเคชันเชื่อมต่อกับแอปพลิเคชันอื่น ๆ โดยตรงตอนนี้แต่ละแอปพลิเคชันจะมีอินเทอร์เฟซเดียวกับ ESB

  • ESB มีหน้าที่แปลข้อความไปยัง / จากรูปแบบทั่วไปและกำหนดเส้นทางไปยังปลายทาง

  • การประหยัดที่สำคัญในแนวทางนี้เป็นประโยชน์หากคุณต้องเปลี่ยนแอปพลิเคชันที่มีอยู่ของคุณ แทนที่จะเขียนอินเทอร์เฟซใหม่ทั้งหมดตอนนี้คุณมีอินเทอร์เฟซเดียวที่ต้องกังวล (ระหว่างแอปพลิเคชันของคุณกับ ESB)

SOA & ESB?

SOA และ ESB มักใช้แทนกันได้ แต่ต่างกันอย่างสิ้นเชิง

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

JBoss Fuse เป็นโซลูชัน ESB แบบโอเพ่นซอร์สโดย Redhat เป็นโซลูชันระดับองค์กรตามโครงการชุมชน Apache Servicemix

บูรณาการกับฟิวส์

JBoss Fuse เป็นแพลตฟอร์มการรวมที่มีน้ำหนักเบาและยืดหยุ่นซึ่งช่วยให้สามารถรวมแอปพลิเคชันระดับองค์กรได้อย่างรวดเร็ว

Fuse ได้รับการพัฒนาครั้งแรกโดย Progressive software Inc. ซึ่ง Redhat ได้เข้าซื้อกิจการในปี 2555 JBoss Fuse 6.1.0.redhat-379 GA เป็น Fuse เวอร์ชันที่เสถียรซึ่งสามารถดาวน์โหลดได้จากเว็บไซต์ทางการ

สถาปัตยกรรม

ฟิวส์รวมเทคโนโลยีต่างๆเข้าด้วยกันเป็นผลิตภัณฑ์เดียว

ส่วนประกอบ

Apache CXF

Apache CXF เป็นเฟรมเวิร์กการพัฒนาเว็บเซอร์วิสแบบโอเพนซอร์สซึ่งสนับสนุนการพัฒนา SOAP & Rest web services

อูฐอาปาเช่

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

อนุญาตให้เขียนลอจิกการกำหนดเส้นทางในภาษาเฉพาะโดเมนหลายภาษาเช่น Java, Spring DSL และ Scala เป็นต้น

Apache AMQ

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

อาปาเช่คาราฟ

Apache Karaf เป็นคอนเทนเนอร์ OSGi ที่มีน้ำหนักเบาซึ่งทำหน้าที่เป็นรันไทม์สำหรับสิ่งประดิษฐ์ Apache Karaf มีลักษณะไดนามิกมากกว่าเมื่อเทียบกับ JVM อนุญาตให้ติดตั้งหรือถอนการติดตั้งโมดูลที่รันไทม์ สิ่งประดิษฐ์ทั้งหมดใน Fuse ถูกปรับใช้ใน Karaf

ผ้า

Fabric มอบวิธีง่ายๆในการจัดการการปรับใช้สิ่งประดิษฐ์ในสภาพแวดล้อมขนาดใหญ่และแบบกระจาย มีการจัดการแบบรวมศูนย์สำหรับอินสแตนซ์ฟิวส์หลายตัว

การติดตั้งฟิวส์

การติดตั้ง Fuse นั้นค่อนข้างง่าย เช่นเดียวกับผลิตภัณฑ์ JBoss อื่น ๆ Fuse มาในรูปแบบไฟล์ zip ที่สามารถแตกออกได้และหลังจากการเปลี่ยนแปลงการกำหนดค่าเล็กน้อยสามารถเริ่มต้นได้โดยตรง

การติดตั้ง Fuse เป็นกระบวนการสี่ขั้นตอน -

ดาวน์โหลด

ดาวน์โหลด Fuse 6.1.0 GA จากลิงค์ต่อไปนี้ http://www.jboss.org/

เปิดเครื่องรูด

เช่นเดียวกับผลิตภัณฑ์อื่น ๆ ของ JBoss Fuse ยังเป็นซิปแบบแยกอิสระ

คลายซิปไฟล์ที่ดาวน์โหลดลงในไดเร็กทอรีปลายทางที่คุณต้องการให้เป็นไดเร็กทอรีการติดตั้ง Fuse เลือกไดเร็กทอรีนี้อย่างชาญฉลาดเนื่องจากควรจะยังคงเหมือนเดิมตลอดอายุการใช้งานของอินสแตนซ์ Fuse

Note - แม้ว่า Fuse จะคลายซิปและเริ่มทำงานเหมือนผลิตภัณฑ์ JBoss อื่น ๆ แต่ก็ไม่แนะนำให้ย้ายการติดตั้ง Fuse จากที่หนึ่งไปยังอีกที่หนึ่งหลังจากการติดตั้งเสร็จสิ้น

กำหนดค่า

หลังจากที่คุณเปิดเครื่องรูด Fuse คุณจะพบไดเร็กทอรีต่อไปนี้ใน Directory ที่แยกออกมา -

  • bin
  • etc
  • deploy
  • lib
  • licenses
  • extras
  • quickstarts

ซึ่งเราจะใช้เพียงสองไดเรกทอรี bin & etc.

หลังจากแยก Fuse เราควรจะเริ่มฟิวส์ได้โดยตรง แต่จะเริ่ม Fuse ด้วยการกำหนดค่าเริ่มต้นทั้งหมดซึ่งไม่แนะนำให้ใช้กับสภาพแวดล้อมการผลิต ขอแนะนำอย่างยิ่งให้ทำการเปลี่ยนแปลงต่อไปนี้ก่อนเริ่ม Fuse

ตั้งค่าตัวแปรสภาพแวดล้อม

  • ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้ - JAVA_HOME

  • ตัวแปรควรชี้ไปที่ไดเร็กทอรีการติดตั้ง java - M2_HOME

  • ตัวแปรควรชี้ไปที่ไดเร็กทอรีการติดตั้ง Maven - PATH

  • ตั้งค่าตัวแปรพา ธ เพื่อรวมไฟล์ปฏิบัติการ Java & Maven

Windows

บน windows การตั้งค่าสามารถทำได้โดยทำตามคำแนะนำด้านล่าง -

เริ่ม→คอมพิวเตอร์ของฉัน→คลิกขวา→คุณสมบัติ→การตั้งค่าระบบขั้นสูง→ตัวแปรสภาพแวดล้อม

UNIX & โคลน

สำหรับผู้ใช้แต่ละคนจะมีโปรไฟล์ bash อยู่ในไฟล์ *nixระบบปฏิบัติการ. เราสามารถเพิ่มหรือแก้ไขตัวแปรระบบที่มีอยู่ได้โดยการเปลี่ยนไฟล์นี้

$ vi ~/.bash_proflle

Note- การเปลี่ยนแปลงใด ๆ ในไฟล์นี้จะมีผลถาวร ขอแนะนำให้สำรองไฟล์ที่มีอยู่ก่อนที่จะเปลี่ยนไฟล์ต้นฉบับ

การกำหนดค่าพื้นฐาน

เราจะพูดถึงการกำหนดค่าพื้นฐานของ JBoss Fuse และสำหรับสิ่งนั้นเราต้องเริ่มต้นด้วยคำสั่งต่อไปนี้ Edit $FUSE_INSTALLATION_DIR/etc/

  • ใน user.properties

    • #admin=admin,admin

    • สิ่งนี้จำเป็นต้องเปลี่ยนตามผู้ดูแลระบบคนแรกที่มีชื่อผู้ใช้ที่เราต้องการผู้ดูแลระบบคนที่สองที่มีรหัสผ่านคนที่สามอาจถูกเก็บไว้เหมือนเดิมเพราะมันบ่งบอกถึงบทบาทและอย่าลืมลบ #

    • ตัวอย่างเช่น - FuseAdmin = FusePAss, admin

    • ใน System.properties

      • karafName = root

        • นี่เป็นการระบุชื่อที่คุณต้องการตั้งให้กับอินสแตนซ์ Karaf

        • เราสามารถตั้งชื่ออะไรก็ได้ที่เราต้องการเช่น Cont1

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

    • ใน org.ops4j.pax.web.cfg

      • Org.osgi.service.http.port = 8181

      • คุณสมบัตินี้ระบุพอร์ตที่จะใช้สำหรับการเข้าถึงอินเตอร์เฟสบนเบราว์เซอร์ HAWTIO ที่ Fuse จัดเตรียมไว้ให้

      • HAWTIO เป็นอินเทอร์เฟซเบราว์เซอร์ที่สร้างขึ้นเพื่อ Fuse ซึ่งพร้อมใช้งานตั้งแต่ 6.0 เป็นต้นไป

    • ใน org.ops4j.pax.url.mvn.cfg

      • org.ops4j.pax.url.mvn.localRepository = D: / repository

      • คุณสมบัตินี้ระบุพา ธ ไปยัง localRepository ของ Maven ของเราจากที่ Fuse จะติดตั้งอาร์ติแฟกต์

      • org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml

      • คุณสมบัตินี้ระบุ settings.xml ซึ่ง Fuse ควรใช้เพื่อรับสิ่งประดิษฐ์จาก Maven

    การกำหนดค่า Maven

    Maven เป็นข้อกำหนดเบื้องต้นสำหรับการติดตั้ง Fuse หากคุณไม่ทราบว่า maven คืออะไรโปรดอ้างถึงhttp://www.tutorialspoint.com/maven/

    Maven เป็นเครื่องมือที่สร้างขึ้นเพื่อใช้ในการสร้างสิ่งประดิษฐ์ Fuse รวมการค้นหาครั้งแรกในพื้นที่เก็บข้อมูลท้องถิ่น Maven สำหรับสิ่งประดิษฐ์เมื่อเราออกคำสั่งเพื่อติดตั้งสิ่งประดิษฐ์ ดังนั้นเราต้องแจ้งให้ Fuse ทราบว่า Maven ติดตั้งไว้ที่ใดและเส้นทางของที่เก็บในเครื่องของ Maven

    แก้ไข $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

    อัปเดตคุณสมบัติสองรายการต่อไปนี้ -

    • org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
    • org.ops4j.pax.url.mvn.localRepository = $ local_repo

    Note - กรุณาเปลี่ยน $local_repo ด้วยเส้นทางจริงของที่เก็บในเครื่องของคุณที่กล่าวถึงใน Mavens settings.xml

    วิ่ง

    หลังจากทำการเปลี่ยนแปลงการกำหนดค่าพื้นฐานตอนนี้เราสามารถเริ่ม Fuse ได้แล้ว ไฟล์ไบนารีทั้งหมดที่จะทำงานกับ Fuse อยู่ใน$FUSE_INSTALLATION_DIR.

    มีสองวิธีในการเริ่มฟิวส์ -

    • การใช้ ./fuse

      • ซึ่งจะช่วยให้คุณเห็นความคืบหน้าและบันทึกในหน้าต่างเดียวกับที่คุณเริ่ม Fuse

      • มันจะให้คอนโซล Karaf ในเทอร์มินัลเดียวกับที่แสดงด้านล่าง

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

    • การใช้ ./start

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

      • ในโลกแห่งความเป็นจริงการประยุกต์ใช้พฤติกรรมประเภทนี้เป็นที่ต้องการ ฟิวส์ควรทำงานอยู่เบื้องหลังแม้ว่าเราจะปิดเทอร์มินัล

      • หากคุณต้องการเชื่อมต่อกับ Fuse ที่ทำงานอยู่เบื้องหลังคุณสามารถใช้ client สคริปต์ซึ่งอยู่ในโฟลเดอร์เดียวกัน

      • คุณควรได้รับการแสดงผลดังที่แสดงในภาพหน้าจอต่อไปนี้

      • การออกจากสคริปต์ไคลเอ็นต์จะไม่หยุดบริการ Fuse มันจะปิดคอนโซล Fuse

    HAWTIO

    Fuse ยังให้การเข้าถึง GUI โดยสมบูรณ์โดยใช้ FMC (Fuse management console) คุณสามารถค้นหา GUI ได้ที่ URL ด้านล่างhttp://localhost:8181.

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

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

    ปัญหา JVM

    JVM หรือ Java virtual Machine ไม่ทำหน้าที่เสมือนเครื่องเสมือนจริง เครื่องที่จะช่วยให้คุณหยุดสตาร์ทหรือรีสตาร์ทส่วนประกอบที่ทำงานอยู่ภายในได้ทันที บางครั้งอาจอนุญาตให้ใช้งานได้อย่างรวดเร็วในระดับคลาส แต่ไม่มีวิธีใดที่คุณสามารถปรับใช้หรือยกเลิกการปรับใช้ส่วนประกอบของแอปพลิเคชันของคุณในเครื่องเสมือนได้โดยไม่ต้องรีสตาร์ท

    เพื่อแก้ปัญหานี้และอนุญาตให้โมดูลาร์ในแอปพลิเคชัน Java Fuse ใช้รันไทม์บน OSGi ที่เรียกว่า Apache Karaf

    OSGi

    เทคโนโลยี OSGi เป็นชุดข้อมูลจำเพาะที่กำหนดระบบส่วนประกอบแบบไดนามิกสำหรับ java ข้อกำหนดเหล่านี้อนุญาตให้ใช้โมเดลการพัฒนาที่แอปพลิเคชัน (แบบไดนามิก) ประกอบด้วยส่วนประกอบต่างๆ (ใช้ซ้ำได้)

    ประโยชน์ของ OSGi

    • Reduced Complexity - แอปพลิเคชันถูกสร้างขึ้นเป็นส่วนประกอบการทำงานร่วมกันซึ่งซ่อนรายละเอียดการใช้งานจากกันและกันส่งผลให้ความซับซ้อนลดลง

    • Reusability - ส่วนประกอบจำนวนมากสามารถใช้ประโยชน์จากส่วนประกอบเดียวกันที่ติดตั้งในคอนเทนเนอร์ได้

    • Deployment - OSGi ให้การสนับสนุนสำหรับการเริ่มต้นหยุดและอัปเดตส่วนประกอบได้ทันทีด้วย API การจัดการวงจรชีวิตโดยไม่ต้องรีสตาร์ทคอนเทนเนอร์

    คุณสมบัติ Bundles Vs

    ต่อไปนี้เป็นการเปรียบเทียบระหว่าง Bundles และ Features

    การรวมกลุ่ม

    บันเดิลเทียบเท่ากับ OSGi ซึ่งเป็น JVM บันเดิลคืออาร์ติแฟกต์ที่ปรับใช้ในคอนเทนเนอร์ OSGi บันเดิลเป็นส่วนประกอบที่ทำงานร่วมกันหรือเป็นอิสระในการสร้างแอปพลิเคชัน

    บันเดิลเหล่านี้สามารถติดตั้งถอนการติดตั้งอัพเดตเริ่มต้นหรือหยุดที่รันไทม์โดยไม่ต้องรีสตาร์ทคอนเทนเนอร์

    คุณสมบัติ

    คุณลักษณะเป็นวิธีการปรับใช้หลายกลุ่มเข้าด้วยกัน บางครั้งการปรับใช้บันเดิลในกลุ่มก็สมเหตุสมผลกว่า ฟีเจอร์ช่วยให้เราสามารถปรับใช้กลุ่มบันเดิลได้ด้วยคำสั่งเดียว

    ทำไมต้องเป็นคอนเทนเนอร์อื่น

    Apache Karaf เป็นรันไทม์ที่ใช้ OSGi ซึ่งเป็นที่ที่แอปพลิเคชันบันเดิลของเราทำงาน Fuse ใช้ Apache Karaf เป็นรันไทม์ที่บันเดิลทำงานและทำงานร่วมกันเพื่อมอบฟังก์ชันทางธุรกิจ

    Karaf สร้างขึ้นจาก Felix และ equinox ซึ่งเป็น OSGi Frameworks

    สถาปัตยกรรม Karaf

    Apache Karaf เพิ่มฟังก์ชันเพิ่มเติมดังต่อไปนี้ให้กับรันไทม์ OSGi พื้นฐาน

    Hot Deployment

    Karaf รองรับการใช้งานที่ร้อนแรง มีไดเร็กทอรี hot deploy ทุกสิ่งที่อยู่ในไดเร็กทอรีนี้จะถูกปรับใช้และติดตั้งใน Karaf โดยอัตโนมัติเป็นกลุ่ม

    การบันทึก

    Karaf จัดเตรียมการบันทึกแบบรวมศูนย์โดยการสร้างบันทึกสำหรับบันเดิลทั้งหมดใน $Fuse_home/data/log. เราสามารถแก้ไขการกำหนดค่าคนตัดไม้ได้ในorg.ops4j.pax.logging.cfg ใน $Fuse_home/etc directory.

    คอนโซลผู้ดูแลระบบ

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

    การเข้าถึง SSH

    Karaf อนุญาตให้เข้าถึงคอนโซลผู้ดูแลระบบนี้จากระยะไกลด้วย SSH ทุกคนที่มีข้อมูลรับรองที่ถูกต้องสามารถเชื่อมต่อกับคอนโซลผู้ดูแลระบบ karaf ผ่านเทอร์มินัล SSH

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

    Apache Camel คืออะไร?

    Apache Camel เป็นเฟรมเวิร์กการรวมโอเพนซอร์สซึ่งเริ่มต้นในต้นปี 2550

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

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

    ตัวอย่างพื้นฐาน

    ข้อกำหนดเบื้องต้นในการใช้ Apache Camel คือ -

    • Java
    • Maven
    • Redhat JBoss ฟิวส์ 6.1-GA-379

    สร้างโครงกระดูกพื้นฐานของแอปพลิเคชัน

    mvn:archetype generate 
    –DgroupId = com.tutorialpoint.app 
    –DartifactId = camel-first-app 
    –DarchetypeGroupId = org.apache.camel.archetypes
    –DarchetypeArtifactId = camel-archetype-spring 
    –DinteractiveMode = false -X

    สิ่งนี้ควรสร้างโครงสร้างไดเร็กทอรีต่อไปนี้

    นี่คือโครงกระดูกพื้นฐานของแอปพลิเคชัน Camel ของเราที่สร้างขึ้น

    แก้ไข camel-context.xml

    แก้ไข camel-first-app → src → main → resources → META-INF\spring\camel-context.xml ให้ตรงตามด้านล่าง

    <?xml version = "1.0" encoding = "UTF-8"?>
    <!-- Configures the Camel Context-->
    <beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://camel.apache.org/schema/spring
       http://camel.apache.org/schema/spring/camel-spring.xsd">
    
       <camelContext xmlns = "http://camel.apache.org/schema/spring">
          <!-- here is a sample which processes the input file
             (leaving them in place - see the 'noop' flag) 
             then performs content based routing on the message using XPath -->
    			
          <route>
             <from uri = "file:///d:/src/data?noop=false"/>
             <choice>
                <when>
                   <xpath>/person/city = 'London'</xpath>
                   <log message = "UK message"/>
                   <to uri = "file:///d:/target/messages/uk"/>
                </when>
    				
                <otherwise>
                   <log message = "Other message"/>
                   <to uri = "file:///d:/target/messages/others"/>
                </otherwise>
    				
             </choice>
    			
          </route>
       </camelContext>
    </beans>

    แก้ไข pom.xml

    เพิ่มรหัสต่อไปนี้ใน <plugins> </plugins>

    <plugin>
       <groupId>org.apache.felix</groupId>
       <artifactId>maven-bundle-plugin</artifactId>
       <version>2.3.4</version>
       <extensions>true</extensions>
    	
       <configuration>
          <instructions>
             <Bundle-SymbolicName>
                ${project.artifactId}
             </Bundle-SymbolicName>
             <Import-Package>*</Import-Package>
          </instructions>
       </configuration>
    	
    </plugin>

    เปลี่ยนประเภทบรรจุภัณฑ์จาก jar → bundle.

    <packaging>bundle</packaging>

    สร้างโครงการโดยใช้คำสั่งต่อไปนี้ -

    mvn clean install

    ติดตั้งโครงการลงในฟิวส์

    เริ่มฟิวส์โดยใช้ Fuse.bat/start.bat. หากคุณเริ่ม Fuse โดยใช้ไฟล์start.bat, ใช้ client.batเพื่อเชื่อมต่อกับ Fuse คุณควรได้รับ UI ดังที่แสดงในภาพหน้าจอต่อไปนี้

    นี่คือ CLI สำหรับการเข้าถึงคำสั่ง Karaf และ Fuse

    install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

    ทดสอบว่าโครงการของคุณกำลังทำงานอยู่หรือไม่

    ตอนนี้ควรติดตั้งแอปพลิเคชันของคุณใน Fuse คัดลอกไดเร็กทอรีข้อมูลภายในcamel-first-app และวางไว้ใน D:/src/ และควรคัดลอกข้อความที่มีเมือง = ลอนดอนลงใน D:/target/merssages/uk.

    วางไฟล์อินพุตใน D:/src/data

    Input

    Message1.xml

    <?xml version = "1.0" encoding = "UTF-8"?>
    <person user = "james">
       <firstName>James</firstName>
       <lastName>Strachan</lastName>
       <city>London</city>
    </person>

    Message2.xml

    <?xml version = "1.0" encoding = "UTF-8"?>
    <person user = "hiram">
       <firstName>Hiram</firstName>
       <lastName>Chirino</lastName>
       <city>Tampa</city>
    </person>

    Output

    ใน D: / target / messages / uk

    <?xml version = "1.0" encoding = "UTF-8"?>
    <person user = "james">
       <firstName>James</firstName>
       <lastName>Strachan</lastName>
       <city>London</city>
    </person>

    ใน D: / เป้าหมาย / ข้อความ / อื่น ๆ

    <?xml version = "1.0" encoding = "UTF-8"?>
    <person user = "hiram">
       <firstName>Hiram</firstName>
       <lastName>Chirino</lastName>
       <city>Tampa</city>
    </person>

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

    CamelContext

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

    บริบทของอูฐถือได้ว่าเป็นภาชนะที่เก็บทุกสิ่งไว้ด้วยกัน บริบทอูฐหนึ่งตัวสามารถมีได้หลายเส้นทางภายในนั้น

    เส้นทาง

    CamelContext อาจมีเส้นทางอย่างน้อยหนึ่งเส้นทาง Routes คือตรรกะการรวมที่กำหนดว่าข้อมูลจะไหลในบริบทอูฐจากจุดสิ้นสุดหนึ่งไปยังอีกจุดหนึ่งอย่างไร

    จุดสิ้นสุด

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

    ส่วนประกอบ

    ส่วนประกอบเป็นจุดขยายของ Camel ส่วนประกอบอาจเป็นส่วนต่อประสานกับเทคโนโลยีรูปแบบข้อมูลหม้อแปลง ฯลฯ นอกจากนี้ยังอาจทำหน้าที่เป็นโรงงานสำหรับอุปกรณ์ปลายทาง

    EIP

    EIP ย่อมาจาก Enterprise Integration Pattern สิ่งเหล่านี้เป็นวิธีที่ระบุและเป็นที่รู้จักกันดีสำหรับปัญหาที่เกิดซ้ำ Camel รองรับรูปแบบการรวมองค์กรส่วนใหญ่

    เราเตอร์ตามเนื้อหา

    รูปแบบ CBR ช่วยให้เราสามารถกำหนดเส้นทางข้อมูลตามเนื้อหาของไฟล์อินพุต

    รูปแบบนี้ใช้เมื่อเราต้องกำหนดเส้นทางค่าขึ้นอยู่กับเนื้อหาของเนื้อหาที่ป้อนข้อมูล

    ตัวอย่างต่อไปนี้จะอ่านข้อมูลจาก D:/data/inputไดเรกทอรี หลังจากอ่านแล้วระบบจะตรวจสอบแท็กค่าภายในแท็กข้อมูล หากแท็กค่ามีvalue1มันจะถูกส่งไปที่ D:/value1, ถ้ามี value2มันจะถูกส่งไปที่ D:/value2 และหากไม่มีทั้งสองอย่างนี้ก็จะถูกส่งไปยังผู้อื่น

    <CamelContext xmlns = "http://camel.apache.org/schema/spring">
       <route>
          <from uri = "file:///D:/data/input"/>
          <choice>
             <when>
                <xpath>/data/value = 'value1'</xpath>
                <to uri = "file:///D:/value1"/>
             </when> 
             <when>
                <xpath>/data/value = 'value2'</xpath>
                <to uri = "file:///D:/value2"/>
             </when>  
    			
             <otherwise>
                <to uri = "file:///D:/others "/>
             </otherwise>
    			
          </choice>
       </route>
    </camelContext>

    Input

    D: /data/input/message1.xml

    <data>
       <value>value1</value>
    </data>

    D: /data/input/message2.xml

    <data>
       <value>value2</value>
    </data>

    Output

    D: / ค่า 1 /

    <data>
       <value>value1</value>
    </data>

    D: / ค่า 2 /

    <data>
       <value>value2</value>
    </data>

    ตัวแยก

    รูปแบบตัวแยกใช้เพื่อแบ่งข้อมูลอินพุตออกเป็นชิ้นเล็ก ๆ

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

    <CamelContext xmlns = "http://camel.apache.org/schema/spring">
       <route>
          <from uri = "file:///D:/inbox"/>
          <split streaming = "true">
             <tokenize token = "order" xml = "true"/>
             <to uri = "activemq:queue:order"/>
          </split>
       </route>
    </CamelContext>

    Input

    D: /inbox/message.xml

    <order>
       <data>
          <value>value1</value>
       </data>
    </order>
    
    <order>
       <data>
          <value>value2</value>
       </data>
    </order>
    
    <order>
       <data>
          <value>value3</value>
       </data>
    </order>

    Output

    หากคุณตรวจสอบ AMQ คุณจะพบ 3 ข้อความที่โพสต์

    <order>
       <data>
          <value>value4</value>
       </data>
    </order>

    รายชื่อผู้รับ

    รูปแบบรายชื่อผู้รับถูกใช้เมื่อต้องการดึงรายชื่อผู้รับจากเนื้อหาข้อความ

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

    <CamelContext xmlns = "http://camel.apache.org/schema/spring">
       <route>
          <from uri = "jms:xmlOrders" />
          <recipientList>
             <xpath>/order/customer</xpath>
          </recipientList>
       </route>
    </camelContext>

    EIP อื่น ๆ

    Camel ให้การสนับสนุน EIP เกือบทั้งหมดที่ระบุ EIP ที่ใช้กันทั่วไปมีดังต่อไปนี้

    • Log - เพื่อบันทึกข้อความทั้งหมดหรือบางส่วน

    • Message Filter - การกรองเนื้อหาของข้อความ

    • Re-Sequencer - เพื่อรับโทเค็นทั้งหมดตามลำดับ

    • Wiretap - เพื่อตรวจสอบข้อความการเดินทาง

    รายชื่อ EIP ทั้งหมดและการใช้งานมีอยู่ในเอกสารอย่างเป็นทางการของ Camel http://camel.apache.org/eip.html

    การจัดการข้อยกเว้นในอูฐ

    Using Error Handler - นี่เป็นวิธีที่ง่ายที่สุดในการจัดการข้อยกเว้นในอูฐ

    ในการใช้สิ่งนี้เราต้องกำหนดค่าคลาสตัวจัดการข้อผิดพลาดและระบุเป็นการอ้างอิงถึง CamelContext errorHandlerRef แอตทริบิวต์

    <bean id = "loggingErrorHandler" class = "org.apache.camel.builder.LoggingErrorHandler">
       <property name = "logName" value = "mylogger.name"/>
       <property name = "level" value = "DEBUG"/>
    </bean>
    
    <camelContext errorHandlerRef = ” loggingErrorHandler” >
       …
    </camelContext>

    ใช้ Try Catch ในที่สุด

    Camel ยังรองรับรูปแบบ Java Try Catch Finally block สำหรับการจัดการข้อผิดพลาด

    เช่นเดียวกับ Java มีสามบล็อกต่อไปนี้ -

    • doTry บล็อกมีรหัสที่อาจสร้างข้อยกเว้น

    • doCatch บล็อกมีรหัสที่ต้องดำเนินการในกรณีที่มีข้อยกเว้น

    • doFinallyบล็อกมีรหัสที่ต้องดำเนินการโดยไม่คำนึงถึงข้อยกเว้น มันจะถูกดำเนินการเสมอไม่ว่าจะมีการยกเว้นหรือไม่ก็ตาม

    Note- Mock เป็นส่วนประกอบการทดสอบและไม่แนะนำสำหรับวัตถุประสงค์อื่น เป็นส่วนประกอบในอูฐที่ใช้ในการทดสอบเช่นเดียวกับส่วนประกอบ jMOck ในการพัฒนาแบบทดสอบ

    <route>
       <from uri = "direct:start"/>
       <doTry>
          <process ref = "someProcesorThatmayFail"/>
          <to uri = "mock:result"/>
    		
          <doCatch>
             <exception>java.io.IOException</exception>
             <exception>java.lang.IllegalStateException</exception>
             <to uri = "mock:catch"/>
          </doCatch>
    		
          <doFinally>
             <to uri = "mock:finally"/>
          </doFinally>
    		
       </doTry>
    </route>

    ในตัวอย่างข้างต้นเราสามารถให้รายการข้อยกเว้นที่จำเป็นต้องจัดการโดย Catch Block

    การปรับใช้ Bundle ใน Fuse

    เริ่มฟิวส์โดยใช้ Fuse.bat/start.bat.

    หากคุณเริ่ม Fuse โดยใช้ start.bat ให้ใช้ client.bat เพื่อเชื่อมต่อกับ Fuse คุณควรได้รับ UI ดังที่แสดงในภาพหน้าจอต่อไปนี้

    นี่คือ CLI สำหรับการเข้าถึงคำสั่ง Karaf และ Fuse

    install –s mvn:group.id /artifact.id/version 
    e.g. install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

    ในบทนี้ให้เราพูดคุยเกี่ยวกับ Apache CXF คืออะไรและจะมีประโยชน์ในการพัฒนา SOAP และ Rest Web Services ได้อย่างไร

    Apache CXF คืออะไร?

    Apache CXF เป็นเฟรมเวิร์กการพัฒนาบริการเว็บที่สามารถใช้เพื่อพัฒนา SOAP และ Rest web services CXF สอดคล้องกับJAX-RS and JAX-Ws มาตรฐาน.

    เป็นกรอบการพัฒนาบริการเว็บที่ใช้กันอย่างแพร่หลายที่สุดในขณะนี้ CXF ได้เรียนรู้และปรับปรุงมากกว่า Axis2 ซึ่งตอนนี้ CXF ค่อยๆถูกแทนที่

    CXF เทียบกับแกน 2

    CXF แกน 2
    การปรับปรุง

    CXF เป็นเฟรมเวิร์กที่ใช้มากที่สุด ณ ตอนนี้

    มีการปรับปรุงมากมายใน Axis2

    Axis2 ค่อยๆถูกแทนที่ด้วย CXf

    ต้องใช้รหัสมากกว่าเมื่อเทียบกับ CXF

    ต้องระบุรหัส

    CXF ต้องการรหัสน้อยกว่าเมื่อเทียบกับ Axis2

    Axis2 ต้องการโค้ดมากกว่าในเชิงเปรียบเทียบ

    การปฏิบัติตามมาตรฐาน

    CSF สอดคล้องกับ JAX-RS และ JAX-WS อย่างสมบูรณ์

    Axis2 ไม่สอดคล้องกับ JAX-RS และ JAX-WS อย่างสมบูรณ์

    เข้ากันได้กับสปริง

    ใช่

    ไม่

    การแยกส่วนหน้า

    ทำความสะอาดการแยกส่วนหน้าออกจากรหัส JAX-WS

    ไม่มีการแยกที่สะอาด

    สบู่

    SOAP ย่อมาจาก Simple Object Access Protocol เป็นโปรโตคอลสำหรับการแลกเปลี่ยนข้อมูลที่มีโครงสร้างผ่านบริการเว็บระหว่างสองระบบ ส่วนใหญ่อาศัย XML ในการจัดโครงสร้างข้อมูลและใช้ HTTP หรือ SMTP สำหรับการเจรจาต่อรองและส่งข้อความ

    มีสองวิธีในการพัฒนาบริการเว็บ SOAP -

    • Code first - ด้วยวิธีนี้ WSDL ถูกสร้างขึ้นจากรหัส

    • Contract first - ในสัญญาก่อนรหัสจะถูกสร้างขึ้นจาก WSDL

    การพัฒนาสบู่โดยใช้ CXF

    กำหนดค่า Maven

    เพิ่มโปรไฟล์ต่อไปนี้ใน settings.xml ของ Maven

    <profiles>
       <profile>
          <id>Jboss-Fuse</id>
    		
          <activation>
             <activeByDefault>true</activeByDefault>
          </activation>
    		
          <repositories>
             <repository>
                <id>fusesource</id>
                <url>http://repo.fusesource.com/nexus/content/groups/public/</url>
                <snapshots>
                   <enabled>false</enabled>
                </snapshots>
                <releases>
                   <enabled>true</enabled>
                </releases>
             </repository>
          </repositories>
    		
       </profile>
    </profiles>

    สร้างโครงกระดูก

    mvn archetype:generate
    -DarchetypeGroupId = org.apache.servicemix.tooling 
    -DarchetypeArtifactId = servicemix-cxf-code-first-osgi-bundle 
    -DarchetypeVersion=2012.01.0.redhat-60024 
    -DgroupId = org.fusesource.example 
    -DartifactId = cxf-basic 
    -Dversion = 1.0-SNAPSHOT

    Build Web Service Project.

    mvn clean install

    Install web-service into Fuse using the following command.

    JBossFuse:karaf@root>install -s mvn:org.fusesource.example/cxf-basic/1.0-SNAPSH

    Check if bundle has registered SOQP web-service

    เปิด URL http://localhost:8181/cxf

    บริการบนเว็บควรมีรายชื่อดังนี้

    Testing Web-Service

    mvn -Pclient

    INFO - การสร้างบริการ {http://ws.totorials.com/} PersonService จากคลาส com.to

    torials.ws.Person
    Invoking getPerson...
    getPerson._getPerson_personId = Guillaume
    getPerson._getPerson_ssn = 000-000-0000
    getPerson._getPerson_name = Guillaume
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 30.668 s
    [INFO] Finished at: 2016-02-15T21:01:20+05:30
    [INFO] Final Memory: 10M/37M
    [INFO] ------------------------------------------------------------------------

    เริ่มต้นด้วย REST ย่อมาจาก Representational State Transfer เป็นวิธีการพัฒนาบริการเว็บโดยใช้โปรโตคอลไคลเอนต์เซิร์ฟเวอร์ที่ไม่ระบุสถานะแคชได้ซึ่งส่วนใหญ่เป็น HTTP

    บริการเว็บ REST ใช้คำขอ HTTP เพื่อโพสต์รับลบข้อมูลจากเครือข่าย

    การพัฒนา REST โดยใช้ CXF

    สร้างโครงการเริ่มต้นด่วน Maven อย่างง่าย

    mvn archetype:generate 
    -DgroupId = com.tuts.abhinav 
    -DartifactId = rest-service
    -DarchetypeArtifactId = maven-archetype-quickstart 
    -DinteractiveMode = false

    เพิ่มการอ้างอิง

    <dependency>
       <groupId>org.apache.servicemix.specs</groupId>
       <artifactId>org.apache.servicemix.specs.jsr311-api-1.1.1</artifactId>
       <version>1.9.0</version>
       <scope>provided</scope>
    </dependency>
    
    <dependency>
       <groupId>org.apache.servicemix</groupId>
       <artifactId>servicemix-http</artifactId>
       <version>2013.01</version>
    </dependency>
    
    <dependency>
       <groupId>log4j</groupId>
       <artifactId>log4j</artifactId>
       <version>1.2.16</version>
    </dependency>

    เพิ่มคำสั่งสร้าง

    <build>
       <defaultGoal>install</defaultGoal>
       <plugins>
          <plugin>
             <groupId>org.apache.felix</groupId>
             <artifalctId>maven-bundle-plugin</artifactId>
             <version>2.3.4</version>
             <extensions>true</extensions>
    			
             <configuration>
                <instructions>
                   <Bundle-SymbolicName>rest-example-database-post-method
                      </Bundle-SymbolicName>
                   <Import-Package>* </Import-Package>
                </instructions>
             </configuration>
    			
          </plugin>
       </plugins>
    </build>

    เพิ่ม Fuse Plugin Repositories

    <pluginRepositories>
       <pluginRepository>
          <id>fusesource.m2</id>
          <name>FuseSource Community Release Repository</name>
          <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
          <snapshots>
             <enabled>false</enabled>
          </snapshots>
    		
          <releases>
             <enabled>true</enabled>
          </releases>
       </pluginRepository>
    <pluginRepositories>

    เพิ่มที่เก็บ

    <repositories>
       <repository>
          <id>fusesource.m2</id>
          <name>FuseSource Community Release Repository</name>
          <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
          <snapshots>
             <enabled>false</enabled>
          </snapshots>
    		
          <releases>
             <enabled>true</enabled>
          </releases>
    		
       </repository>
    	
       <repository>
          <id>fusesource.ea</id>
          <name>FuseSource Community Early Access Release Repository</name>
          <url>http://repo.fusesource.com/nexus/content/groups/ea</url>
          <snapshots>
             <enabled>false</enabled>
          </snapshots>
          <releases>
             <enabled>true</enabled>
          </releases>
       </repository>
    	
    </repositories>

    สร้างคลาสบริการ

    สร้างคลาส UserService.java ภายใต้ com / tuts /

    package com.tuts;
    
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.Produces;
    import javax.ws.rs.core.MediaType;
    
    @Path("/UserService_1")
    public class UserService {
       @GET
       @Path("/get_data")
       @Produces(MediaType.APPLICATION_JSON)
    	
       public String getUser() {
          String reponse = "This is standard response from REST";
          return reponse;
       }
    }

    สร้าง Blueprint.xml

    สร้าง blueprint.xml ภายใต้ / src / main / resources / OSGI-INF / blueprint blueprint.xml

    <?xml version = "1.0" encoding = "UTF-8"?>
    <blueprint xmlns = "http://www.osgi.org/xmlns/blueprint/v1.0.0"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:jaxrs = "http://cxf.apache.org/blueprint/jaxrs"
       xsi:schemaLocation = "http://www.osgi.org/xmlns/blueprint/v1.0.0 
       http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
       http://cxf.apache.org/blueprint/jaxrs 
       http://cxf.apache.org/schemas/blueprint/jaxrs.xsd">
    	
       <jaxrs:server id = "service" address = "/users">
          <jaxrs:serviceBeans>
             <ref component-id = "userService" />
          </jaxrs:serviceBeans>
       </jaxrs:server>
    	
       <bean id = "userService" class = "com.tuts.UserService" />
    </blueprint>

    ติดตั้ง Rest service ใน Fuse

    install -s mvn:com.tuts.abhinav/rest-service/1.0-SNAPSHOT

    ตรวจสอบว่า Bundle มีบริการบนเว็บที่ลงทะเบียนหรือไม่

    เปิด URL http://localhost:8181/cxf

    ทดสอบบริการเว็บ

    เปิด URL http://localhost:8181/cxf/users12/UserService_1/get_data

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

    AMQ คืออะไร?

    ActiveMQ เป็นโบรกเกอร์ข้อความโอเพนซอร์สที่เขียนด้วย Java เป็นไปตามมาตรฐาน JMS 1.1 อย่างสมบูรณ์

    JMS เป็นข้อกำหนดที่ช่วยในการพัฒนาระบบตามข้อความ ActiveMQ ทำหน้าที่เป็นนายหน้าของข้อความที่อยู่ระหว่างแอปพลิเคชันและช่วยให้สามารถสื่อสารในรูปแบบอะซิงโครนัสและเชื่อถือได้

    ประเภทของการส่งข้อความ

    มีตัวเลือกการส่งข้อความสองประเภทที่อธิบายไว้ด้านล่างเพื่อความเข้าใจที่ดีขึ้น

    จุดต่อจุด

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

    หากไม่มีผู้บริโภคโบรกเกอร์จะเก็บข้อความไว้จนกว่าจะได้รับผู้บริโภค การสื่อสารประเภทนี้เรียกอีกอย่างว่าQueue based communicationโดยที่ Producer ส่งข้อความไปยังคิวและมีผู้บริโภคเพียงรายเดียวเท่านั้นที่ได้รับหนึ่งข้อความจากคิว หากมีผู้บริโภคมากกว่าหนึ่งรายพวกเขาอาจได้รับข้อความถัดไป แต่จะไม่ได้รับข้อความเดียวกันกับผู้บริโภครายอื่น

    เผยแพร่ / สมัครสมาชิก

    ในการสื่อสารประเภทนี้นายหน้าจะส่งสำเนาข้อความเดียวกันไปยังผู้บริโภคที่ใช้งานอยู่ทั้งหมด การสื่อสารประเภทนี้เรียกอีกอย่างว่าTopic based communicationที่โบรกเกอร์ส่งข้อความเดียวกันไปยังผู้บริโภคที่ใช้งานอยู่ทั้งหมดที่สมัครรับหัวข้อเฉพาะ รุ่นนี้รองรับการสื่อสารทางเดียวซึ่งคาดว่าจะไม่มีการตรวจสอบข้อความที่ส่ง

    การสร้างคิวและหัวข้อ

    ฟิวส์มาพร้อมกับ ActiveMQ เราสามารถเข้าถึง ActiveMQ โดยใช้คอนโซล FMC (อินเทอร์เฟซที่ใช้เบราว์เซอร์เพื่อทำงานกับ AMQ)

    เข้าสู่ระบบ FMC โดยใช้ localhost:8181 และเลือก ActiveMQ แท็บ

    • คลิกที่ + สร้าง
    • ป้อนชื่อคิว / หัวข้อ
    • เลือกคิว / หัวข้อจากปุ่มตัวเลือก
    • คลิกที่สร้างคิว / สร้างหัวข้อ

    ตอนนี้คุณควรจะเห็นไฟล์ TestQ สร้างภายใต้รูท→คิว→

    ในการตรวจสอบหัวข้อที่สร้างขึ้นให้ทำตามรูท→หัวข้อ

    การเรียกดู / การลบเนื้อหาของคิว

    • เข้าสู่ระบบ FMC โดยใช้ localhost:8181

    • เลือกแท็บ ActiveMQ

    • Root → Queue → TestQ <เลือกคิวที่คุณต้องการเรียกดู> →เรียกดู

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

    ในบทนี้เราจะเรียนรู้พื้นฐานของการทำงานของ ActiveMQ กับ Camel

    การกำหนดค่าเป็น ActiveMQ Component

    ก่อนที่เราจะสามารถใช้คิว ActiveMQ หรือหัวข้อในโค้ดของเราเราต้องกำหนดค่า ActiveMQComponent การกำหนดค่าขั้นต่ำของ ActiveMQComponent สามารถทำได้ดังแสดงในโปรแกรมต่อไปนี้ -

    <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
       <property name = "brokerURL" value = "tcp://localhost:61616"/>
       <property name = "userName" value = "admin"/>
       <property name = "password" value = "admin"/>
    </bean>
    • brokerURL - ระบุโฮสต์และพอร์ตสำหรับ AMQ Broker

    • username - ระบุชื่อผู้ใช้ที่จะใช้เชื่อมต่อกับ AMQ Broker

    • password - ระบุรหัสผ่านสำหรับเชื่อมต่อกับ AMQ Broker

    กำลังเชื่อมต่อกับคิว

    ตอนนี้เราได้กำหนดค่า ActiveMQComponent แล้วเราสามารถใช้ใน CamelContext เป็นจุดสิ้นสุด

    เราจะใช้จุดสิ้นสุด AMQ ในรูปแบบต่อไปนี้ -

    Activemq:[queue|topic]:[queueName|topicName]

    การเขียนข้อความถึง AMQ

    <?xml version = "1.0" encoding="UTF-8"?>
    <!-- Configures the Camel Context-->
    <beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://camel.apache.org/schema/spring
       http://camel.apache.org/schema/spring/camel-spring.xsd">

    หลังจากปรับใช้บันเดิลนี้ใน Fuse container คุณควรจะเห็นข้อความที่โพสต์ไปยัง AMQ ซึ่งวางเป็นไฟล์ในรูปแบบ D:/src/data.

    Input

    D: /src/data/input.txt

    Test me

    Output

    อ่านจาก AMQ

    <?xml version = "1.0" encoding = "UTF-8"?>
    <!-- Configures the Camel Context-->
    
    <beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://camel.apache.org/schema/spring
       http://camel.apache.org/schema/spring/camel-spring.xsd">
    	
       <camelContext xmlns = "http://camel.apache.org/schema/spring">
          <!-- here is a sample which processes the input files
             (leaving them in place - see the 'noop' flag)
              then performs content based routing on the message using XPath -->
    			 
          <route>
             <from uri = "activemq:queue:TestQ"/>
             <to uri = "file:///d:/src"/>
          </route>
       </camelContext>
    	
       <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
          <property name = "brokerURL" value = "tcp://localhost:61616"/>
          <property name = "userName" value = "admin"/>
          <property name = "password" value = "admin"/>
       </bean>
    	
    </beans>

    Input

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

    Output

    D: / src

    Test me

    การเขียนหัวข้อ

    <?xml version = "1.0" encoding = "UTF-8"?>
    <!-- Configures the Camel Context-->
    <beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://camel.apache.org/schema/spring 
       http://camel.apache.org/schema/spring/camel-spring.xsd">
    	
       <camelContext xmlns = "http://camel.apache.org/schema/spring">
          <!-- here is a sample which processes the input files
             (leaving them in place - see the 'noop' flag)
              then performs content based routing on the message using XPath -->
    			 
          <route>
             <from uri = "file:///d:/src"/>
             <to uri = "activemq:topic:TestTopic” />
          </route>
       </camelContext>
    	
       <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
          <property name = "brokerURL" value = "tcp://localhost:61616"/>
          <property name = "userName" value = "admin"/>
          <property name = "password" value = "admin"/>
       </bean>
    	
    </beans>

อ่านจากหัวข้อ

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "activemq:topic:TestTopic"/>
         <to uri = "file:///d:/src2"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value="tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

D: /src/file1.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

D: / src /

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

ผ้าคืออะไร?

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

ทำไมต้องเป็นผ้า?

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

  • ตรวจสอบสถานะของภาชนะทั้งหมดในผ้า
  • การสตาร์ทและการหยุดคอนเทนเนอร์ระยะไกล
  • จัดเตรียมคอนเทนเนอร์ระยะไกลเพื่อเรียกใช้แอปพลิเคชันเฉพาะ
  • การอัปเกรดแอปพลิเคชันและเปิดตัวแพตช์ในระบบถ่ายทอดสด
  • เริ่มต้นและจัดเตรียมคอนเทนเนอร์ใหม่อย่างรวดเร็วเพื่อรับมือกับภาระที่เพิ่มขึ้นในระบบ

การตั้งค่าผ้า

การสร้างผ้า

ปกติ Fuse container สามารถแปลงเป็น Fabric ได้โดยใช้คำสั่งต่อไปนี้

fabric: create --clean --zookeeper-password myZooPass

การเชื่อมต่อภาชนะอื่นกับ Fabric -

fabric:join --zookeeper-password myZooPass <fabric_host>:2181 Cont1

Note - โปรดแทนที่ <fabric_host> ด้วยชื่อโฮสต์จริงที่แฟบริคทำงานอยู่

เมื่อคุณเข้าสู่ระบบ Fuse Management Console จากเบราว์เซอร์ของคุณโดยใช้ localhost:8181คุณควรจะเห็นสองคอนเทนเนอร์ดังที่แสดงในภาพหน้าจอต่อไปนี้ คอนเทนเนอร์ Fabric มีสัญลักษณ์เมฆขนาดเล็กอยู่ด้านหน้า

โปรไฟล์

โปรไฟล์มีข้อมูลต่อไปนี้ -

  • การรวมกลุ่มที่จะติดตั้ง
  • คุณสมบัติที่จะติดตั้ง
  • การกำหนดค่าที่จะใช้

โปรไฟล์จัดเตรียมวิธีในสภาพแวดล้อมแฟบริกเพื่อติดตั้งบันเดิลคุณลักษณะและคอนฟิกูเรชันเดียวกันบนเซิร์ฟเวอร์หลายเครื่อง

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

การสร้างโปรไฟล์

  • เข้าสู่ระบบ FMC localhost:8181

  • รันไทม์→จัดการ

  • ที่ด้านซ้ายมือใต้เมนูโปรไฟล์คลิกที่ +

ป้อนชื่อที่คุณต้องการตั้งให้กับโปรไฟล์แล้วคลิกสร้าง

หลังจากนี้ควรสร้างโปรไฟล์

การใช้โปรไฟล์กับคอนเทนเนอร์

รันไทม์→คอนเทนเนอร์→รูท (เลือกคอนเทนเนอร์ที่คุณต้องการ)

คลิก Addซึ่งจะนำไปสู่กล่องป๊อปอัป ค้นหาโปรไฟล์ที่คุณต้องการแล้วคลิกอีกครั้งAdd.

โปรไฟล์ควรแสดงในรายการดังที่แสดงในภาพหน้าจอต่อไปนี้

การปรับใช้ Bundle

ในการปรับใช้บันเดิลให้ใช้เส้นทางต่อไปนี้ -

รันไทม์→คอนเทนเนอร์→รูท (เลือกคอนเทนเนอร์ที่คุณต้องการ) → First_profile (เลือกโปรไฟล์)

คลิกแท็บ Bundles กำหนดเส้นทางบันเดิลในรูปแบบต่อไปนี้แล้วคลิก+.

mvn:group.id/artifact.id/version

ตัวอย่างเช่น: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

บันเดิลจะถูกเพิ่มลงในโปรไฟล์และจะนำไปใช้กับคอนเทนเนอร์ทั้งหมดที่กำหนดโปรไฟล์

การยกเลิกการใช้งาน Bundle

ในการยกเลิกการปรับใช้บันเดิลให้ใช้เส้นทางต่อไปนี้ -

รันไทม์→คอนเทนเนอร์→รูท (เลือกคอนเทนเนอร์ที่คุณต้องการ) → First_profile (เลือกโปรไฟล์)

คลิกแท็บ Bundles และค้นหาบันเดิลที่คุณต้องการลบจากนั้นคลิกที่ X. Bundle จะถูกลบออกจากคอนเทนเนอร์ทั้งหมดที่ใช้โปรไฟล์

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

การสร้างคอนเทนเนอร์ลูก

เข้าสู่ระบบ FMC โดยใช้ localhost:8181

ตอนนี้ไปตามเส้นทาง: Runtime → container → + Create (ปุ่มทางด้านขวามือ)

ป้อนรายละเอียดเช่นชื่อลูกคอนเทนเนอร์หลักจำนวนอินสแตนซ์เป็นต้น

คลิก Create And Start Container

การจัดการคอนเทนเนอร์ลูก

คอนเทนเนอร์เด็กทำหน้าที่เป็นคอนเทนเนอร์ปกติเท่านั้น

การหยุดคอนเทนเนอร์ลูก

ในการหยุดคอนเทนเนอร์ลูกให้ทำตามเส้นทาง: รันไทม์→คอนเทนเนอร์→เด็ก 1

คลิกหยุดเพื่อหยุดคอนเทนเนอร์ลูก

การเริ่มต้นคอนเทนเนอร์ลูก

ในการเริ่มต้นคอนเทนเนอร์ลูกให้ทำตามเส้นทาง: รันไทม์→คอนเทนเนอร์→เด็ก 1

คลิกเริ่มเพื่อเริ่มคอนเทนเนอร์ลูก

ในบทนี้เราจะพูดถึงปัญหาที่ทราบบางประการที่คุณอาจพบขณะทำงานกับ Fuse นอกจากนี้เราจะพูดคุยกันว่าคุณจะแก้ไขปัญหาเหล่านี้ได้อย่างไร

การเปลี่ยนแปลงรหัสจะไม่สะท้อน

เชื่อมต่อกับอินสแตนซ์ Fuse โดยใช้สคริปต์ไคลเอ็นต์ ค้นหาบันเดิลที่คุณกำลังประสบปัญหาโดยใช้คำสั่งต่อไปนี้

JBossFuse:karaf@root > list|grep <Bundle Description>
For Example:
JBossFuse:karaf@root > list|grep Camel
[ 255] [Active ] [ ] [ ] [ 60] Fabric8 :: Camel Component (1.0.0.redhat-379)
[ 266] [Active ] [ ] [Started] [ 60] A Camel Spring Route (1.0.0.SNAPSHOT)

Note - Bundle ID สำหรับบันเดิลจากเอาต์พุตของคำสั่งด้านบนและใช้คำสั่งด้านล่าง

JBossFuse:karaf@root > update <bundle id>
JBossFuse:karaf@root > update 266

ไม่ได้ดาวน์โหลด Bundle

อาจเกิดขึ้นเนื่องจากสองสาเหตุต่อไปนี้ -

  • ไม่ได้ระบุที่เก็บ Maven
  • ไม่มีบันเดิลในที่เก็บ

ไม่ระบุที่เก็บ Maven

Maven เป็นเครื่องมือที่สร้างขึ้นเพื่อใช้ในการสร้างสิ่งประดิษฐ์ Fuse รวมการค้นหาครั้งแรกในพื้นที่เก็บข้อมูลท้องถิ่น Maven สำหรับสิ่งประดิษฐ์เมื่อเราออกคำสั่งเพื่อติดตั้งสิ่งประดิษฐ์ ดังนั้นเราต้องแจ้งให้ Fuse ทราบตำแหน่งที่ติดตั้ง Maven และเส้นทางของพื้นที่เก็บข้อมูล Mavens

แก้ไข $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

อัปเดตคุณสมบัติสองรายการต่อไปนี้ -

  • org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
  • org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - โปรดเปลี่ยน $ local_repo ด้วยเส้นทางจริงของที่เก็บในเครื่องของคุณที่กล่าวถึงใน Mavens settings.xml

Bundle ไม่อยู่ใน Repository

หากมีการตั้งค่า Maven แต่ยังคงประสบปัญหาขณะดาวน์โหลดชุดข้อมูลให้ตรวจสอบว่าบันเดิล JAR อยู่ในตำแหน่งที่ถูกต้องใน Maven Repository

ตัวอย่างเช่นหากบันเดิลต่อไปนี้เกิดข้อผิดพลาดขณะดาวน์โหลด -

mvn:com.tutorialpoint.app/camel-first-app/1.0-SNAPSHOT

เราต้องตรวจสอบใน $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT หากมี JAR จริง

Note - $ M2_REPO จะต้องถูกแทนที่ด้วยพา ธ จริงของที่เก็บ Maven ที่เรากำหนดค่า Fuse ให้ใช้

ไม่สามารถเข้าสู่ระบบ FMC (GUI ที่ใช้เบราว์เซอร์)

Users not Created - หากคุณได้รับ UI ต่อไปนี้ แต่ไม่สามารถเข้าสู่ระบบได้โดยมีข้อความว่า“ เข้าสู่ระบบล้มเหลวถูกห้าม”

ตรวจสอบว่าคุณได้เพิ่มผู้ใช้เข้ามาหรือไม่ $FUSE_INSTALLATION_HOME/etc/users.properties

รูปแบบที่ถูกต้องในการเพิ่มผู้ใช้คือ -

Username = Password,Role

พอร์ต HAWTIO แตกต่างกัน

หากคุณไม่สามารถรับ UI ที่ localhost: 8181 ในเบราว์เซอร์ได้ให้ตรวจสอบว่าคุณได้กล่าวถึงพอร์ตที่ถูกต้องใน URL หรือไม่

$FUSE_INSTALLATION_HOME/etc/org.ops4j.pax.web.cfg

แก้ไขคุณสมบัติต่อไปนี้ในไฟล์เพื่อใช้พอร์ตที่คุณต้องการเข้าถึง

org.osgi.service.http.port=8181

AMQ Broker ไม่ทำงาน

ตรวจสอบให้แน่ใจว่าพอร์ต 61616 เปิดอยู่และไม่ได้ใช้งานโดยพอร์ตอื่น หากคุณต้องการเปลี่ยนพอร์ต 61616 เริ่มต้นสำหรับพอร์ตเดียวกันคุณสามารถแก้ไขได้ในรูปแบบ$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616