[디자인패턴] 이터레이터 패턴 (Iterator Pattern)

💡 이터레이터 패턴 (Iterator Pattern)
컬렉션 구현 방법을 노출시키지 않으면서도 그 집합체 안에 들어있는 모든 항목에 접근할 수 있는 방법을 제공한다.

 

■ 예제 : 레스토랑 합병

Steak 레스토랑과 Burger 레스토랑의 합병이 결정되었다. 두 레스토랑이 합병하면서 메뉴를 통일화하고 판매하기로 했다.

 

(1) 문제인식

1. 두 레스토랑이 합의한 메뉴 항목 : MenuItem

/**
 * 두 가게의 합의한 메뉴
 */
public class MenuItem {

    String name; // 메뉴명
    String description; // 메뉴설명
    boolean vegetarian; // 베지테리언 여부
    Long price; // 가격

    public MenuItem(String name, String description, Boolean vegitarian, Long price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegitarian;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public Long getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "MenuItem{" +
                "name='" + name + '\'' +
                ", description='" + description + '\'' +
                ", vegetarian=" + vegetarian +
                ", price=" + price +
                '}';
    }
}

2. 각 레스토랑의 메뉴

/**
 * 스테이크 메뉴 : 배열
 */
public class SteakMenu {

    public static final int MAX_ITEMS = 5; // 최대 메뉴 갯수 5개
    int numberOfItems = 0;
    MenuItem[] menuItemList;

    public SteakMenu() {
        menuItemList = new MenuItem[MAX_ITEMS];
        addMenu("안심 스테이크", "안심스테이크, 구운버섯, 구운양파", false, 18000);
        addMenu("T본 스테이크", "T본 스테이크, 구운파인애플, 구운버섯", false, 20000);
        addMenu("등심 스테이크", "등심스테이크, 구운마늘, 구운감자", false, 15000);
        addMenu("채끝 스테이크", "채끝스테이크, 구운마늘, 구운아스파라거스", false, 12000);
        addMenu("콩고기 스테이크", "콩고기스테이크, 구운아스파라거스, 구운양파, 구운파인애플", true, 17000);
    }

    public void addMenu(String name, String description, boolean vegietarian, long price) {
        MenuItem menuItem = new MenuItem(name, description, vegietarian, price);

        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("등록할 수 있는 메뉴 갯수를 초과했습니다.");
        } else {
            menuItemList[numberOfItems] = menuItem;
            numberOfItems += 1;
        }
    }

    public MenuItem[] getMenuItemList() {
        return menuItemList;
    }

}

/**
 * 햄버거 메뉴 : 리스트
 */
public class BurgerMenu {
    List<MenuItem> menuItemList;

    public BurgerMenu() {
        menuItemList = new ArrayList<>();
        addItem("머쉬룸버거", "버섯, 콩이 재료인 패티로 만든 버거", true, 8000);
        addItem("치킨버거", "치킨 다리살로 만든 버거", false, 9000);
        addItem("한우버거", "1++ 한우로 만든 버거", false, 15000);
        addItem("새우버거", "새우가 듬뿍 들어간 버거", false, 10000);
        addItem("야채버거", "야채를 튀겨 만든 버거", true, 7000);
    }

    public void addItem(String name, String description, boolean vegetarian, long price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItemList.add(menuItem);
    }

    public List<MenuItem> getMenuItemList() {
        return menuItemList;
    }

    @Override
    public String toString() {
        return "burgerMenu{" +
                "menuItemList=" + menuItemList +
                '}';
    }
}

두 가게는 메뉴 구현 방식이 다르다. Steak 는 배열을 Burger 은 리스트로 메뉴를 구현하고 있다. 이렇게 구현 방식이 다르면 각 타입에 맞춰 두 개의 반복문이 작성되야 하는 문제가발생한다.

 

3. 두 메뉴를 사용하는 클라이언트 클래스 (점원) : Clerk

public class Clerk {

    SteakMenu steakMenu; // Array
    BurgerMenu burgerMenu; // List

    public Clerk(SteakMenu steakMenu, BurgerMenu burgerMenu) {
        this.steakMenu = steakMenu;
        this.burgerMenu = burgerMenu;
    }

