๐ก ์ปดํฌ์งํธ(๋ณตํฉ์ฒด) ํจํด์ด๋?
๊ฐ์ฒด๋ค์ ํธ๋ฆฌ ๊ตฌ์กฐ๋ค๋ก ๊ตฌ์ฑํ ํ, ์ด๋ฌํ ๊ตฌ์กฐ๋ค์ ๊ฐ๋ณ ๊ฐ์ฒด๋ค์ฒ๋ผ ์์ ํ ์ ์๋๋ก ํ๋ ๊ตฌ์กฐ ํจํด์ ๋๋ค. ์ฆ, ๋ณตํฉ ๊ฐ์ฒด(Composite)์ ๋จ์ผ ๊ฐ์ฒด(Leaf)๋ฅผ ๋์ผํ ์ปดํฌ๋ํธ๋ก ์ทจ๊ธํ์ฌ ํด๋ผ์ด์ธํธ๊ฐ ๋ฌด์์ด ๋ณตํฉ ๊ฐ์ฒด์ด๊ณ ๋ฌด์์ด ๋จ์ผ ๊ฐ์ฒด์ธ์ง ๊ตฌ๋ถํ์ง ์๊ณ ๋ ์ฌ์ฉํ ์ ์๊ฒ๋ ํ๋ ํจํด์ ๋๋ค.
๐ก ํด๋์ค ๋ค์ด์ด๊ทธ๋จ์ผ๋ก ๋ณธ ์ปดํฌ์งํธ ํจํด
- Component(์ธํฐํ์ด์ค) : Leaf์ Compsite ๋ฅผ ๋ฌถ๋ ๊ณตํต์ ์ธ ์์ ์ธํฐํ์ด์ค
- Composite : ๋ณตํฉ ๊ฐ์ฒด๋ก์, Component ๊ตฌํ์ฒด๋ค์ ๋ด๋ถ ๋ฆฌ์คํธ๋ก ๊ด๋ฆฌ
- Leaf : ๋จ์ผ ๊ฐ์ฒด๋ก์, ํ์ ์์๊ฐ ์๋ค.
- Client : Component Interface๋ฅผ ํตํด ๋จ์ผ/๋ณตํฉ ๊ฐ์ฒด๋ฅผ ํ๋์ ๊ฐ์ฒด๋ก ๋ค๋ฃฌ๋ค.
๋ณตํฉ์ฒด ํจํด์ ํต์ฌ์ Composite ์ Leaf๊ฐ ๋์์ ๊ตฌํํ๋ operation() ์ธํฐํ์ด์ค ์ถ์ ๋ฉ์๋๋ฅผ ์ ์ํ๊ณ , Composite ๊ฐ์ฒด์ operation() ๋ฉ์๋๋ ์๊ธฐ ์์ ์ ํธ์ถํ๋ ์ฌ๊ท ํํ๋ก ๊ตฌํํ๋ ๊ฒ์ด๋ค. ์๋ํ๋ฉด ํด๋ ์์ ํด๋๋ฅผ ๋ฃ๊ณ , ๊ทธ ์์ ๋ ํด๋๋ฅผ ๋ฃ๊ณ ํ์ผ์ ๋ฃ๋ ํธ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์๊ฐํด๋ณด๋ฉด, ์ฌ๊ท์ ์ผ๋ก ๋ฐ๋ณต๋๋ ํ์์ด ๋ํ๋๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋์ ๋จ์ผ์ฒด์ ๋ณตํฉ์ฒด๋ฅผ ๋์ผํ ๊ฐ์ฒด๋ก ์ทจ๊ธํ์ฌ ์ฒ๋ฆฌํ๊ธฐ ์ํด ์ฌ๊ท ํจ์ ์๋ฆฌ๋ฅผ ์ด์ฉํ๋ค.
๐ก ์ปดํฌ์งํธ ํจํด ๊ตฌํ
interface Component {
void operation();
}
class Leaf implements Component {
@Override
public void operation() {
System.out.println(this + " ํธ์ถ");
}
}
class Composite implements Component {
// Leaf ์ Composite ๊ฐ์ฒด ๋ชจ๋๋ฅผ ์ ์ฅํ์ฌ ๊ด๋ฆฌํ๋ ๋ด๋ถ ๋ฆฌ์คํธ
List<Component> components = new ArrayList<>();
public void add(Component c) {
components.add(c); // ๋ฆฌ์คํธ ์ถ๊ฐ
}
public void remove(Component c) {
components.remove(c); // ๋ฆฌ์คํธ ์ญ์
}
@Override
public void operation() {
System.out.println(this + " ํธ์ถ");
// ๋ด๋ถ ๋ฆฌ์คํธ๋ฅผ ์ํํ์ฌ, ๋จ์ผ Leaf์ด๋ฉด ๊ฐ์ ์ถ๋ ฅํ๊ณ ,
// ๋๋ค๋ฅธ ์๋ธ ๋ณตํฉ ๊ฐ์ฒด์ด๋ฉด, ๋ค์ ๊ทธ ๋ด๋ถ๋ฅผ ์ํํ๋ ์ฌ๊ท ํจ์ ๋์์ด ๋๋ค.
for (Component component : components) {
component.operation(); // ์๊ธฐ ์์ ์ ํธ์ถ(์ฌ๊ท)
}
}
public List<Component> getChild() {
return components;
}
}
class Client {
public static void main(String[] args) {
// 1. ์ต์์ ๋ณตํฉ์ฒด ์์ฑ
Composite composite1 = new Composite();
// 2. ์ต์์ ๋ณตํฉ์ฒด์ ์ ์ฅํ Leaf์ ๋๋ค๋ฅธ ์๋ธ ๋ณตํฉ์ฒด ์์ฑ
Leaf leaf1 = new Leaf();
Composite composite2 = new Composite();
// 3. ์ต์์ ๋ณตํฉ์ฒด์ ๊ฐ์ฒด๋ค์ ๋ฑ๋ก
composite1.add(leaf1);
composite1.add(composite2);
// 4. ์๋ธ ๋ณตํฉ์ฒด์ ์ ์ฅํ Leaf ์์ฑ
Leaf leaf2 = new Leaf();
Leaf leaf3 = new Leaf();
Leaf leaf4 = new Leaf();
// 5. ์๋ธ ๋ณตํฉ์ฒด์ ๊ฐ์ฒด๋ค์ ๋ฑ๋ก
composite2.add(leaf2);
composite2.add(leaf3);
composite2.add(leaf4);
// 6. ์ต์์ ๋ณตํฉ์ฒด์ ๋ชจ๋ ์์ ๋
ธ๋๋ค์ ์ถ๋ ฅ
composite1.operation();
}
}
์ถ์ฒ: <https://inpa.tistory.com/entry/GOF-๐ -๋ณตํฉ์ฒดComposite-ํจํด-์๋ฒฝ-๋ง์คํฐํ๊ธฐ#composite_pattern> [Inpa Dev ๐จ๐ป:ํฐ์คํ ๋ฆฌ]
๐ก ๋ง๋ฌด๋ฆฌ
์ปดํฌ์งํธ ํจํด์
- ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ๋ ๊ณ์ธต์ ํธ๋ฆฌ ํํ์ ๋ค๋ฃจ์ด์ผ ํ ๋
- ๋ณต์กํ๊ณ ๋ํดํ ๋จ์ผ / ๋ณตํฉ ๊ฐ์ฒด ๊ด๊ณ๋ฅผ ๊ฐํธํ ๋จ์ํํ์ฌ ๊ท ์ผํ๊ฒ ์ฒ๋ฆฌํ๊ณ ์ถ์๋
์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๋ณต์กํ ๊ตฌ์กฐ๋ฅผ ๋ณด๋ค ํธ๋ฆฌํ๊ฒ ๊ตฌ์ฑํ ์ ์๊ณ , ์๋ก์ด Leaf ํด๋์ค๋ฅผ ์ถ๊ฐํ๋๋ผ๋ ํด๋ผ์ด์ธํธ๋ ์ถ์ํ๋ ์ธํฐํ์ด์ค๋ง์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ OCP๋ฅผ ์ค์ํฉ๋๋ค. ๊ทธ๋ฌ๋, ๊ณตํต ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํ๋ ๊ฒ์ด ๊น๋ค๋ก์ธ ์ ์์ต๋๋ค.