ว่าด้วยเรื่องการติดต่อสื่อสารระหว่าง module ด้วย Spring Modulith

July 14, 2026 Programming

หนึ่งในคำถามที่น่าสนใจ จากการ share เรื่อง Software Architecture นั่นก็คือ
เราจะแบ่งส่วนต่าง ๆ ของการทำงานในระบบออกเป็น service ย่อย ๆ อย่างไรบ้าง ?
ซึ่งแน่นอนมีแนวคิดเยอะมาก ๆ
ทั้ง Modular
ทั้ง Service-Oriented Architecture
ทั้ง Microservice
ทั้งนำแนวคิด boundary context จาก DDD เข้ามาช่วย
ทั้งแนวคิด Event-based เข้ามาใช้งาน
เยอะไปหมด แต่กลับมาจุดเริ่มต้นคือ ปัญหาที่คุณจะแก้ไขคืออะไรนั่นเอง ?
เมื่อรู้ปัญหาแล้ว คุณมีวิธีการในกระเป๋า หรือใน secret toolbox เยอะไหม ?
อย่าบอกนะ มีเพียงวิธีการเดียว แล้วใช้มันแก้ทุกปัญหา !!

แต่หนึ่งในแนวคิดที่ควรเริ่มต้นก่อนคือ อย่าเพิ่งไปแยกออกจากกัน
ให้ทำการรวมอยู่ด้วยกันก่อน แล้วจัดการให้ดี
แน่นอนว่า ยังไม่มีเปลี่ยน หรือ กระทบแนวทางการพัฒนาและ deploy มากนัก
เช่นยังอยู่บ้านหลังเดียวกัน แต่แบ่งออกเป็นห้องย่อย ๆ ตามความรับผิดชอบไปเลย
หรือจะเรียกว่า Modular นั่นเอง
หรือบางคนอาจจะเรียกว่า Modulith Architecture ก็ได้

ปล. ในแต่ละ module ก็ควรทำงานจบในตัวเองให้มากที่สุดเช่นกัน
ไม่ใช่แบ่งเป็น module แล้ว แต่เรียกกันไปมาจนเกิด cyclic ก็ไม่ดีนะ

โดยจะยกตัวอย่างด้วยการใช้งานผ่าน Spring Modulith กันหน่อย

ซึ่ง project ตัวนี้จะช่วย 2 เรื่องหลัก ๆ คือ

• สร้าง Diagram การทำงานของแต่ละ module ว่าเรียกใช้งานกันอย่างไร
• การติดต่อสื่อสารระหว่าง module มีทั้งแบบ เรียกผ่าน code ตรง ๆ ได้เลย และ event-based (Tight vs Loose coupling)

แน่นอนว่า project นี้ทำขึ้นมาเพื่อสนับสนุน Spring Boot App นั่นเอง
ดังนั้นโครงสร้าง โดยพื้นฐานของระบบงานที่เป็น modular ก็จะเป็นไปตามรูปแบบดังนี้
สามารถ shared database ร่วมกันได้
(แต่จัดการ boundary ให้ดี มิเช่นนั้นก็จะมีเป็น monolith ที่ database อีก !!)

มาดูสิ่งที่น่าสนใจคือ การติดต่อสื่อสารระหว่าง module ใน Spring Modulith กัน

โดยปกติเราสามารถกำหนดในแต่ละ module ได้เลยว่า
จะเปิดให้ class จาก module อื่นเรียกใช้งานแบบตรง ๆ เลยได้หรือไม่
ถ้าไม่ต้องการเปิดให้เรียกใช้งาน (private หรือ internal package)
หรือทำการประกาศเพิ่มเติมในไฟล์ package-info.java ได้
เป็นแนวทางในการจัดการตั้งแต่เริ่ม ดังนั้นการออกแบบสำคัญมาก ๆ
อย่าไปแก้ไขตอนเกิดปัญหา ควรป้องกันไว้ก่อนเสมอ

อีกรูปแบบหนึ่งที่น่าสนใจคือ Event-based นั่นเอง หรือ Application Events

ช่วยให้แต่ละ module ทั้งต้นทาง (producer) และปลายทาง (consumer)
ทำงานเป็นอิสะแก่กัน ลดการผูกมัดกันอย่างชัดเจน
แต่ก็เป็นการสร้างปัญหาใหม่ เพราะว่าจำเป็นต้องมีคนกลาง !!
เพื่อจัดเก็บ event เหล่านี้ไว้นั่นเอง

โดยใน Spring Modulith 2.0 สนับสนุนที่จัดเก็บ Event (Event Store) ดังนี้

• Spring Data JDBC
• Spring Data JPA
• Spring Data MoongoDB
• Spring Data Neo4j

และยังสนับสนุนพวก messaging ต่าง ๆ อีกด้วย (External event store)
แต่ต้อง configuration เพิ่มเข้ามาอีกหน่อย

• Kafka
• AMQP เช่น RabbitMQ
• JMS
• Spring Messaging

แสดงการทำงานดังรูป
แน่นอนว่าเราสามารถเลือกใช้งานได้เอง

เป็นอีกทางเลือกในการแก้ไขปัญหาที่น่าสนใจ
ลองศึกษาและเล่นดูได้ครับ

ขอให้สนุกกับการ coding

Article by Somkiat Puisungnoen

To be Craftmanship