    public void printMenu() {
        System.out.println("===== Steak Menu =====");
        printMenu(steakMenu.getMenuItemList());
        System.out.println("===== Burger Menu =====");
        printMenu(burgerMenu.getMenuItemList());
    }
    // 배열로 된 Steak 메뉴 출력방식
    public void printMenu(MenuItem[] menus) {
        for (int i = 0; i < menus.length; i++) {
            MenuItem menu = menus[i];
            System.out.println("name = " + menu.getName() + ", price = " + menu.getPrice());
            System.out.println("description = " + menu.getDescription());
        }
    }
    // 리스트로 된 Burger 메뉴 출력방식
    public void printMenu(List<MenuItem> menus) {
        for (MenuItem m : menus) {
            System.out.println("name = " + m.getName() + ", price = " + m.getPrice());
            System.out.println("description = " + m.getDescription());
        }
    }

    public void printVegetarianMenu() {
        printVegetarianMenu(steakMenu.getMenuItemList());
        printVegetarianMenu(burgerMenu.getMenuItemList());
    }
    // 배열로 된 Steak 채식메뉴 출력방식
    public void printVegetarianMenu(MenuItem[] menus) {
        for (int i = 0; i < menus.length; i++) {
            MenuItem menu = menus[i];
            if (menu.isVegetarian()) {
                System.out.println("name = " + menu.getName() + ", price = " + menu.getPrice());
                System.out.println("description = " + menu.getDescription());
            }
        }
    }
    // 리스트로 된 Burger 채식메뉴 출력방식
    public void printVegetarianMenu(List<MenuItem> menus) {
        for (MenuItem m : menus) {
            if (m.isVegetarian()) {
                System.out.println("name = " + m.getName() + ", price = " + m.getPrice());
                System.out.println("description = " + m.getDescription());
            }
        }
    }

    public boolean isItemVegetarian(String name) {
        MenuItem[] steakMenus = steakMenu.getMenuItemList();
        List<MenuItem> burgerMenus = burgerMenu.getMenuItemList();

        if (isVegetarian(name, steakMenus)) {
            return true;
        }
        if (isVegetarian(name, burgerMenus)) {
            return true;
        }
        return false;
    }
    // 배열로 된 Steak 메뉴의 채식여부 확인 메소드
    private boolean isVegetarian(String name, MenuItem[] menus) {
        for (int i = 0; i < menus.length; i++) {
            MenuItem menuItem = menus[i];
            if (menuItem.getName().equals(name)) {
                if (menuItem.isVegetarian()) {
                    return true;
                }
            }
        }
        return false;
    }
    // 리스트로 된 Burger 메뉴의 채식여부 확인 메소드
    private boolean isVegetarian(String name, List<MenuItem> menuItemLists) {
        for (MenuItem m : menuItemLists) {
            if (m.getName().equals(name)) {
                if (m.isVegetarian()) {
                    return true;
                }
            }
        }
        return false;
    }

}

(2) 문제점

Steak 와 Burger 의 구현 방식이 다르기 때문에 똑같은 처리를 각 방식에 맞게 해결해줘야 한다.

즉, 각각에 대한 똑같은 처리 (반복) 를 캡슐화하여 반복자 인터페이스로 해결해보자.

 

(3) 문제해결

1. Menu 인터페이스 생성

public interface Menu {
    public Iterator createIterator();
}

2. Steak 메뉴와 Burger 메뉴에 구현

/**
 * 스테이크 메뉴 : Array, Menu 인터페이스 사용
 */
public class SteakMenu implements Menu {

    // 인스턴스, 생성자 생략 (기존과 동일)

    // getter 는 삭제하자. 내부 구조를 다 드러내기때문에 불필요하다.
//    public MenuItem[] getMenuItemList() {
//        return menuItemList;
//    }

    @Override
    public Iterator createIterator() {
        // 스테이크 메뉴 Iterator 생성
        return new SteakMenuIterator(menuItemList);
    }
}
/**
 * 햄버거 메뉴 : ArrayList, Menu 인터페이스 사용
 */
public class BurgerMenu implements Menu {

    // 인스턴스, 생성자 생략 (기존과 동일)

    // getter 는 삭제하자. 내부 구조를 다 드러내기때문에 불필요하다.
//    public List<MenuItem> getMenuItemList() {
//        return menuItemList;
//    }

