๋ธ๋ฆฟ์ง ํจํด์ ์ถ์ํ ๊ณ์ธต(Abstraction)๊ณผ ๊ตฌํ ๊ณ์ธต(Implementor)๋ฅผ ๋ถ๋ฆฌํด์ ๋ ๋ฆฝ์ ์ผ๋ก ํ์ฅํ ์ ์๊ฒ ๋ง๋๋ ๊ตฌ์กฐ ํจํด์ด์์.
์ถ์ํ ๊ณ์ธต์ ๊ธฐ๋ฅ ํด๋์ค ๊ณ์ธต์ด๋ผ๊ณ ๋ณด๊ธฐ๋ ํด์. ๊ทธ๋์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๊ณ ์ถ์ผ๋ฉด ์ถ์ํ ๊ณ์ธต์, ๊ตฌํ์ ์ถ๊ฐํ๊ณ ์ถ์ผ๋ฉด ๊ตฌํ ๊ณ์ธต์ ํ์ฉํ๋ฉด ๋๋ ๋ ๋ฆฝ์ ์ผ๋ก ํ์ฅ์ด ๊ฐ๋ฅํ๊ฒ ๋๋ ๊ฑฐ์์.

Abstraction(์ถ์ํ ๊ณ์ธต, ๊ธฐ๋ฅ ๊ณ์ธต)๊ณผ Implementor(๊ตฌํ ๊ณ์ธต)์ ๋ถ๋ฆฌํ์ฌ ์ด์ด์ฃผ๋ ๊ตฌ์กฐ๊ฐ ๋๊ธฐ ๋๋ฌธ์ ๋ธ๋ฆฟ์ง ํจํด์ด์์. ๋ ๊ณ์ธต์ ์ง์ ๋ฌถ์ง ์๊ณ , ์ค๊ฐ์ ๋ค๋ฆฌ๋ฅผ ๋์ ์๋ก ๋ ๋ฆฝ์ ์ผ๋ก ๋ฐ์ ํ ์ ์๋๋ก ์ด์ ๊ฑฐ์์. ๊ทธ๋ฆผ์ ๊ฐ ์์์ ๋ํด ์ค๋ช ํด ๋ณผ๊ฒ์.
Abstraction (์ถ์ํ ๊ณ์ธต์ ์์ ์ญํ , ๊ธฐ๋ฅ ๊ณ์ธต์ ์์ ์ญํ )
์ญํ : Client๊ฐ ์ฌ์ฉํ๋ ์ถ์ ์ธํฐํ์ด์ค๋ก ๋ด๋ถ์ Implementor๋ฅผ ์ฐธ์กฐํ์ฌ ๊ตฌํ ์ผ๋ถ๋ฅผ ์์ํด์.
ํน์ง: ์ด๋ค Implementor๋ฅผ ์ฌ์ฉํ ์ง ๋ชจ๋ฅด์ง๋ง, ๋จ์ง ํธ์ถํ์ฌ ๊ธฐ๋ฅ์ ๋ง๋๋๋ฐ ์ฌ์ฉํด์.
์์: ๋ฆฌ๋ชจ์ปจ -> TV๊ฐ ์ผ์ฑ์ธ์ง LG์ธ์ง ๋ชจ๋ฅด์ง๋ง "์ ์ ํค๊ธฐ", "์ ์ ๋๊ธฐ"๊ฐ ๊ฐ๋ฅํด์.
RefinedAbstraction (์ถ์ํ ๊ณ์ธต์ ๊ตฌํ ํด๋์ค)
์ญํ : Abstraction์ ์ ์๋ operation()์ ์ค์ ๋ก ๊ตฌํ ๋ฐ ํ์ฅํด์. ์ฌ์ ํ Implementor๋ฅผ ์ฌ์ฉํด์ฌ ๊ตฌํํด์.
ํน์ง: Abstraction์ ์์๋ฐ๊ธฐ ๋๋ฌธ์ ๊ธฐ๋ฅ ๊ณ์ธต๊ณผ ์ฝํ ๊ฒฐํฉ์ ๊ฐ์ ธ์.
์์: LG ๋ฆฌ๋ชจ์ฝ, ์ข ํฉ ๋ฆฌ๋ชจ์ฝ ๋ฑ..
Implementor (๊ตฌํ ๊ณ์ธต์ ์ธํฐํ์ด์ค)
์ญํ : ์ค์ ๊ธฐ๋ฅ์ ๋ด๋นํ๋ ๊ตฌํ ๊ฐ์ฒด๋ค์ด ๋ฐ๋ผ์ผ ํ ์ธํฐํ์ด์ค๋ก ์ค์ ๊ตฌํ์ ConcreteImplementor์์ ํด์.
ํน์ง: RefinedAbstraction ๊ธฐ๋ฅ์ ์ํ api ์ ๊ณต ๋ฐ ๊ตฌํ ๋ก์ง์ ์ต์ ๊ธฐ์ค์ ์ ์ํด์.
์์: TV ๋ณธ์ฒด๋ก TV์ ์ ์ ์ผ๊ธฐ, ๋๊ธฐ ๋ฑ์ ํ ์ ์์ด์
ConcreteImplementor (๊ตฌํ ๊ณ์ธต์ ๊ตฌํ์ฒด)
์ญํ : Implementor๋ฅผ ๊ตฌ์ฒด์ ์ผ๋ก ๊ตฌํํ๋ ํด๋์ค๋ค์ด์์
ํน์ง: Abstraction์ ๋ชฐ๋ผ๋ Implementor๋ง ์๊ณ ์์๋ฐ์ ๊ตฌํํ๋ฉด ๋์.
์์: LG TV, ์ผ์ฑ TV
์ด์ ์งง๊ฒ ํ ์ด๋ธ๋ก ์์ฝํด ๋ณผ๊ฒ์
์์ | ์ญํ | ์ค๋ช |
|---|---|---|
Abstraction | ์ถ์ํ ๊ณ์ธต | ํด๋ผ์ด์ธํธ๊ฐ ์ฌ์ฉํ๋ ์์ ์ธํฐํ์ด์ค, ๊ตฌํ์ฒด์ ์์ |
RefinedAbstraction | ์ถ์ํ ํ์ฅ | Abstraction์ ํ์ฅํ ์ค์ ๊ธฐ๋ฅ ํด๋์ค |
Implementor | ๊ตฌํ ๊ณ์ธต์ ์ธํฐํ์ด์ค | ์ค์ ๊ธฐ๋ฅ์ ๋ด๋นํ๋ ๊ตฌํ์ฒด ์ธํฐํ์ด์ค |
ConcreteImplementorA/B | ๊ตฌํ์ฒด | Implementor๋ฅผ ์ค์ ๋ก ๊ตฌํํ๋ ํด๋์ค๋ค |
๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง์ผ๋ก ๋ธ๋ฆฟ์ง ํจํด์ ๋ํด ์ต๋ํ ์งง๊ฒ ์ ๋ฆฌํด ๋ณผ๊ฒ์.
์ ๋ฆฌ
๊ธฐ๋ฅ๊ณผ ๊ตฌํ์ ๋ถ๋ฆฌํ ํจํด์ผ๋ก Abstraction(๊ธฐ๋ฅ ๊ณ์ธต)์ Implementor(๊ตฌํ)์ ๊ตฌ์ฑ์ผ๋ก ๊ฐ๊ณ ๊ธฐ๋ฅ์๋ง๋๋๋ฐ ๊ตฌํ์ ์ฌ์ฉํ๋ค.
๊ธฐ๋ฅ์ ์ถ๊ฐํ๊ณ ์ถ์ผ๋ฉด Abstraction์ ์์๋ฐ๋ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐ, ๊ตฌํ์ Implementor๋ฅผ ์์๋ฐ๋ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐํ๋ฉด ๋๋ค.
๊ธฐ๋ฅ์ ๊ตฌํ ์ถ์ํด๋์ค๋ง ์๋ฉด ๋๊ณ , ๊ตฌํ์ฒด๋ ๊ธฐ๋ฅ์ ๋ชฐ๋ผ๋ ๋๋ค.
LG TV๋ฅผ ๊ตฌํ์ฒด๋ก ๋ดค์ง๋ง, ์ฌ์ค LG TV๋ Display๋ผ๋ ๊ธฐ๋ฅ์ด ์์ ๋, ์ด Display๋ฅผ ์ํ ๊ตฌํ์ Panel์๊ฒ ์์ํ ์ ์๋ค. ๊ทธ๋์ LG Panel, BOE ํจ๋, ์ผ์ฑ ํจ๋์ ์ฌ์ฉํ์ฌ LG TV๋ฅผ ๋ง๋ค ์ ์์ ๊ฒ์ด๋ค. ๊ทธ๋์ LG TV๋ ๋ค๋ฅธ ๊ด์ ์์ ์ธ์ ๋ ์ถ์ํ ๊ณ์ธต์ด ๋ ์ ์๋ค.
ํ์ฌ ์๋ฆผ ์์คํ ์ ๋ง๋ ๋ค๊ณ ํด๋ด์. ๊ทธ๋ฐ๋ฐ Email๋ก ์๋ฆผ, Slack์ผ๋ก ์๋ฆผ, SMS๋ก ์๋ฆผ ๋ฑ ์๋ฆผ์ ๋ณด๋ด์ผํ ๊ณณ์ด ์ ์ ๋ง์์ ธ์. ๊ทธ๋ฆฌ๊ณ ์๋ฆผ๋ ๊ธด๊ธ ์๋ฆผ, ์ผ๋ฐ ์๋ฆผ ๋ฑ ์๋ฆผ์ ์ข ๋ฅ๋ ๋ค์ํด์ ธ์. ์ด ์ํฉ์ ๋ธ๋ฆฟ์ง ํจํด์ ์ ์ฉํด ํ์ฅ์ฑ๊ณผ ์ฑ ์ ๋ถ๋ฆฌ๋ฅผ ํ๋ณดํด๋ด์.
interface NotificationChannel { sendMessage(message: string): void;}class EmailSender implements NotificationChannel { sendMessage(message: string) { console.log(`์ด๋ฉ์ผ ๋ฉ์์ง : ${message}`); }}class SlackSender implements NotificationChannel { sendMessage(message: string) { console.log(`์ฌ๋ ๋ฉ์์ง: ${message}`); }}abstract class Notification { protected sender: NotificationChannel ; constructor(sender: NotificationChannel ) { this.sender = sender; } abstract notify(message: string): void;}class NormalNotification extends Notification { notify(message: string) { this.sender.sendMessage(`[์ผ๋ฐ] ${message}`); }}class UrgentNotification extends Notification { notify(message: string) { this.sender.sendMessage(`[๊ธด๊ธ] ${message.toUpperCase()}`); }}// ์ด๋ฉ์ผ ๊ธด๊ธ ์๋ฆผconst emailUrgent = new UrgentNotification(new EmailSender());// ์ฌ๋ ๊ธด๊ธ ์๋ฆผconst slackUrgent = new UrgentNotification(new SlackSender());// ์ฌ๋ ์ผ๋ฐ ์๋ฆผconst slackNormal = new NormalNotification(new SlackSender());emailUrgent.notify("server down!"); // ์ด๋ฉ์ผ ๋ฉ์์ง: [๊ธด๊ธ] SERVER DOWN!slackNormal.notify("daily report ready");// ์ฌ๋ ๋ฉ์์ง: [์ผ๋ฐ] daily report ready์์ ๊ฐ์ด ๋ธ๋ฆฟ์ง ํจํด์ผ๋ก ์ค๊ณํ๋ฉด ์ธ์ ๋ ์ผ๋ฐ ์๋ฆผ๋ ์ด๋ฉ์ผ๋ก ๋ณด๋ผ ์ ์๊ฒ ์ฃ ? ๊ทธ๋ฆฌ๊ณ ์ ์ก ์ฑ๋๋ก ์ ํ ์๋ฆผ์ด ์๊ฒจ๋ฉด ์๋ก์ด ์ฑ๋์ ์ถ๊ฐํ๋ฉด ๋์. ๊ทธ๋ฆฌ๊ณ ๊ธด๊ธ/์ผ๋ฐ์ ๋ํด์ ํ์ฌ ์๋ฆผ์ด ์ถ๊ฐ๋๋ฉด ์๋ฆผ ์ข ๋ฅ๋ง ์ถ๊ฐํ๋ฉด ๋๊ณ ์. ๋ ์ฌ์ด์ ์ฐ๊ฒฐ๊ณ ๋ฆฌ๋ ์ ์ก ์ฑ๋ ์ธํฐํ์ด์ค๋ฅผ ์๋ฆผ ์ข ๋ฅ๊ฐ ๊ตฌ์ฑ์ผ๋ก ์ฌ์ฉํ๊ณ ์์ด์ ์๊ธด๋ค๋ ๊ฒ์ ํตํด ์ ์ดํดํ์ จ์ผ๋ฉด ์ข๊ฒ ์ด์.
๋ธ๋ฆฟ์ง ํจํด์ ์ฐ๋ฉด ๋ณต์กํ ์กฐํฉ (n๊ฐ์ ์๋ฆผ, m๊ฐ์ ์ ์ก ์ฑ๋)์ ์ธ์ ๋ ๋ง๋ค์ด ์ฌ์ฉํ ์ ์์ด์. n๊ฐ์ ์๋ฆผ์ m๊ฐ์ ์ ์ก์ฑ๋์ด ์์ผ๋ฉด n * m๊ฐ์ ์กฐํฉ์ ๋ง๋ค ์ ์์ด์. ๊ทธ๋ฆฌ๊ณ ์ธ์ ๋ ์๋ฆผ๊ณผ ์ ์ก ์ฑ๋์ ์ถ๊ฐํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ ๋ฆฝ์ ์ธ ํ์ฅ์ฑ์ ๋ณด์ฅํด์.
์ด ํจํด์ ์ฌ์ค ์๊ฒ๋ชจ๋ฅด๊ฒ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค๊ณ ์๊ฐํด์. ์๋ฅผ ๋ค๋ฉด ๊ฒ์ ์บ๋ฆญํฐ๊ฐ ๊ณต๊ฒฉ์ ํ๋ ์ฝ๋๋ฅผ ๋ง๋ ๋ค๊ณ ํด๋ด์. ๊ทธ๋ฐ๋ฐ ๊ณต๊ฒฉ์ด ์ด๋ค ๋ฌด๊ธฐ๋ฅผ ์ฐ๋๋์ ๋ฐ๋ผ ๋ชจ์ ์ด ๋ฌ๋ผ์ง ์ ์์ด์. ๊ทธ๋ฌ๋ฉด "์บ๋ฆญํฐ = Abstraction, ๋ฌด๊ธฐ = Implementor, ๊ณต๊ฒฉ ๋ชจ์ = Attack Strategy"๋ก ๊ตฌ์ฑํด์ ์ฌ์ฉํ ์ ์์ ๊ฒ ๊ฐ์์. ์บ๋ฆญํฐ์ ๊ณต๊ฒฉ ๊ธฐ๋ฅ์ ๋ฌด๊ธฐ์ attack ๊ตฌํ์ ์ฌ์ฉํ๊ณ ์, ๋ฌด๊ธฐ๋ง๋ค์ attack ๊ตฌํ์ Attack Strategy์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ ์ฉ๋๊ฒํ ์ ์์ ๊ฒ ๊ฐ์์. ์ด๋ฌ๋ฉด ์บ๋ฆญํฐ n๊ฐ์ ๋ฌด๊ธฐ m๊ฐ๊ฐ ์์ผ๋ฉด n*m๊ฐ์ ์กฐํฉ์ด ๊ฐ๋ฅํ๊ฒ ์ฃ ?
์๋ฌดํผ ๋ธ๋ฆฟ์ง ํจํด์ ๋ฏธ๋์ ๊ตฌ์กฐ์ ๋ฌธ์ (์กฐํฉ์ ํญ๋ฐ์ ์ฆ๊ฐ) ํน์ ๋ง์ ํ์ฅ์ด ์์ ๋์ด ์์ ๋ ์ฌ์ฉํ๋ฉด ์ข์ ๊ฒ ๊ฐ์์. ๊ฒ์ ์บ๋ฆญํฐ์ ๋ฌด๊ธฐ๊ฐ ๋ฑ ์ด ๊ตฌ์กฐ์ ์๋ง๋ค๊ณ ์๊ฐํด์ ์์๋ฅผ ๋ค์ด๋ดค์ด์.