JAVA 어댑터(Adapter) 패턴

어댑터 패턴(Adapter Pattern)은 서로 다른 인터페이스를 가진 클래스들 사이에서 호환성을 제공하기 위해 사용됩니다. 클라이언트가 기대하는 인터페이스와 실제 객체의 인터페이스가 다를 때, 어댑터를 통해 중간 역할을 수행하게 됩니다.

이 패턴은 마치 멀티탭이나 변환 플러그처럼, 하나의 시스템을 다른 시스템에 맞춰주는 역할을 합니다.

---

1. 인터페이스 호환성을 위한 어댑터 사용

클라이언트 코드가 특정 인터페이스를 기대하고 있을 때, 이미 구현된 클래스의 인터페이스가 다르면 이를 직접 사용할 수 없습니다. 이런 상황에서 어댑터 패턴을 사용하여 기존 클래스를 클라이언트의 요구사항에 맞게 변환할 수 있습니다.

핵심: 어댑터는 중간 계층으로, 호환되지 않는 인터페이스를 호환 가능하게 만들어줍니다.

---

2. 클래스 다이어그램

아래는 어댑터 패턴의 클래스 다이어그램입니다:

            +-----------------+        +------------------+
            | Target          |        | Adaptee          |
            | (Client expects)|        | (Existing Class) |
            +-----------------+        +------------------+
                      |                        |
                      |                        |
              +-------------------+            |
              | Adapter           |------------+
              | (Implements)      |
              | Adapts Adaptee    |
              +-------------------+
                      ^
                      |
                +------------+
                | Client     |
                +------------+

요약

1. Target: 클라이언트가 기대하는 인터페이스.
2. Adaptee: 기존 클래스, 호환되지 않는 인터페이스를 가짐.
3. Adapter: Target 인터페이스를 구현하고 Adaptee 객체를 감싸서 변환.
4. Client: Adapter를 사용해 기존 클래스를 새로운 인터페이스로 활용.

---

3. 실제 사용 사례

어댑터 패턴의 사용 사례를 확인해보겠습니다:

• 레거시 코드와 새로운 코드가 함께 사용되는 환경.
• 시스템에서 외부 라이브러리나 서비스의 인터페이스를 호환시켜야 할 때.
• 데이터 변환기(예: JSON -> XML).

---

4. 예제 코드

예제 설명

클라이언트는 Target 인터페이스를 기대하고 있지만, Adaptee는 다른 메서드를 제공합니다. 이를 해결하기 위해 어댑터를 사용합니다.

// Target: 클라이언트가 기대하는 인터페이스
interface Target {
    void request();
}

// Adaptee: 기존 클래스 (호환되지 않는 인터페이스를 가짐)
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee: Specific request is being called!");
    }
}

// Adapter: Target 인터페이스를 구현하고 Adaptee 객체를 감싸서 변환
class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        System.out.println("Adapter: Translating request to specificRequest...");
        adaptee.specificRequest();
    }
}

// Client: Target 인터페이스를 사용
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target adapter = new Adapter(adaptee);

        System.out.println("Client: Using adapter to call request...");
        adapter.request();
    }
}

출력 결과

Client: Using adapter to call request...
Adapter: Translating request to specificRequest...
Adaptee: Specific request is being called!

코드 설명

1. Target은 클라이언트가 기대하는 인터페이스입니다.
2. Adaptee는 기존 클래스이며, specificRequest 메서드를 가집니다.
3. Adapter는 Target을 구현하고, 내부에서 Adaptee의 specificRequest를 호출합니다.
4. Client는 Target을 사용해 어댑터를 호출하지만, 실제 작업은 Adaptee에서 수행됩니다.

---

5. 정리

어댑터 패턴을 사용하면 클라이언트가 호환되지 않는 인터페이스를 가진 클래스를 사용할 수 있게 됩니다.

장점:

• 기존 클래스를 변경하지 않고 재사용할 수 있습니다.
• 인터페이스 호환성 문제를 쉽게 해결할 수 있습니다.

단점:

• 코드가 복잡해질 수 있습니다.
• 어댑터 클래스가 많아지면 관리가 어려울 수 있습니다.

---

실생활 비유: 멀티탭이나 변환 플러그는 어댑터의 대표적인 예입니다. 서로 다른 전원 콘센트 형태를 호환시키기 위해 어댑터를 사용하듯, 소프트웨어에서도 인터페이스를 변환할 때 어댑터 패턴을 사용합니다.

---

이제 어댑터 패턴을 적용해보며 코드의 확장성과 유연성을 높여보세요!