    @Override
    public Iterator createIterator() {
        // 버거 메뉴 Iterator 생성
        return new BurgerMenuIterator(menuItemList);
    }
}

3. 배열과 리스트의 내부구조를 하나로 캡슐화 할 Iterator 인터페이스 생성

public interface Iterator {
    boolean hasNext();
    MenuItem next();
}

4. Iterator 를 구현하는 배열용 반복자 (ArrayIterator) , 리스트용 반복자 (ArrayListIterator) 생성

// 배열용 반복자
public class ArrayIterator implements Iterator {

    MenuItem[] menuItems;
    int position;

    public ArrayIterator(MenuItem[] menuItems) {
        this.menuItems = menuItems;
    }

    @Override
    public boolean hasNext() {
        if (position >= menuItems.length || menuItems[position] == null) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public MenuItem next() {
        MenuItem menuItem = menuItems[position];
        position += 1;
        return menuItem;
    }
}
// 리스트용 반복자
public class ArrayListIterator implements Iterator {

    ArrayList<MenuItem> menuItemList;
    int position;

    public ArrayListIterator(ArrayList<MenuItem> menuItems) {
        this.menuItemList = menuItems;
    }

    @Override
    public boolean hasNext() {
        if (position >= menuItemList.size()) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public MenuItem next() {
        MenuItem menuItem = menuItemList.get(position);
        position += 1;
        return menuItem;
    }
}

5. 클라이언트

public class Clerk {

    Menu steakMenu;
    Menu burgerMenu;

    public Clerk(Menu steakMenu, Menu burgerMenu) {
        this.steakMenu = steakMenu;
        this.burgerMenu = burgerMenu;
    }

    public void printMenu() {
        Iterator stakeIterator = steakMenu.createIterator();
        Iterator burgerIterator = burgerMenu.createIterator();

        System.out.println("===== Steak Menu =====");
        printMenu(stakeIterator);
        System.out.println("===== Burger Menu =====");
        printMenu(burgerIterator);
    }

    public void printMenu(Iterator menuIter) {
        while (menuIter.hasNext()) {
            MenuItem menuItem = menuIter.next();
            System.out.println("name = " + menuItem.getName() + ", price = " + menuItem.getPrice());
            System.out.println("description = " + menuItem.getDescription());
        }
    }

    public void printVegetarianMenu() {
        printVegetarianMenu(steakMenu.createIterator());
        printVegetarianMenu(burgerMenu.createIterator());
    }

    public void printVegetarianMenu(Iterator iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            if (menuItem.isVegetarian()) {
                System.out.println("name = " + menuItem.getName() + ", price = " + menuItem.getPrice());
                System.out.println("description = " + menuItem.getDescription());
            }
        }
    }

    public boolean isItemVegetarian(String name) {
        Iterator steakIter = steakMenu.createIterator();
        Iterator burgerIter = burgerMenu.createIterator();

        if (isVegetarian(name, steakIter)) {
            return true;
        }
        if (isVegetarian(name, burgerIter)) {
            return true;
        }
        return false;
    }

    private boolean isVegetarian(String name, Iterator iter) {
        while (iter.hasNext()) {
            MenuItem menuItem = iter.next();
            if (menuItem.getName().equals(name)) {
                if (menuItem.isVegetarian()) {
                    return true;
                }
            }
        }
        return false;
    }
}

Iterator 를 이용해서 배열과 리스트의 반복자를 캡슐화 하기 전에는 각 구현에 맞게 생성해줘야했다.

 

• 반복자 캡슐화 전
  • 다음과 같이 배열, 리스트가 각각 출력방법이 다르기 때문에 구현해야할 소스가 많아지고 지저분하다. 
  • // 전체메뉴 출력 메소드들
    public void printMenu(MenuItem[] menus) {...}
    public void printMenu(List<MenuItem> menus) {...}
    // 채식메뉴 출력 메소드들
    public void printVegetarianMenu(MenuItem[] menus) {...}
    public void printVegetarianMenu(List<MenuItem> menus) {...}

 

• 반복자 캡슐화 후
  • 다음과 같이 배열, 리스트를 하나의 메소드에서 출력할 수 있도록 할 수 있다.
  • // 전체메뉴 출력 메소드
    public void printMenu(Iterator menuIter) {...}
    // 채식메뉴 출력 메소드
    public void printVegetarianMenu(Iterator iterator) {...}

 

이렇게 함으로써 집합체 내에서 어떤 식으로 일이 처리되는지에 대해서 전혀 모르는 상태에서도 그 안에 모든 항목들에 대해서 반복작업을 수행할 수 있게 되었다.

 

 

■ 자바가 제공하는 이터레이터 : java.util.Iterator

이터레이터 패턴을 위해 직접 Iterator 를 작성해봤지만, java 에서 제공해주는 Iterator 가 존재한다.

1. Menu 인터페이스

import java.util.Iterator;

public interface Menu {
    public Iterator createIterator();
}

2. MenuItem 클래스

public class MenuItem {
    String name; // 메뉴명
    String description; // 설명
    boolean vegetarian; // 베지테리언 여부
    Long price; // 가격

