🔌 어댑터 패턴 (Adapter Pattern): 호환되지 않는 인터페이스를 연결하는 마법

🤔 어댑터 패턴이란?

어댑터 패턴은 호환되지 않는 인터페이스를 가진 클래스들을 함께 작동할 수 있도록 하는 구조적 디자인 패턴입니다. 마치 여행할 때 사용하는 전원 어댑터처럼, 서로 다른 규격의 시스템들을 연결해주는 역할을 합니다.

🎯 주요 특징

• 기존 코드 수정 없이 새로운 인터페이스와 통합
• 레거시 시스템과 새로운 시스템 간의 브릿지 역할
• 의존성 역전 원칙을 따르는 깔끔한 설계

---

🌊 Java 예제: 바다 생물 어댑터

바다의 다양한 생물들이 서로 다른 방식으로 움직이지만, 공통된 인터페이스를 통해 관리하는 예제입니다.

// 🐠 기존 물고기 인터페이스
interface Fish {
    void swim();
}

// 🦈 상어 클래스
class Shark implements Fish {
    @Override
    public void swim() {
        System.out.println("🦈 상어가 빠르게 수영합니다!");
    }
}

// 🐙 문어 클래스 (다른 인터페이스)
class Octopus {
    public void crawl() {
        System.out.println("🐙 문어가 바닥을 기어다닙니다!");
    }
}

// 🔧 문어 어댑터
class OctopusAdapter implements Fish {
    private Octopus octopus;
    
    public OctopusAdapter(Octopus octopus) {
        this.octopus = octopus;
    }
    
    @Override
    public void swim() {
        // 문어의 crawl을 swim으로 변환
        octopus.crawl();
        System.out.println("💫 문어가 수영하듯 이동합니다!");
    }
}

// 🌊 바다 생태계 관리자
class OceanManager {
    private List<Fish> marineLife = new ArrayList<>();
    
    public void addFish(Fish fish) {
        marineLife.add(fish);
    }
    
    public void makeAllSwim() {
        System.out.println("🌊 바다 생물들이 움직입니다:");
        marineLife.forEach(Fish::swim);
    }
}

// 사용 예제
public class AdapterPatternExample {
    public static void main(String[] args) {
        OceanManager ocean = new OceanManager();
        
        // 일반 물고기 추가
        ocean.addFish(new Shark());
        
        // 문어를 어댑터로 감싸서 추가
        Octopus octopus = new Octopus();
        ocean.addFish(new OctopusAdapter(octopus));
        
        ocean.makeAllSwim();
    }
}

---

☁️ TypeScript 예제: 하늘의 날개 어댑터

하늘을 나는 다양한 생물들의 비행 방식을 통합하는 예제입니다.

// ✈️ 기존 비행 인터페이스
interface Flyer {
    fly(): void;
}

// 🦅 독수리 클래스
class Eagle implements Flyer {
    fly(): void {
        console.log("🦅 독수리가 날개를 펼치고 비행합니다!");
    }
}

// 🚁 헬리콥터 클래스 (다른 인터페이스)
class Helicopter {
    rotate(): void {
        console.log("🚁 헬리콥터가 로터를 회전시킵니다!");
    }
}

// 🔧 헬리콥터 어댑터
class HelicopterAdapter implements Flyer {
    private helicopter: Helicopter;
    
    constructor(helicopter: Helicopter) {
        this.helicopter = helicopter;
    }
    
    fly(): void {
        // 헬리콥터의 rotate를 fly로 변환
        this.helicopter.rotate();
        console.log("💫 헬리콥터가 하늘을 날아갑니다!");
    }
}

// 🎈 기구 클래스 (또 다른 인터페이스)
class Balloon {
    float(): void {
        console.log("🎈 기구가 공중에 떠오릅니다!");
    }
}

// 🔧 기구 어댑터
class BalloonAdapter implements Flyer {
    private balloon: Balloon;
    
    constructor(balloon: Balloon) {
        this.balloon = balloon;
    }
    
    fly(): void {
        // 기구의 float을 fly로 변환
        this.balloon.float();
        console.log("💫 기구가 하늘을 날아갑니다!");
    }
}

// ☁️ 하늘 관제센터
class SkyController {
    private flyers: Flyer[] = [];
    
    addFlyer(flyer: Flyer): void {
        this.flyers.push(flyer);
    }
    
    makeAllFly(): void {
        console.log("☁️ 하늘의 모든 것들이 비행합니다:");
        this.flyers.forEach(flyer => flyer.fly());
    }
}

