设计模式——11 组合模式

11 CompositePattern（组合模式）

         前言：帮助客户用同样的方法遍历不同的集合。

需求：

         上次Vander在Panda的帮助下，很好地解决了厨师们的菜单使用不同的集合，解决了不同集合的遍历问题，但是市场竞争真的太激烈了，Vande在九方购物广场的Vander奶茶店也迎来了经营问题，所以现在需要将奶茶店的菜单加入到烧烤菜单中，但是添加会有什么问题呢。我们来看看现在的结构：

 很明显，类型不匹配，无法直接将奶茶菜单加入到Barbecue的子菜单中，别无它法，只能请所有的厨师重新设计他们的菜单，来到这里很容易就会想到树形结构，需要这种树形结构能够容纳菜单、子菜单和菜单项，并且需要能够在每个菜单的各项间游走，需要遍历整个菜单，包括子菜单也要遍历。形成的树如下所示：

 

         正当Vander毫无头绪，不知道这个代码要怎么写的时候，Panda大师又来了，这个可以用“组合模式”解决，下面由我Panda来说明一下组合模式。

组合模式：允许你将对象组合成树形结构来变现“整体/部分”层次结构，组合能让客户以一致的方式处理个别对象以及对象组合。一旦有了丰富的大菜单，我们就可以使用这个模式来“统一处理个别对象和组合对象”。意味着有一个树形结构的菜单（Menu）、子菜单和可能还带有菜单项的子菜单，任何一个菜单都是一种“组合”，因为它既可以包括其他菜单，也可以包括菜单项（MenuItem）。个别对象只是菜单项——并未持有其他对象。菜单就是“节点”，而菜单项就是“叶子节点”。

         组合模式让我们能用树形方式创建对象的结构，树里面包含了组合以及个别的对象，使用组合结构，我们能把相同的操作应用在组合和个别对象上。换句话说，就是在大多数情况下，我们可以忽略对象组合和个别对象之间的差别。用一个浅显一点的例子把：就是一个print语句，可以print（叶子节点）、print（根）、print（子菜单）、print（菜单），就是说可以忽略它在树里面的位置。

         说了那么多，Vander还是懵逼的，接着Panda继续讲解一下组合模式的一般套路，如下图：

         解释一下以上的图，叶子跟组合都是继承于组件，客户端代码主要是跟组件打交道，叶子就是菜单中的每个菜单项，组合指的就是菜单（BarbecueMenu、PizzaMenu等）。使用组合迭代器，就是为了可以在遍历的时候忽略它是菜单还是菜单项，也就是说不管是叶子还是组合对客户端代码来说都是透明的。

这么说可能有点抽象，直接使用吧，用组合模式来重新写菜单：

 

这种方式比较简单，相当于Menu跟MenuItem将迭代器实现转移到了内部，也就是说遍历什么的操作都在Menu跟MenuItem自身来完成。

Menu：

public class Menu extends MenuComponent {

	ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
	
	private String name;
	
	private String desc;

	public Menu(String name, String desc) {
		this.name = name;
		this.desc = desc;
	}
	
	public void add(MenuComponent menuComponent) {
		menuComponents.add(menuComponent);
	}
	
	public void remove(MenuComponent menuComponent) {
		menuComponents.remove(menuComponent);
	}
	
	public MenuComponent getChild(int i) {
		return menuComponents.get(i);
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public void print() {
		System.out.println("\nname:" + getName() + "#desc:" + getDesc());
		System.out.println("----------------------------------------");
		Iterator<MenuComponent> iterator = menuComponents.iterator();
		while(iterator.hasNext()) {
			MenuComponent menuComponent = iterator.next();
			menuComponent.print();
		}
	}
	
}

 MenuItem：

public class MenuItem extends MenuComponent {

	private String name;
	
	private String desc;
	
	private double price;

	public MenuItem(String name, String desc, double price) {
		super();
		this.name = name;
		this.desc = desc;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public double getPrice() {
		return price;
	}
	
	public void print() {
		System.out.println("name:" + getName() + "#desc:" + getDesc() + "#price:" + getPrice());
	}

}

 MenuComponent：

public abstract class MenuComponent {

	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public MenuComponent getChild(int i) {
		throw new UnsupportedOperationException();
	}
	
	public String getName() {
		throw new UnsupportedOperationException();
	}
	
	public String getDesc() {
		throw new UnsupportedOperationException();
	}
	
	public double getPrice() {
		throw new UnsupportedOperationException();
	}
	
	public void print() {
		throw new UnsupportedOperationException();
	}
	
}

 MenuAdmin：

public class MenuAdmin {

	private MenuComponent menuComponent;

	public MenuAdmin(MenuComponent menuComponent) {
		super();
		this.menuComponent = menuComponent;
	}

	public void print() {
		menuComponent.print();
	}
	
}

 Main：

public class Main {