    public MenuItem(String name, String description, Boolean vegetarian, Long price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }
    // getter
    public String getName() { return name; }
    public String getDescription() { return description; }
    public boolean isVegetarian() { return vegetarian; }
    public Long getPrice() { return price; }
}

3. SteakMenu, BurgerMenu 클래스

import java.util.Arrays;
import java.util.Iterator;

/**
 * 스테이크 메뉴 : Array
 */
public class SteakMenu implements Menu {

    public static final int MAX_ITEMS = 5; // 최대 메뉴 갯수 5개
    int numberOfItems = 0;
    MenuItem[] menuItemList;

    public SteakMenu() {
        menuItemList = new MenuItem[MAX_ITEMS];
        addMenu("안심 스테이크", "안심스테이크, 구운버섯, 구운양파", false, 18000);
        addMenu("T본 스테이크", "T본 스테이크, 구운파인애플, 구운버섯", false, 20000);
        addMenu("등심 스테이크", "등심스테이크, 구운마늘, 구운감자", false, 15000);
        addMenu("채끝 스테이크", "채끝스테이크, 구운마늘, 구운아스파라거스", false, 12000);
        addMenu("콩고기 스테이크", "콩고기스테이크, 구운아스파라거스, 구운양파, 구운파인애플", true, 17000);
    }

    public void addMenu(String name, String description, boolean vegetarian, long price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);

        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("등록할 수 있는 메뉴 갯수를 초과했습니다.");
        } else {
            menuItemList[numberOfItems] = menuItem;
            numberOfItems += 1;
        }
    }

    @Override
    public Iterator<MenuItem> createIterator() {
        // 배열 : stream 사용한 Iterator
        return Arrays.stream(menuItemList).iterator();
    }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 햄버거 메뉴 : ArrayList
 */
public class BurgerMenu implements Menu {
    List<MenuItem> menuItemList;

    public BurgerMenu() {
        menuItemList = new ArrayList<>();
        addItem("머쉬룸버거", "버섯, 콩이 재료인 패티로 만든 버거", true, 8000);
        addItem("치킨버거", "치킨 다리살로 만든 버거", false, 9000);
        addItem("한우버거", "1++ 한우로 만든 버거", false, 15000);
        addItem("새우버거", "새우가 듬뿍 들어간 버거", false, 10000);
        addItem("야채버거", "야채를 튀겨 만든 버거", true, 7000);
    }

    public void addItem(String name, String description, boolean vegetarian, long price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItemList.add(menuItem);
    }

    @Override
    public Iterator<MenuItem> createIterator() {
        // 자바가 제공해주는 Iterator
        return menuItemList.iterator();
    }
}

4. 클라이언트 Clerk

import java.util.Iterator;

public class Clerk {

    Menu steakMenu;
    Menu burgerMenu;

    public Clerk(Menu steakMenu, Menu burgerMenu) {
        this.steakMenu = steakMenu;
        this.burgerMenu = burgerMenu;
    }

    /**
     * 이터레이터 사용
     */
    public void printMenu() {
        Iterator<MenuItem> steakMenuIterator = steakMenu.createIterator();
        Iterator<MenuItem> burgerMenuIterator = burgerMenu.createIterator();
        System.out.println("===== Steak Menu =====");
        printMenu(steakMenuIterator);
        System.out.println("===== Burger Menu =====");
        printMenu(burgerMenuIterator);
    }

