Structural design pattern คืออะไร?

Question

Accepted Answer

**Structural pattern** จัดการเรื่องวิธีที่**อ็อบเจ็กต์และคลาสถูกประกอบ**เข้าด้วยกันเป็นโครงสร้างที่ใหญ่ขึ้น โดยจัดระเบียบความสัมพันธ์ระหว่างเอนทิตีเพื่อสร้างโครงสร้างที่ยืดหยุ่นและมีประสิทธิภาพ ซึ่งรวมถึง Adapter, Decorator, Facade, Proxy, Composite และ Bridge

## Structural pattern ตอบโจทย์อะไร

```text
STRUCTURAL patterns concern how objects/classes are COMPOSED/related:
  → organize relationships to build larger structures from objects
  → make components work together flexibly; simplify complex structures
→ about COMPOSITION and structure, not creation or behavior
```

## Structural pattern หลัก ๆ

```text
ADAPTER → make incompatible interfaces work together (wrap to convert one interface to
  another) — "a translator"
DECORATOR → add behavior by wrapping objects (covered separately)
FACADE → provide a SIMPLE interface to a complex subsystem (hide complexity behind one
  clean interface)
PROXY → a placeholder/surrogate controlling access to another object (lazy loading,
  access control, caching, remote)
COMPOSITE → treat individual objects and groups of objects UNIFORMLY (tree structures)
BRIDGE → separate an abstraction from its implementation (vary independently)
```

## ตัวที่พบบ่อยและใช้งานได้จริง

```text
✓ ADAPTER → integrate incompatible code/libraries (very common — make A work with B)
✓ FACADE → simplify a complex API/subsystem behind one easy interface (common, practical)
✓ PROXY → control access (lazy init, caching, security, remote proxies)
✓ COMPOSITE → tree-like structures (file systems, UI component trees, org charts)
→ use the one that fits the structural/composition problem
```

## ทำไมจึงสำคัญ

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

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

การเข้าใจ**structural pattern หลัก ๆ** ได้แก่ **Adapter** (ทำให้ interface ที่เข้ากันไม่ได้ทำงานร่วมกันได้ เหมือนตัวแปลภาษา), **Decorator** (เพิ่มพฤติกรรมด้วยการห่อหุ้ม), **Facade** (ให้ interface ที่เรียบง่ายไปยัง subsystem ที่ซับซ้อน), **Proxy** (ควบคุมการเข้าถึงอ็อบเจ็กต์), **Composite** (จัดการอ็อบเจ็กต์เดี่ยวและกลุ่มอย่างเป็นแบบเดียวกันในโครงสร้างต้นไม้) และ **Bridge** (แยก abstraction ออกจาก implementation) ครอบคลุมชุดเครื่องมือสำหรับการประกอบอ็อบเจ็กต์

การเข้าใจ**ตัวที่พบบ่อยและใช้งานได้จริง**มีคุณค่าเป็นพิเศษ ได้แก่ **Adapter** (การรวม integrate โค้ดหรือ library ที่เข้ากันไม่ได้ ซึ่งเป็นความต้องการจริงที่พบบ่อยมาก คือการทำให้ component หนึ่งทำงานกับอีกตัวได้), **Facade** (การทำให้ API หรือ subsystem ที่ซับซ้อนเรียบง่ายขึ้นหลัง interface ที่ใช้ง่ายตัวเดียว ซึ่งใช้งานได้จริงสำหรับการซ่อนความซับซ้อน), **Proxy** (การควบคุมการเข้าถึงสำหรับ lazy loading, caching, security หรือการเข้าถึงระยะไกล) และ **Composite** (การจำลองโครงสร้างแบบต้นไม้อย่าง file system, UI component tree และ org chart)

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

การเข้าใจ structural pattern ในฐานะหมวดหมู่หนึ่งและวิธีที่แต่ละตัวตอบโจทย์สถานการณ์การประกอบที่แตกต่างกัน ช่วยให้คุณจัดระเบียบอ็อบเจ็กต์เป็นโครงสร้างที่ยืดหยุ่นและดูแลรักษาง่าย

เนื่องจากการประกอบอ็อบเจ็กต์เป็นโครงสร้างที่ยืดหยุ่นเป็นความกังวลด้านการออกแบบที่พบบ่อย และ structural pattern ตอบโจทย์มัน (Adapter สำหรับความเข้ากันได้, Facade สำหรับการทำให้เรียบง่าย, Proxy สำหรับการควบคุมการเข้าถึง, Composite สำหรับลำดับชั้น) และเนื่องจากการเข้าใจ pattern และตัวที่พบบ่อยที่ใช้งานได้จริงมีประโยชน์ต่อการจัดระเบียบโค้ด การเข้าใจ structural pattern จึงเป็นความรู้การออกแบบที่มีคุณค่าและเกี่ยวข้องในเชิงปฏิบัติ เป็นหมวดหมู่ของ pattern ที่มีประโยชน์สำหรับการประกอบอ็อบเจ็กต์เป็นโครงสร้างที่ยืดหยุ่น โดย Adapter, Facade, Proxy และ Composite มีประโยชน์เป็นพิเศษสำหรับปัญหาจริงที่พบบ่อย และเป็นความรู้การออกแบบที่สำคัญสำหรับการจัดโครงสร้างโค้ดให้ดี