	public static void main(String args[]) {
		
		Menu totalMenu = new Menu("TotalMenu", "TotalMenu");
		
		Menu pizzaMenu = new Menu("PizzaMenu", "PizzaMenu");
		Menu barbecueMenu = new Menu("barbecueMenu", "barbecueMenu");
		Menu milkTeaMenu = new Menu("milkTeaMenu", "milkTeaMenu");
		Menu hotPotMenu = new Menu("hotPotMenu", "hotPotMenu");
		
		pizzaMenu.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
		pizzaMenu.add(new MenuItem("BuffPizza", "American Style", 28.0));
		pizzaMenu.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
		
		milkTeaMenu.add(new MenuItem("Bubble milk tea", "big cup", 10.0));
		milkTeaMenu.add(new MenuItem("Coconut milk tea", "middle cup", 8.0));
		milkTeaMenu.add(new MenuItem("cheese tea", "middle cup", 18.0));
		
		hotPotMenu.add(new MenuItem("chicken", "with solt", 10));
		hotPotMenu.add(new MenuItem("tofu", "with solt", 5));
		hotPotMenu.add(new MenuItem("lettuce", "with solt", 10));
		
		barbecueMenu.add(new MenuItem("corn", "with pepper", 10));
		barbecueMenu.add(new MenuItem("chicken", "with pepper", 10));
		barbecueMenu.add(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
		barbecueMenu.add(milkTeaMenu);

		totalMenu.add(hotPotMenu);
		totalMenu.add(barbecueMenu);
		totalMenu.add(pizzaMenu);
		totalMenu.print();
		
	}
	
}

 MenuComponent：

public abstract class MenuComponent {

	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public MenuComponent getChild(int i) {
		throw new UnsupportedOperationException();
	}
	
	public String getName() {
		throw new UnsupportedOperationException();
	}
	
	public String getDesc() {
		throw new UnsupportedOperationException();
	}
	
	public double getPrice() {
		throw new UnsupportedOperationException();
	}
	
	public void print() {
		throw new UnsupportedOperationException();
	}
	
}

 实现效果：

 

第一种方式是不是违反了单一责任原则，想想看Menu里面是不是使用了迭代器来进行菜单的遍历操作，第一种方式用单一责任原则来换取了透明性（通过让组件的接口同时包含一些管理子节点和叶节点的操作，客户可以将组合和叶节点一视同仁。）

接下来，继续说第二种方式。第二种方式是把遍历的操作实现到了外部，也就是用外部迭代器来完成，我们先来看看图：

这个是当前菜单的树状图，有点复杂，我们简化一下，假设主菜单就只有一个BarbecueMenu：

 下面我们用图示的方法，大概画一下整个遍历的过程：

 

         相当于将BarbecueMenuIterator（普通的list迭代器），遍历到MilkteaMenu的时候，这个时候调用next()获取到的就是MilkteaMenu这个组合，然后由于它里面还有很多叶子，所以将这个组合放入堆栈中，再次next的时候，获取到这个组合迭代器的普通迭代器，再继续遍历，最后这个遍历完了，就将MenuteaMenuIterator从堆栈中移除，然后MilkteaCompositeIterator也移出，然后发现BarbecueMenuIterator也遍历完了，也移除，最后整个堆栈就空了，就算遍历完毕了，这里的位置信息不像之前的普通迭代器那样用pos来标记了，这里直接用栈来实现位置信息的存储。

下面我们上代码：（代码看上去不多，但是确实不好理解，请仔细体会递归的味道）

MenuComponent：（与第一种方式一致）

public class MenuItem extends MenuComponent {

	private String name;
	
	private String desc;
	
	private double price;

	public MenuItem(String name, String desc, double price) {
		super();
		this.name = name;
		this.desc = desc;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public double getPrice() {
		return price;
	}
	
	public void print() {
		System.out.println("name:" + getName() + "#desc:" + getDesc() + "#price:" + getPrice());
	}

	@Override
	public Iterator<MenuComponent> createIteractor() {
		return new NullIterator();
	}

}

Menu：

public class Menu extends MenuComponent {

	ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
	
	private String name;
	
	private String desc;

	public Menu(String name, String desc) {
		this.name = name;
		this.desc = desc;
	}
	
	public void add(MenuComponent menuComponent) {
		menuComponents.add(menuComponent);
	}
	
	public void remove(MenuComponent menuComponent) {
		menuComponents.remove(menuComponent);
	}
	
	public MenuComponent getChild(int i) {
		return menuComponents.get(i);
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public void print() {
		System.out.println("name:" + getName() + "#desc:" + getDesc());
	}
	
	@Override
	public Iterator<MenuComponent> createIteractor() {
		return new CompositeIterator(menuComponents.iterator());
	}
	
}

 NullIterator：

public class NullIterator implements Iterator<MenuComponent> {

	public boolean hasNext() {
		return false;
	}

