📚 Iterater Pattern & Composite Pattern

📖 Restaurant menu problem - Iterator Pattern

• 레스토랑에는, 메뉴가 적혀있는 메뉴판 있음

• 레스토랑에는 메뉴판이 2개가 있으며, 주문을 받는 웨이터가 있음

• 그런데, A메뉴판에 있는 메뉴들을 ArrayList로 관리했고, B메뉴판에 있는 메뉴들을 Array로 관리했다고 가정

• 여기서 생길 수 있는 문제점

  • 각 메뉴 ( A / B )에 들어있는 메뉴들을 모두 출력하기 위해서는 A, B 각각 for문으로 순회하며 출력 해 주어야 함
  • 웨이터쪽 코드를 개발 할 때, Menu의 구체 클래스들 ( A, B 메뉴 클래스 )에 의존 해야 함
  • 즉, 메뉴 항목의 컬렉션 형태를 웨이터가 알고 있어야 하는데, 이는 의존성이 높아짐을 의미
  • 만약 B 메뉴판을 HashTable로 바꾼다면, 웨이터쪽 코드를 수정해야 할 곳이 매우 많아짐

• 메뉴판에 있는 메뉴들을 담아놓은 컬렉션의 자료구조 형태가 달라 생긴 문제

• 이를 위해 Iterator 인터페이스를 만들고, Adapter 처럼 사용 할 수 있음

  interface Iterator<T> {
  		boolean hasNext();
  		T next();
  }
  

  class DinerMenuIterator implements Iterator<MenuItem> {
  		MenuItem[] items;
  		int position = 0;
  
  		public DinerMenuIterator(MenuItem[] items) {
  				this.items = items;
  		}
  
  		@override public MenuItem next() {
  				return items[position++];
  		}
  
  		@override public boolean hasNext() {
  				if (position > items.length || items[position] == null) {
  						return false;
  				}
  				return true;
  		}
  }
  

  class DinerMenu {
  		static final int MAX_ITEMS = 6;
  		int numberOfItems = 0;
  		MenuItem[] menuItems;
  
  		// add menu items / ... 
  
  		// 이 Iterator를 가지고, 클라이언트 ( 웨이터 ) DinerMenu에 있는 값들을 조회할 수 있도록 함
  		public Iterator createIterator() {
  				return new DinerMenuIterator(menuItems);
  		}
  }
  

  class Waiter {
  		DinerMenu dinerMenu;
  		
  		public Waiter(DinerMenu dinerMenu) {
  				this.dinerMenu = dinerMenu;
  		}
  
  		void printMenu() {
  				printMenu(dinerMenu.createIterator());
  		}
  
  		void printMenu(Iterator iterator) {
  				while(iterator.hasNext()) {
  						// print 내용
  				}
  		}
  }
  

  • 위와 같이 코드를 진행했을 시, 다른 메뉴판 ( PancakeMenu )이 추가되고, 그 안에서 HashMap을 쓴다고 하더라도 웨이터 쪽에서 코드수정 할 일은 없음
  • 즉, 메뉴 구현법이 캡슐화 되었음
  • 메뉴판의 메뉴 아이템을 출력하는것을 다형성을 통해 한개의 순환문으로 통일함
  • 웨이터가 구현 클래스에 의존하고있지 않음

• Java.util.Iterator를 활용할 수도 있음

  interface Iterator<T> {
  		boolean hasNext();
  		T next();
  		void remove();
  }
  

  • remove가 추가되었음
  • 이 remove는 구현체에서 지원하지 않는다면, 적절한 exception을 던져 주는것이 좋음

• DinerMenu도 구체 클래스니, 이를 Menu 인터페이스로 추상화

  interface Menu {
  		public Iterator createIterator();
  }
  

  class Waiter {
  		Menu dinerMenu;
  		Menu pancakeMenu;
  		
  		public Waiter(Menu dinerMenu, Menu pancakeMenu) {
  				this.dinerMenu = dinerMenu;
  				this.pancakeMenu = pancakeMenu;
  		}
  
  		void printMenu() {
  				printMenu(dinerMenu.createIterator());
  				printMenu(pancakeMenu.createIterator());
  		}
  
  		void printMenu(Iterator iterator) {
  				while(iterator.hasNext()) {
  						// print 내용
  				}
  		}
  }
  

