เห็นผ่าน ๆ ว่ามีการพูดถึงความแตกต่างของ Observer pattern และ Publish-Subscribe pattern ว่าเป็นอย่างไร ?
เป็นคำถามที่น่าสนใจมาก ๆ
แต่ก่อนที่จะคุยกันว่า มันต่างกันอย่างไร
ควรที่จะรู้ก่อนไหมว่า แต่ละตัวมันคืออะไร ?
ดังนั้นมาดูกันหน่อยสิ

เริ่มด้วยข้อมูลที่ Wikipedia กันเลย
ถ้าตั้งใจหาและอ่านจะเจอแน่ ๆ ดังนี้

Observer pattern

The observer pattern is a software design pattern in which an object, called the subject,
maintains a list of its dependents, called observers,
and notifies them automatically of any state changes,
usually by calling one of their methods.

นั่นหมายความว่า
ใน Observer pattern จะมีการทำงาน 2 ส่วนคือ subject กับ observer
โดยที่ subject จะมีรายชื่อของ depedency หรือ observer ไว้
จากนั้นเมื่อมีการเปลี่ยนแปลงที่ subject จะแจ้งไปยัง observer ทั้งหมดที่ดูแลหรือผูกไว้
จะใช้ในระบบที่จัดการกับ event หรือเหตุการณ์ต่าง ๆ แบบ synchronous
ยกตัวอย่างเช่น เมื่อเกิดการเปลี่ยนแปลงหรือเหตุการณ์ที่หน้าจอผู้ใช้งานแล้ว
จะทำการแจ้งไปยัง observer ที่ผูกไว้ทั้งหมดทันที (ด้วยการเรียก method เช่น notify() หรือ notifyAll() เป็นต้น)
เป็น pattern ที่ถูกใช้บ่อยอย่างมาก

แต่เนื่องจากทาง Subject ต้องผูกมัดกับ Observer ไว้ก่อน
ดังนั้นอาจจะทำให้เกิด memory leak ได้
เพราะว่าถ้าผูกมัดแล้วไม่มีการคืนหรือแก้การผูกมัดนั่นเอง บางทีเราเรียกว่า Storng reference
นั่นคือสิ่งที่เราต้องแก้ไขให้เป็น weak reference

Publish-subscribe pattern

publish–subscribe is a messaging pattern where senders is messages, called publishers,
do not program the messages to be sent directly to specific receivers, called subscribers,
but instead categorize published messages into classes without knowledge of which subscribers

นั่นหมายความว่า
ใน Publish-subscribe pattern นั้นจะมีการทำงาน 3 ส่วนคือ Publisher, Subscriber และคนกลาง
โดยที่ Publisher คือผู้ส่ง message ต่าง ๆ
คำถามคือส่งไปที่ไหน ?
ตอบง่าย ๆ ไปที่คนกลางไงล่ะ !!
คนกลางคือ Subscriber ใช่ไหม ?
ตอบว่า ไม่ใช่ แต่เป็นส่วนที่ไว้รับ message ต่าง ๆ เช่น Broker, Message broker หรือพวก Event bus , Queue messaging หรือ Middleware
จะเยอะไปไหน งงไปหมด !!

มาถึงส่วน Subscriber กันบ้าง
แน่นอนว่า Publisher นั้นจะไม่รู้จักกับ Subscriber เลย
คำถามคือ แล้ว Subscriber จะไปเอา message จากไหนมาทำงาน ?
คำตอบคือ ก็ไปขอข้อมูลจากคนกลางไงละ
นั่นหมายความว่า คนกลางจะมีช่องทางให้ไปลงทะเบียนว่า Subscriber แต่ละตัวอยากจะทำงานกับอะไร ก็ไปลงทะเบียนไว้
เมื่อมี message หรือ event เข้ามาก็นำไปทำงานได้เลย

ดังนั้นทั้ง Publisher และ Subscriber จึงไม่ต้องรู้จักกันเลย
หรือพูดได้ว่าไม่ได้ผูกมัดกันเลยหรือแบบหลวม ๆ (Loose coupling)
ส่วนคนกลางก็มีบทบาทสำคัญมาก ๆ
ทั้งรับ message/event เข้ามาจากทาง Publisher
และคอยให้ทาง Subscriber มาลงทะเบียน
ซึ่ง pattern นี้ถูกใช้งานในระบบแบบกระจายอย่างมาก
ที่สำคัญยังสามารถ scale ได้ง่ายอีกด้วย เช่นการเพิ่ม Subsciber เข้าไป
แต่สิ่งที่ต้องพึงระวังให้มาก ๆ คือ คนกลางนั่นเอง
ถ้าล่มหรือทำงานไม่เสถียรจะส่งผลร้ายแรงต่อระบบงานมาก ๆ

มาถึงตรงนี้น่าจะพอทำให้เห็นว่า ทั้งสอง pattern ต่างกันอย่างไรแล้วหรือไม่ ?

Reference Websites
https://hackernoon.com/observer-vs-pub-sub-pattern-50d3b27f838c
https://medium.com/@huytrongnguyen1985/from-pub-sub-pattern-to-observer-pattern-f4ae1e425cc9
https://www.quora.com/What-is-the-difference-between-observer-and-pub-sub-pattern