	public MenuComponent next() {
		return null;
	}

}

 ComponentIterator：（重中之中）

public class CompositeIterator implements Iterator<MenuComponent> {

	private Stack<Iterator<MenuComponent>> stack = new Stack<Iterator<MenuComponent>>();
	
	public CompositeIterator(Iterator<MenuComponent> iterator) {
		stack.push(iterator);
	}

	public boolean hasNext() {
		if(stack.empty()) {
			return false;
		} else {
			Iterator<MenuComponent> iterator = stack.peek();
			if(!iterator.hasNext()) {
				stack.pop();
				return hasNext();
			} else {
				return true;
			}
		}
	}

	public MenuComponent next() {
		if(hasNext()) {
			Iterator<MenuComponent> itemIterator = stack.peek();
			MenuComponent component = itemIterator.next();
			if(component instanceof Menu) {
				stack.push(component.createIteractor());
			}
			return component;
		}
		return null;
	}

}

 MenuAdmin：

public class MenuAdmin {

	private MenuComponent menuComponent;

	public MenuAdmin(MenuComponent menuComponent) {
		super();
		this.menuComponent = menuComponent;
	}

	public void print() {
		Iterator<MenuComponent> iterator =menuComponent.createIteractor();
		while(iterator.hasNext()) {
			MenuComponent menuComponent = iterator.next();
			menuComponent.print();
		}
	}
	
}

 Main：

public class Main {

	public static void main(String args[]) {
		
		Menu totalMenu = new Menu("TotalMenu", "TotalMenu");
		
		Menu pizzaMenu = new Menu("PizzaMenu", "PizzaMenu");
		Menu barbecueMenu = new Menu("barbecueMenu", "barbecueMenu");
		Menu milkTeaMenu = new Menu("milkTeaMenu", "milkTeaMenu");
		Menu hotPotMenu = new Menu("hotPotMenu", "hotPotMenu");
		
		pizzaMenu.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
		pizzaMenu.add(new MenuItem("BuffPizza", "American Style", 28.0));
		pizzaMenu.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
		
		milkTeaMenu.add(new MenuItem("Bubble milk tea", "big cup", 10.0));
		milkTeaMenu.add(new MenuItem("Coconut milk tea", "middle cup", 8.0));
		milkTeaMenu.add(new MenuItem("cheese tea", "middle cup", 18.0));
		
		hotPotMenu.add(new MenuItem("chicken", "with solt", 10));
		hotPotMenu.add(new MenuItem("tofu", "with solt", 5));
		hotPotMenu.add(new MenuItem("lettuce", "with solt", 10));
		
		barbecueMenu.add(new MenuItem("corn", "with pepper", 10));
		barbecueMenu.add(new MenuItem("chicken", "with pepper", 10));
		barbecueMenu.add(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
		barbecueMenu.add(milkTeaMenu);

		totalMenu.add(hotPotMenu);
		totalMenu.add(barbecueMenu);
		totalMenu.add(pizzaMenu);
		
		MenuAdmin menuAdmin = new MenuAdmin(totalMenu);
		menuAdmin.print();
		
	}
	
}

 实现效果：

 

这里有个小细节说明一下，MenuItem使用了NullIterator，由于菜单项已经是子节点了，没有什么好遍历的了，这里如果不用NullIterator，也可以直接返回null，如果直接返回null的话，就需要加入条件判断。但是如果用了NullIterator，就相当于创建了一个没有作用的迭代器。这个迭代器的hasNext()永远都是false，这样操作起来更具有统一性。

         以上的代码最主要就是CompositeIterator的部分，需要自己好好理解一番。

下面我们先来总结一下我们学过的一些模式：

策略	封装可互换的行为，并使用委托决定用哪个行为。
适配器	改变一个或多个类的接口
迭代器	提供一个方式遍历集合，无需暴露集合的实现
外观	简化一群类的接口
组合	客户可以将对象的集合以及个别对象一视同仁
观察者	当某个状态发生变化的时候，允许一群对象被通知到。

 

最后又到了喜闻乐见的总结部分，我们又来总结我们现在现有的设计模式武器。

面向对象基础

         抽象、封装、多态、继承

八大设计原则

设计原则一：封装变化

设计原则二：针对接口编程，不针对实现编程。

         设计原则三：多用组合，少用继承。

         设计原则四：为交互对象之间的松耦合设计而努力

设计原则五：对扩展开放，对修改关闭

设计原则六：依赖抽象，不要依赖于具体的类

设计原则七：只和你的密友谈话

设计原则八：别找我，我有需要会找你

设计原则九：类应该只有一个改变的理由

模式

组合模式：允许你将对象组成树形结构来表现整体/部分的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。

最后献上此次设计所涉及到的源码，有需要的小伙伴可以下载来运行一下，首先先自己进行设计，然后再参考，这样才能加深模式的理解。