• 위와 같이 구현 할 경우, Menu가 늘어 났을 때 Menu 별로 코드를 추가 해주어야 하는 불편함이 있음

• 따라서 Menu들을 ArrayList에 담아서 활용 가능

  class Waiter {
  		ArrayList<Menu> menus;
  		
  		public Waiter(ArrayList<Menu> menus) {
  				this.menus = menus;
  		}
  
  		void printMenu() {
  				Iterator menuIterator = menus.iterator();
  				while(menuIterator.hasNext()) {
  						printMenu(((Menu) menuIterator.next()).createIterator());
  				}
  		}
  
  		void printMenu(Iterator iterator) {
  				while(iterator.hasNext()) {
  						// print 내용
  				}
  		}
  }
  

  class Waiter {
  		ArrayList<MenuComponent> menus;
  		
  		public Waiter(ArrayList<Menu> menus) {
  				this.menus = menus;
  		}
  
  		void printMenu() {
  				Iterator menuIterator = menus.iterator();
  				while(menuIterator.hasNext()) {
  						printMenu(((Menu) menuIterator.next()).createIterator());
  				}
  		}
  
  		void printMenu(Iterator iterator) {
  				while(iterator.hasNext()) {
  						// print 내용
  				}
  		}
  }
  

• 이떄, DinerMenu 안에, DesertMenu가 들어가야 하는 상황이 발생한다고 가정

• 즉, 저녁 메뉴판안에 디저트 메뉴판 내용이 포함 되어야 하는데, 이는 위와 같은 자료구조 형태에서는 불가능한 형태 ( MenuItem ≠ Menu )

• 따라서, 컴포지트 패턴을 활용하여 Menu ( 메뉴판 )와 MenuItem ( 개별 메뉴 )를 MenuComponent로 통일함

  interface MenuComponent<MenuComponent> {
  		// 메뉴판에 필요함 
  		void add(MenuComponent menuComponent)
  		...
  		// 메뉴에 필요함 
  		String getName();
  		boolean isVegetarian();
  		...
  		void print();
  }
  

  class MenuItem implements MenuComponent {
  		// MenuItem에서 필요하지 않은 MenuComponent 함수는, 에러를 throw
  		@override void add(MenuComponent menuComponent) {
  				throw ...
  		}
  
  		@override String getName() {
  				return ...
  		}
  
  		@override void print() {
  				...
  		}
  }
  

  class Menu implements MenuComponent {
  
  		ArrayList<MenuComponent> menuComponents = new ArrayList();
  
  		// Menu에서 필요하지 않은 MenuComponent 함수는, 에러를 throw
  		@override void add(MenuComponent menuComponent) {
  				menuComponents.add(menuComponent);
  		}
  
  		@override boolean isVegetarian() {
  				throw ...
  		}
  
  		@override void print() {
  				Iterator iterator = menuComponents.iterator();
  				while(iterator.hasNext()) {
  						MenuComponent menuComponent = (MenuComponent) iterator.next();
  						// 메뉴판인 경우에 재귀적 으로 MenuComponent를 부르며 호출됨
  						menuComponent.print(); 
  				}
  		}
  }
  

• 컴포지트 패턴과 이터레이터 패턴을 합쳐, Component ( 복합 객체 전체 ) 에서 iterator를 바로 뽑아 낼 수 있도록 구현하여, 반복문의 사용에 통일성을 줄 수 있음

