๐ก ์ด๋ํฐ ํจํด (Adapter Pattern)
ํ ํด๋์ค์ ์ธํฐํ์ด์ค๋ฅผ ํด๋ผ์ด์ธํธ์์ ์ฌ์ฉํ๊ณ ์ํ๋ ๋ค๋ฅธ ์ธํฐํ์ด์ค๋ก ๋ณํํ๋ค. ์ด๋ํฐ๋ฅผ ์ด์ฉํ๋ฉด ์ธํฐ
ํ์ด์ค ํธํ์ฑ ๋ฌธ์ ๋๋ฌธ์ ๊ฐ์ด ์ธ ์ ์๋ ํด๋์ค๋ค์ ์ฐ๊ฒฐํด์ ์ธ ์ ์๋ค.
Wrapper
ํด๋์ค๊ฐ ๋ค๋ฅธ ์ธํฐํ์ด์ค๋ฅผ ๊ฐ์ง๋๋ผ๋ ๊ฐ์ด ์ด์ฉํ ์ ์๊ฒ ๋ํ ํด๋์ค๋ฅผ ๋ง๋๋ ๊ฒ.
์ ๊ธฐ ์ฝ์ผํธ๋ฅผ ์๊ฐํ๋ฉด ์ดํดํ๊ธฐ ์ฝ๋ค.
ํธํ๋์ง ์๋ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ ํด๋ผ์ด์ธํธ๋ฅผ ๊ทธ๋๋ก ํ์ฉํ ์ ์๋ค. Wrapper ๋ก ์ด์ฉํจ์ผ๋ก์ ํด๋ผ์ด์ธํธ์ ๊ตฌํ๋ ์ธํฐํ์ด์ค๋ฅผ ๋ถ๋ฆฌ์ํฌ ์ ์์ผ๋ฉฐ, ํฅํ ์ธํฐํ์ด์ค๊ฐ ๋ฐ๋๋๋ผ๋ ์ด๋ํฐ์ ์บก์ํ๋๊ธฐ ๋๋ฌธ์ ํด๋ผ์ด์ธํธ๋ ๋ฐ๊ฟ ํ์๊ฐ ์์ด์ง๋ค.
โ ์์ : ์ค๋ฆฌ ์ดํ๋ฆฌ์ผ์ด์ ์ ์น ๋ฉด์กฐ ์ถ๊ฐํ๊ธฐ
์๊ตฌ์ฌํญ
์ค๋ฆฌ ์ดํ๋ฆฌ์ผ์ด์ ์ ํ์ฌ ์์คํ ์๋ Duck ์ธํฐํ์ด์ค์ ์ด๋ฅผ ๊ตฌํํ ๊ฐ ์ค๋ฆฌ ํด๋์ค๋ค์ด ์กด์ฌํ๋ค. ์ด ์ดํ๋ฆฌ์ผ์ด์ ์ ๊ณ ๊ฐ์ฌ๋ก๋ถํฐ Turkey ๋ฅผ ์ ๊ณต๋ฐ์ ์ถ๊ฐํด๋ฌ๋ผ๋ ์์ฒญ์ ๋ฐ์๋ค. Duck ๋ง์ด ์กด์ฌํ๋ ํ์ฌ์ ์์คํ ์ Turkey ๋ฅผ ์ถ๊ฐํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น? Turkey๋ฅผ Duck์์ ์ฌ์ฉํ ์ ์๋๋ก ์ค๊ฐ์ Duck ์ ๋ง์ถฐ์ ๋ณํํด์ฃผ๋ ์ด๋ํฐ๊ฐ ์์ผ๋ฉด ๋์ง ์์๊น? ๋ง์น 220v ๋ฅผ 110v ๋ก ๋ณํํด์ฃผ๋ ์ด๋ํฐ ์ฒ๋ผ ๋ง์ด๋ค.
1. ๊ธฐ์กด์ Duck ์ธํฐํ์ด์ค
public interface Duck {
public void quack();
public void fly();
}
2. Duck ๋ฅผ ๊ตฌํํ MallardDuck ํด๋์ค
public class MallardDuck implements Duck {
public void quack() {
System.out.println("MallardDuck ๊ฝฅ");
}
public void fly() {
System.out.println("MallardDuck ๋ ๊ณ ์์ด์~");
}
}
3. ์ ์ฒด๋ก๋ถํฐ Turkey ๋ฅผ ์ ๊ณต๋ฐ์๋ค.
public interface Turkey {
public void gobble();
public void fly();
}
// Turkey ๋ฅผ ๊ตฌํํ WildTurkey ํด๋์ค
public class WildTurkey implements Turkey {
public void gobble() {
System.out.println("์น ๋ฉด์กฐ gobble gobble~");
}
public void fly() {
System.out.println("์น ๋ฉด์กฐ๋ ์งง์ ๊ฑฐ๋ฆฌ๋ง ๋ ์ ์์ด์");
}
}
4. ์ ์ฒด๋ก ๋ถํฐ ๋ฐ์ Turkey ๋ฅผ ๊ธฐ์กด ๋์ ์์คํ Duck ์ ์ฌ์ฉํด์ผํ๋ค. Duck์ผ๋ก ๋ณํํด์ค ์ด๋ํฐ๋ฅผ ๋ง๋ค์.
public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey){
this.turkey = turkey;
}
@Override
public void quack() {
turkey.gobble();
}
@Override
public void fly() {
for(int i=0; i < 3; i++) {
turkey.fly();
}
}
}
5. ์คํํด๋ณด์.
@Test
void duck() {
MallardDuck duck = new MallardDuck();
// Turkey ๋ฅผ ์์ฑ
WildTurkey turkey = new WildTurkey();
// ์์ฑํ Turkey ๋ฅผ ์ด๋ํฐ๋ฅผ ํตํ์ฌ Duck ์ ์ด์ฉํ๋๋ก ๋ณํ
Duck turkeyAdapter = new TurkeyAdapter(turkey);
System.out.println("The WildTurkey says...");
turkey.gobble(); // ์น ๋ฉด์กฐ gobble gobble~
turkey.fly(); // ์น ๋ฉด์กฐ๋ ์งง์ ๊ฑฐ๋ฆฌ๋ง ๋ ์ ์์ด์
System.out.println("The MallardDuck says...");
testDuck(duck);
System.out.println("The TurkeyAdapter says...");
testDuck(turkeyAdapter);
// → ์ด๋ํฐ๊ฐ gobble ํ ๋ fly()๋ฅผ ์ฌ๋ฌ๋ฒ ํธ์ถํ๋๋ก ๊ตฌํํ๋ค.
// testDuck()๋ turkey ๊ฐ duck ์ผ๋ก ์จ๊ฒจ์ ธ์๋์ง ๋ชจ๋ฅธ๋ค!
}
static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
6. ๊ฒฐ๊ณผํ์ธ
The WildTurkey says...
์น ๋ฉด์กฐ gobble gobble~
์น ๋ฉด์กฐ๋ ์งง์ ๊ฑฐ๋ฆฌ๋ง ๋ ์ ์์ด์
The MallardDuck says...
MallardDuck ๊ฝฅ
MallardDuck ๋ ๊ณ ์์ด์~
The TurkeyAdapter says...
์น ๋ฉด์กฐ gobble gobble~
์น ๋ฉด์กฐ๋ ์งง์ ๊ฑฐ๋ฆฌ๋ง ๋ ์ ์์ด์
์น ๋ฉด์กฐ๋ ์งง์ ๊ฑฐ๋ฆฌ๋ง ๋ ์ ์์ด์
์น ๋ฉด์กฐ๋ ์งง์ ๊ฑฐ๋ฆฌ๋ง ๋ ์ ์์ด์
โ ํด๋ผ์ด์ธํธ์์ ์ด๋ํฐ ์ฌ์ฉ
- ํด๋ผ์ด์ธํธ์์ ํ๊ฒ ์ธํฐํ์ด์ค (Adapter) ๋ฅผ ์ฌ์ฉํ์ฌ request() ๋ฉ์๋๋ฅผ ํธ์ถ ํ๋ค.
- ์ด๋ํฐ์์ ์ด๋ํฐ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ์ฌ ์์ฒญ request() ์ ์ด๋ํฐ์๋ํ ์์ฒญ translatedRequst() ์ผ๋ก ๋ณํํ๋ค.
- ํด๋ผ์ด์ธํธ์์๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ง๋ง, ์ค๊ฐ์ ์ด๋ํฐ๊ฐ ์๋์ง ์์ง ๋ชปํ๋ค.
โ UML Diagram
โ ์ด๋ํฐ์๋ ๋๊ฐ์ง ์ข ๋ฅ๊ฐ ์๋ค.
(1) ํด๋์ค ์ด๋ํฐ (Class Adapter)
(2) ์ค๋ธ์ ํธ ์ด๋ํฐ (Object Adapter)
์ฐธ๊ณ
ํค๋ ํผ์คํธ ๋์์ธ ํจํด (Head First Design Patterns) - ์๋ฆญ ํ๋ฆฌ๋จผ,์๋ฆฌ์๋ฒ ์ค ๋กญ์จ,์ผ์ด์ ์์๋ผ,๋ฒํธ ๋ฒ ์ด์ธ