// 사용 예제
const skyController = new SkyController();

// 일반 비행체 추가
skyController.addFlyer(new Eagle());

// 헬리콥터를 어댑터로 감싸서 추가
const helicopter = new Helicopter();
skyController.addFlyer(new HelicopterAdapter(helicopter));

// 기구를 어댑터로 감싸서 추가
const balloon = new Balloon();
skyController.addFlyer(new BalloonAdapter(balloon));

skyController.makeAllFly();

---

🌍 Python 예제: 땅의 이동 어댑터

땅 위의 다양한 생물들과 탈것들의 이동 방식을 통합하는 예제입니다.

from abc import ABC, abstractmethod

# 🚶 기존 이동 인터페이스
class Walker(ABC):
    @abstractmethod
    def walk(self):
        pass

# 🦓 얼룩말 클래스
class Zebra(Walker):
    def walk(self):
        print("🦓 얼룩말이 네 발로 걸어갑니다!")

# 🐍 뱀 클래스 (다른 인터페이스)
class Snake:
    def slither(self):
        print("🐍 뱀이 몸을 구불거리며 기어갑니다!")

# 🔧 뱀 어댑터
class SnakeAdapter(Walker):
    def __init__(self, snake: Snake):
        self.snake = snake
    
    def walk(self):
        # 뱀의 slither를 walk로 변환
        self.snake.slither()
        print("💫 뱀이 걸어가듯 이동합니다!")

# 🚗 자동차 클래스 (또 다른 인터페이스)
class Car:
    def drive(self):
        print("🚗 자동차가 바퀴를 굴려 달립니다!")

# 🔧 자동차 어댑터
class CarAdapter(Walker):
    def __init__(self, car: Car):
        self.car = car
    
    def walk(self):
        # 자동차의 drive를 walk로 변환
        self.car.drive()
        print("💫 자동차가 걸어가듯 이동합니다!")

# 🌱 로봇 클래스 (또 다른 인터페이스)
class Robot:
    def move_mechanically(self):
        print("🤖 로봇이 기계적으로 움직입니다!")

# 🔧 로봇 어댑터
class RobotAdapter(Walker):
    def __init__(self, robot: Robot):
        self.robot = robot
    
    def walk(self):
        # 로봇의 move_mechanically를 walk로 변환
        self.robot.move_mechanically()
        print("💫 로봇이 걸어가듯 이동합니다!")

# 🌍 지상 관리자
class GroundManager:
    def __init__(self):
        self.walkers = []
    
    def add_walker(self, walker: Walker):
        self.walkers.append(walker)
    
    def make_all_walk(self):
        print("🌍 땅 위의 모든 것들이 이동합니다:")
        for walker in self.walkers:
            walker.walk()

# 사용 예제
if __name__ == "__main__":
    ground_manager = GroundManager()
    
    # 일반 보행자 추가
    ground_manager.add_walker(Zebra())
    
    # 뱀을 어댑터로 감싸서 추가
    snake = Snake()
    ground_manager.add_walker(SnakeAdapter(snake))
    
    # 자동차를 어댑터로 감싸서 추가
    car = Car()
    ground_manager.add_walker(CarAdapter(car))
    
    # 로봇을 어댑터로 감싸서 추가
    robot = Robot()
    ground_manager.add_walker(RobotAdapter(robot))
    
    ground_manager.make_all_walk()

---

💡 어댑터 패턴의 장점

✅ 장점

• 기존 코드 수정 없이 새로운 기능 통합
• 단일 책임 원칙 준수
• 레거시 시스템과의 호환성 유지
• 코드 재사용성 증가

⚠️ 주의사항

• 코드 복잡도 증가 가능
• 너무 많은 어댑터 사용 시 성능 저하
• 인터페이스 변경 시 어댑터도 수정 필요

---

🎯 언제 사용해야 할까?

• 레거시 시스템을 새로운 시스템과 통합할 때
• 외부 라이브러리의 인터페이스가 맞지 않을 때
• 서로 다른 데이터 형식을 변환해야 할 때
• 마이크로서비스 간의 통신 인터페이스 통합

---

📚 마무리

어댑터 패턴은 소프트웨어 개발에서 매우 실용적인 패턴입니다. 마치 실생활의 어댑터처럼, 서로 다른 시스템들을 연결하여 더 큰 가치를 창출할 수 있게 해줍니다.

호환되지 않는 인터페이스 때문에 고민이 있다면, 어댑터 패턴을 적용해보세요! 🚀

---