• 즉 Iterator를 Composite 에서도, Leaf에서도 리턴하도록 구현

  interface MenuComponent {
  		// 메뉴판에 필요함 
  		void add(MenuComponent menuComponent);
  		...
  		// 메뉴에 필요함 
  		String getName();
  		boolean isVegetarian();
  		...
  		void print();
  		...
  		// 추가된 부분
  		Iterator createIterator();
  }
  

  class MenuItem implements MenuComponent {
  		// MenuItem에서 필요하지 않은 MenuComponent 함수는, 에러를 throw
  		@override void add(MenuComponent menuComponent) {
  				throw ...
  		}
  
  		@override String getName() {
  				return ...
  		}
  
  		@override void print() {
  				...
  		}
  
  		@override Iterator createIterator() {
  				// 커스텀으로 만든것 
  				// default 항상 값을 리턴하도록 구현 해도 됨
  				return NullIterator();
  		}
  }
  

  class NullIterator implements Iterator<MenuItem> {
  		@override MenuItem next() {
  				return null;
  		}
  
  		@override boolean hasNext() {
  				return false;
  		}
  
  		@override void remove() {
  				throw error ... 
  		}
  }
  

  class Menu implements MenuComponent {
  
  		ArrayList<MenuComponent> menuComponents = new ArrayList();
  
  		// Menu에서 필요하지 않은 MenuComponent 함수는, 에러를 throw
  		@override void add(MenuComponent menuComponent) {
  				menuComponents.add(menuComponent);
  		}
  
  		@override boolean isVegetarian() {
  				throw ...
  		}
  
  		@override void print() {
  				Iterator iterator = menuComponents.iterator();
  				while(iterator.hasNext()) {
  						MenuComponent menuComponent = (MenuComponent) iterator.next();
  						// 메뉴판인 경우에 재귀적 으로 MenuComponent를 부르며 호출됨
  						menuComponent.print(); 
  				}
  		}
  
  		@override Iterator createIterator() {
  				// MenuComponent는 Leaf도, Composite도 될 수 있음
  				// 따라서 Leaf / Composite에 관계 없이 반복작업을 할 수 있도록 만든 클래스 
  				return new CompositeIterator(menuComponents.iterator());
  		}
  }
  

  class CompositeIterator implements Iterator<MenuComponent> {
  		// Iterator 객체들을 담아놓을 stack
  		// 나중에 들어온 것을 나중에 꺼내기 위해 사용했으나, 
  		Stack<Iterator> stack = new Stack();
  
  		public CompositeIterator(Iterator iterator) {
  				stack.push(iterator);
  		}
  
  		@override MenuComponent next() {
  				if (hasNext()) {
  						Iterator iterator = (Iterator) stack.peek();
  						MenuComponent component = (MenuComponent) iterator.next();
  						if (component instanceof Menu) { // 메뉴판 ( Composite ) 이라면
  								// 메뉴판에 있는 모든 Menu component를 stack에 담아놓음
  								stack.push(component.createIterator());
  						}
  						return component;
  				} else {
  						return null;
  				}
  		}
  
  		@override boolean hasNext() {
  				if (stack.isEmpty()) {
  						return false;
  				} else {
  						Iterator iterator = (Iterator) stack.peek();
  						if (!iterator.hasNext()) {
  								stack.pop();
  								return hasNext();
  						} else {
  								return true;
  						}
  				}
  		}
  
  		@override void remove() {
  				throw ... // 지원안함
  		}
  }
  

• 채식주의자용 메뉴 찾기

  class Waiter {
  		MenuComponent allMenues;
  		
  		public Waiter(MenuComponent allMenues) {
  				this.allMenues = allMenues;
  		}
  
  		void printMenu() {
  				// 위 예시코드와 변경된점을 확인
  				allMenus.print();
  		}
  
  		void printMenuVegetarianMenu() {
  				Iterator iterator = allMenus.createIterator();
  				while (iterator.hasNext()) {
  						MenuComponent menuComponent = (MenuComponent) iterator.next();
  						try {
  								if (menuComponent.isVegetarian()) {
  										menuComponent.print();
  								}
  						} catch (Exception e) { } // isVegetarian을 지원하지 않는 메뉴판 때문에 에러처리
  				}
  		}
  }
  

📖 소개된 디자인 패턴 원칙 정리

이터레이터 패턴