자바(JAVA) - 어댑터(Adapter) 패턴

- 자바(JAVA) - 어댑터(Adapter) 패턴

 

1. 의도

호환되지 않는 클래스(레거시 코드, 의존성이 높은 코드 등)들이 함께 동작하게끔 함.

 

2. 용도

하나의 인터페이스를 다른 클래스가 사용할 수 있도록 변환하는 것이 목표다.

어댑터는 부모 클래스를 수정하지 않고도 다른 인터페이스를 가진 객체들이 협업하게끔 만들 수 있다.

 

어댑터 패턴은 크게 객체 어댑터 패턴과 클래스 어댑터 패턴으로 나뉜다.

객체 어댑터 패턴은 두 개의 인터페이스를 구현하여, 하나의 인터페이스를 다른 인터페이스의 객체로 변환한다.

- 기존 클래스의 코드 변경 없이 인터페이스를 변환하여 사용할 수 있다.

 

클래스 어댑터 패턴은 기존 클래스를 상속받아 새로운 클래스를 만들고 인터페이스를 연결한다.

- 새로운 클래스를 만들어야 하므로, 코드의 복잡도가 높아진다. 또한 자바에서는 다중상속이 불가하여 권장하지 않는다.

 

3. UML

 

4. 구현

public class AdapterClient {

    public static void main(String[] args) {
        //origin
        System.out.println("============ origin ============");
        SortingMachine machine = new SortingMachine(new ASortEngine());
        machine.sortingRun();

        System.out.println("============ origin end ============");

        //change
        System.out.println("============ change ============");
        SortEngineAdapter sortAdapter = new SortEngineAdapter(new ASortEngine(), new BSortEngine());
        SortingMachine machine2 = new SortingMachine(sortAdapter);
        machine2.sortingRun();

        System.out.println("============ change end ============");
    }
}

/*
============ origin ============
A 정렬 세팅
A 정렬
A 정렬 프린트
A 정렬 리버스
A 정렬 프린트
============ origin end ============
============ change ============
B 정렬 세팅
B 정렬 정순
A 정렬 프린트
B 정렬 역순
A 정렬 프린트
============ change end ============
*/

 

public class SortingMachine {

    private final ISortEngine engine;

    public SortingMachine(ISortEngine iSortEngine) {
        this.engine = iSortEngine;
    }

    void sortingRun() {
        engine.setList();
        engine.sort();
        engine.printSortListPretty();
        engine.reverseSort();
        engine.printSortListPretty();
    }
}

public interface ISortEngine {
    void setList();
    void sort();
    void reverseSort();
    void printSortListPretty();
}
============================================================

public class ASortEngine implements ISortEngine{

    private ISortEngine engine;

    @Override
    public void setList() {
        System.out.println("A 정렬 세팅");
    }

    @Override
    public void sort() {
        System.out.println("A 정렬");
    }

    @Override
    public void reverseSort() {
        System.out.println("A 정렬 리버스");
    }

    @Override
    public void printSortListPretty() {
        System.out.println("A 정렬 프린트");
    }
}
============================================================

public class BSortEngine {

    public void setList() {
        System.out.println("B 정렬 세팅");
    }

    public void sorting(boolean desc) {
        if (desc) {
            System.out.println("B 정렬 역순");
        } else {
            System.out.println("B 정렬 정순");
        }
    }
}

public class SortEngineAdapter implements ISortEngine{

    private final ASortEngine aSortEngine;
    private final BSortEngine bSortEngine;

    public SortEngineAdapter(ASortEngine aSortEngine, BSortEngine bSortEngine) {
        this.aSortEngine = aSortEngine;
        this.bSortEngine = bSortEngine;
    }

    @Override
    public void setList() {
        bSortEngine.setList();
    }

    @Override
    public void sort() {
        bSortEngine.sorting(false);
    }

    @Override
    public void reverseSort() {
        bSortEngine.sorting(true);
    }

    @Override
    public void printSortListPretty() {
        aSortEngine.printSortListPretty();
    }
}

 

5. 패턴의 장단점

• 장점
  • 개방폐쇄 원칙(OCP)을 최대한 활용한 패턴이다.
  • 가장 큰 장점으로는 클라이언트 코드가 어댑터와 작동하는 동안, 기존 코드를 변경하지 않고 새로운 코드를 추가할 수 있다는 것이다.
  • 기존 코드와 새로운 코드 사이에 중간 계층을 두어, 객체간의 결합도를 낮추고 서로 독립적으로 개발할 수 있도록 돕는다.
• 단점
  • 새로운 인터페이스와 클래스가 요구되므로, 불필요한 복잡성이 추가될 여지가 있다.
  • 객체 간의 상호작용이 요구되어 리소스가 필요하다.
  • 어댑터 클래스가 인터페이스를 변환하는 과정에 오버헤드가 발생한다.

 

출처 :

https://refactoring.guru/design-patterns/adapter

Adapter