常用设计模式(下)

结合原理与实例介绍以下设计模式：适配器，装饰，组合，模板方法，策略，责任链，观察者，迭代器等设计模式。

1.适配器模式

定义：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
实际运用：SpringMVC的handlerAdapter
实例：电源转接头

public interface PowerTarget {
	public int output5V();
}
public class PowerAdaptee {
	private int output = 220;
	public int output220V() {
		System.out.println("电源输出电压：" + output);
		return output;
	}
}

public class PowerAdapter extends PowerAdaptee implements PowerTarget{
	//也能够以组合的方式传入适配对象
	@Override
	public int output5V() {
		int output = output220V();
		System.out.println("电源适配器开始工作，此时输出电压是：" + output);
        output = output/44;
        System.out.println("电源适配器工作完成，此时输出电压是：" + output);
        return output;
	}
}
public class Test {
	public static void main(String[] args) {
		PowerTarget target = new PowerAdapter();
		target.output5V();
	}
}

2.装饰者模式

定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。
实际运用：java io类(new BufferedReader(new FileReader(new File("")));

3.组合模式

定义：它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。
只有为(a is b)关系是才能用继承；
当为(a has b)时就应用组合。
组合相对于继承更加灵活，<< effective java >>这本书上面也有说组合优先于继承。

4.模板方法模式

定义：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
实际运用：看看Spring IOC容器的初始化流程，在AbstractApplicationContext类的refresh方法中：

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				destroyBeans();

				cancelRefresh(ex);
				throw ex;
			}
			finally {
				resetCommonCaches();
			}
		}
	}

5.策略模式

定义：模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户
实例：比如validator接口，我们可以为不同的对象定义不同的验证策略。

6.责任链模式

定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
我曾看到：有把整个下订单流程封装为一个链，还有mybatis底层拦截器链，这些相似设计。
示例：

abstract class Handler {

	private Handler next;
	public abstract void handle(String request);
	public Handler getNext() {
		return next;
	}
	public void setNext(Handler next) {
		this.next = next;
	}
}

public class FirstHandler extends Handler{

	@Override
	public void handle(String request) {
		if(request.equals("one")) {
			System.out.println("firstHandler ...");
		}else {
			if(getNext() != null) {
				getNext().handle(request);
			}else {
				System.out.println("No one handle...");
			}
		}
		
	}

}

public class SecondHandler extends Handler{
	@Override
	public void handle(String request) {
		if(request.equals("two")) {
			System.out.println("SecondHandler ...");
		}else {
			if(getNext() != null) {
				getNext().handle(request);
			}else {
				System.out.println("No one handle...");
			}
		}
		
	}
}

public class Test {
	public static void main(String[] args) {
		Handler handler1 = new FirstHandler();
		Handler handler2 = new SecondHandler();
		handler1.setNext(handler2);
		handler1.handle("two");
	}
}

7.观察者模式

定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式
实际运用：spring中的各种listener,zookeeper的watch机制等。
示例：

public interface Observer {
	void notice();
}

abstract class Subject {
	// 存放所有的订阅者
	protected List<Observer> observers = new ArrayList<Observer>();
	public void add(Observer observer) {
		observers.add(observer);
	}
	
	public void remove(Observer observer) {
		observers.remove(observer);
	}
	public abstract void notifyObserver();、
}

public class FireSubject extends Subject{

	@Override
	public void notifyObserver() {
		System.out.println("下达开火命令....");
		
		observers.forEach(ob -> {
			ob.notice();
		});
	}
}

public class TeamOneObserver implements Observer{

	@Override
	public void notice() {
		System.out.println("Team one 收到开火命令，fire.");
	}
}

public class TeamTwoObserver implements Observer{

	@Override
	public void notice() {
		System.out.println("Team two 收到开火命令，fire.");
	}
}

public class Test {
	public static void main(String[] args) {
		Subject subject = new FireSubject();
		Observer oneObserver = new TeamOneObserver();
		Observer twoObserver = new TeamTwoObserver();
		subject.add(oneObserver);
		subject.add(twoObserver);
		
		subject.notifyObserver();
	}
}

8.迭代器模式

定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
实际运用：这个模式我们应该很熟悉，Java中的集合类都提供了iterator方法遍历，这就是迭代器模式的运用。

总结：遵循面向对象设计原则，根据具体的业务场景使用合适的设计模式。

参考：http://c.biancheng.net/view/1395.html