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