    public void printMenu(Iterator<MenuItem> menuItemIterator) {
        while (menuItemIterator.hasNext()) {
            MenuItem menuItem = menuItemIterator.next();
            System.out.println("name = " + menuItem.getName() + ", price = " + menuItem.getPrice());
            System.out.println("description = " + menuItem.getDescription());
        }
    }

    public void printVegetarianMenu() {
        printVegetarianMenu(steakMenu.createIterator());
        printVegetarianMenu(burgerMenu.createIterator());
    }

    public void printVegetarianMenu(Iterator<MenuItem> iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            if (menuItem.isVegetarian()) {
                System.out.println("name = " + menuItem.getName() + ", price = " + menuItem.getPrice());
                System.out.println("description = " + menuItem.getDescription());
            }
        }
    }

    public boolean isItemVegetarian(String name) {
        Iterator steakMenuIterator = steakMenu.createIterator();
        Iterator burgerMenuIterator = burgerMenu.createIterator();
        if (isVegetarian(name, steakMenuIterator)) {
            return true;
        }
        if (isVegetarian(name, burgerMenuIterator)) {
            return true;
        }
        return false;
    }

    private boolean isVegetarian(String name, Iterator<MenuItem> menuItemIterator) {
        while (menuItemIterator.hasNext()) {
            MenuItem menuItem = menuItemIterator.next();
            if (menuItem.getName().equals(name)) {
                if (menuItem.isVegetarian()) {
                    return true;
                }
            }
        }
        return false;
    }

}

 

 

 

■ UML Diagram

모든 항목에 일일이 접근하는 작업을 반복자 객체에서 맡게 된다.  컬렉션 객체 안에 들어있는 모든 항목에 접근하는 방식이 통일된다. 그로인해 어떤 종류의 집합체에 대해서도 사용할 수 있는 다형적인 코드를 만들 수 있다. 또한 집합체는 반복작업에 대해서 손을 떼고 자신의 컬렉션 관리에만 전념할 수 있다.

 

■ 디자인 원칙 : 단일 역할 원칙

만약, Iterator 를 따로 만들지 않고, 클래스(예제에서 SteakMenu, BurgerMenu에 해당) 에서 반복자용 메소드 관련기능을 전부 구현했다면 어떨까? 메소드가 꽤 많아지게된다. 메소드 수가 많아진다는 것이 좋지않은 이유가 될까?

 

클래스에서 원래 그 클래스의 역할 (집합체 관리) 외에 다른 역할 (반복자 메소드) 을 처리하도록 하면 두 가지 이유로 인해 그 클래스에 변경이 생길 수 있다.

    (1) 컬렉션이 어떤 이유로 바뀌게 되면 해당 클래스의 변경이 생긴다.

    (2) 반복자 관련 기능이 바뀌게 되면 해당 클래스의 변경이 생긴다.

 

따라서 다음과 같은 디자인 원칙이 있다.

📌 디자인 원칙 : 단일 역할 원칙
      클래스를 바꾸는 이유는 한 가지 뿐이어야 한다.

클래스를 고치는 것은 최대한 피해야 한다. 변경은 예상치 못한 수많은 문제를 야기할 가능성이 있기 때문이다.

한 역할은 한 클래스에서만 맡도록 해야한다.

 

📌 응집도 (cohesion)
한 클래스 또는 모듈이 특정 목적 또는 역할을 얼마나 일관되게 지원하는지를 나타내는 척도이다.

어떤 모듈 또는 클래스의 응집도가 높다는 것은 일련의 서로 연관된 기능이 묶여있다는 것을, 응집도가 낮다는 것은 서로 상관 없는 기능들이 묶여있다는 것을 뜻한다.

응집도는 단일 역할 원칙에서만 쓰이는 용어는 아니고, 좀더 관범위한 용도로 쓰이는 용어이다. 하지만 그 둘은 서로 밀접하게 연관되어 있다. 이 원칙을 잘 따르는 클래스는 두 개 이상의 역할을 맡고 있는 클래스에 비해 응집도가 높고, 관리하기도 더 용이한 편이다.

 

---

참고
헤드 퍼스트 디자인 패턴 (Head First Design Patterns) - 에릭 프리먼,엘리자베스 롭슨,케이시 시에라,버트 베이츠