จากการแบ่งปันเรื่องของ Software Architecture ทั้ง Monolith, SOA และ Microservice นั้น
คำถามที่เจอบ่อย ๆ คือ การจัดการให้ service หนึ่ง ๆ เป็น module/component ให้มันดีก่อน
แต่เมื่อมีการติดต่อสื่อสารกันระหว่าง module แล้ว
จะจัดการ หรือ เลือกแนวทางไหนดี
หนึ่งในแนวทางที่เคยอธิบายไว้แล้วคือ ผ่านตัวกลาง หรือ การติดต่อแบบ indect
แต่ก็ยังมีวิธีการอื่น ๆ ในการจัดการ จึงสรุปแบบสั้น ๆ ไว้นิดหน่อย
โดยแต่ละวิธีก็มีข้อดีและข้อเสียต่างกันไป
ลองเรียนรู้ และ พิจารณากันดูครับ
แบบที่ 1 เรียกกันตรง ๆ ไปเลย
โดยปกติก็ reference ผ่าน code ตรง ๆ ไปเลย
แต่ผลที่ตามมาคือ แต่ละ module ผู้มัดกันไปหมดเลย
หาขอบเขตได้ยากมาก ๆ
ดังนั้นถ้าเรียกตรง ๆ แบบนี้ ต้องจัดการให้ดี
เช่น การสร้าง public interface ของ module นั้น ๆ ขึ้นมา
ถ้าหลักการของ design pattern จะเรียกว่า facade pattern
หรือบ่อยครั้งจะเห็นว่า ติดต่อผ่านระบบ network กันไปเลย
นั่นคือ แต่ละ module ทำงานอยู่ต่าง process กัน
เช่นการติดต่อผ่าน HTTP protocol เป็นต้น
อาจะใช้รูปแบบของ RESTFul API และ gRPC เป็นต้น
แต่ต้องระวังด้วย เพราะว่าการติดต่อผ่านระบบ network มันพร้อมพังมาก ๆ
ต้องระมัดระวังให้ดี
Plan for fail ต้องมาแล้วนะ
แบบที่สอง แบบไม่เรียกตรง ๆ (indirect) หรือ มีคนกลางนั่นเอง
เป็นเหมือนการเพิ่ม hop เข้ามา เช่น
- Gateway ตรงกลาง
- Event-based ผ่าน memory, messaging server
- File system แล้วสร้าง batch process มาทำงานตามเวลาที่เราต้องการ
แน่นอนว่า วิธีการนี้ทำให้แต่ละ module ผูกมัดกันน้อยลง
แต่ความซับซ้อนก็สูงขึ้นเช่นเดียวกัน
ก็ต้องระมัดระวังเช่นเดียวกัน
ลองดูว่า การติดต่อสื่อสารระหว่าง module ของระบบงานควรเป็นอย่างไร
เลือกให้เหมาะสมกับงาน คน เวลา
ขอให้สนุกกับการ coding ครับ