shaofei_huai

行为型设计模式

行为型设计模式目的是将多个类或对象相互协作，共同完成单个类或对象无法单独完成的任务。行为型设计模式共11种，分别为解释器模式、模板方法模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式。

一、解释器模式

解释器模式指预先定义一种语法，然后根据语法对传入数据进行解析。例如java中正则表达式解析就是使用该模式。其优点为扩展性好，容易实现，但执行效率较低，并且每种语法对应一种实现，需要建大量类。在解释器模式中存在抽象解释器（AbstractExpression），终结符表达式（TerminalExpression），非终结符表达式（NonterminalExpression），上下文（Context），客户类（Test）五种角色。以简单的规则定义为例，代码如下

新建抽象表达式Expression

/**
 * 抽象表达式：定义所有终结符表达式和非终结符表达式的解释操作
 * 
 * @author huaisf
 *
 */
public interface Expression {

	public boolean interpret(String value);
}

新建非终结符表达式NonterminalExpression

/**
 * 非终结符表达式：实现非终结操作
 * 
 * @author huaisf
 *
 */
public class NonterminalExpression implements Expression {

	private Expression terminalExpression = null;

	public NonterminalExpression(Expression terminalExpression) {
		this.terminalExpression = terminalExpression;
	}

	public boolean interpret(String value) {
		// 没有非终结符，直接调用终结符表达式
		return terminalExpression.interpret(value);
	}
}

新建终结符表达式TerminalExpression

/**
 * 终结符表达式：实现终结操作
 * 
 * @author huaisf
 *
 */
public class TerminalExpression implements Expression {

	private Map map = new HashMap();

	public TerminalExpression(String rule) {
		int index = rule.indexOf(":");
		String city = rule.substring(0, index);
		String scenery = rule.substring(index + 1, rule.length());
		map.put(city, scenery);

	}

	@Override
	public boolean interpret(String value) {
		int index = value.indexOf(":");
		String city = value.substring(0, index);
		String scenery = value.substring(index + 1, value.length());
		String existScenery = map.get(city);
		if (existScenery != null && existScenery.equals(scenery)) {
			return true;
		}
		return false;
	}

}

新建上下文Context

/**
 * 上下文:完成终结表达式初始化，并对要解释的数据进行中转
 * 
 * @author huaisf
 *
 */
public class Context {

	private Expression nonterminalExpression;

	public Context(String rule) {
		Expression terminalExpression = new TerminalExpression(rule);
		nonterminalExpression = new NonterminalExpression(terminalExpression);
	}

	public void matches(String value) {
		boolean isExist = nonterminalExpression.interpret(value);
		if (isExist) {
			System.out.println("城市与景区对应成功");
			return;
		}
		System.out.println("城市与景区对应失败");
	}
}

新建测试类Test

public class Test {

	public static void main(String[] args) {
		// 定义规则为"杭州:西湖"进行验证
		Context context = new Context("杭州:西湖");
		context.matches("杭州:西湖");
		context.matches("苏州:西湖");
		context.matches("苏州:太湖");
	}
}

二、模板方法模式

模板方法指在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。使用模板方法可提取公共逻辑进行封装，对于非公共操作交由子类执行，但非公共操作如果有改变，则会影响其所有子类。模板方法中分为抽象模板（AbstractTemplate）与具体实现模板（ConcreteTemplate）两种角色。以生产插排为例，代码如下

新建抽象模板Socket

/**
 * 抽象模板:定义具体操作及抽象操作，抽象操作由子类实现
 * 
 * @author huaisf
 *
 */
public abstract class Socket {

	/**
	 * 封装公共逻辑
	 */
	final void create() {

		// 先购买材料
		buyMaterial();

		// 然后材料组装成插排
		assembly();

		// 印上各厂商logo
		printLogo();

	}

	void buyMaterial() {
		System.out.println("购买材料");
	}

	void assembly() {
		System.out.println("材料组装成插排");
	}

	/**
	 * 印上logo
	 */
	abstract void printLogo();

}

新建具体实现模板BullSocket与TCLSocket

/**
 * 具体实现模板:实现父类定义的抽象方法，重写父类逻辑
 * 
 * @author huaisf
 *
 */
public class BullSocket extends Socket {

	@Override
	void printLogo() {
		System.out.println("图上公牛的logo");

	}

}


/**
 * 具体实现模板:实现父类定义的抽象方法，重写父类逻辑
 * 
 * @author huaisf
 *
 */
public class TCLSocket extends Socket {

	@Override
	void printLogo() {
		System.out.println("图上TCL的logo");

	}

}

新建测试类Test

public class Test {

	public static void main(String[] args) {
		// 生产公牛插排
		BullSocket bullSocket = new BullSocket();
		bullSocket.create();

		// 生成tcl插排
		TCLSocket tclSocket = new TCLSocket();
		tclSocket.create();

	}
}

三、责任链模式

责任链模式是对某个请求的所有处理构成一条链，如果链上的某一处理者可以处理，则处理后返回。如果不能处理则将请求传递给链上的下一个处理者。责任链模式中存在抽象处理者(Handler)与具体处理者(ConcreteHandler)两种角色。以购买插排为例，代码如下：

新建抽象处理者AbstractSocketHandler

/**
 * 抽象处理者:定义处理请求接口
 * 
 * @author huaisf
 *
 */
public abstract class AbstractSocketHandler {

	private AbstractSocketHandler NextHandler;

	public AbstractSocketHandler getNextHandler() {
		return NextHandler;
	}

	public void setNextHandler(AbstractSocketHandler nextHandler) {
		NextHandler = nextHandler;
	}

	/**
	 * 购买插排
	 * 
	 * @param count
	 */
	abstract void buySocket(Integer count);
}

新建具体处理者OriginalPriceSocketHandler、NineDiscountSocketHandler、EightDiscountSocketHandler

/**
 * 具体处理者:对抽象处理者定义的接口进行实现，如果无法处理则将请求传递给下一个处理者
 * 
 * @author huaisf
 *
 */
public class OriginalPriceSocketHandler extends AbstractSocketHandler {

	@Override
	void buySocket(Integer count) {
		if (count <= 500) {
			System.out.println("原价购买插排");
			return;
		}
		this.getNextHandler().buySocket(count);
	}

}

public class NineDiscountSocketHandler extends AbstractSocketHandler {

	@Override
	void buySocket(Integer count) {
		if (count > 500 && count <= 5000) {
			System.out.println("九折购买插排");
			return;
		}
		this.getNextHandler().buySocket(count);
	}
}

public class EightDiscountSocketHandler extends AbstractSocketHandler {

	@Override
	void buySocket(Integer count) {
		if (count > 5000) {
			System.out.println("八折购买插排");
			return;
		}
		this.getNextHandler().buySocket(count);
	}
}

新建测试类Test组装调用

public class Test {

	public static void main(String[] args) {
		// 组装责任链
		OriginalPriceSocketHandler originalPriceSocket = new OriginalPriceSocketHandler();
		NineDiscountSocketHandler nineDiscountSocket = new NineDiscountSocketHandler();
		originalPriceSocket.setNextHandler(nineDiscountSocket);
		nineDiscountSocket.setNextHandler(new EightDiscountSocketHandler());

		originalPriceSocket.buySocket(50000);
	}
}

四、命令模式

命令模式将请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，由该对象处理请求。命令模式中包括抽象命令（Command）、具体命令（Concrete Command）、接收者（Receiver）、调用者（Invoker）四种角色。使用命令模式可降低系统耦合度，提高扩展性，但每增加一个命令需要新增具体命令类造成类膨胀。以聊天为例，代码如下：

定义操作枚举ChatTypeEnum

public enum ChatTypeEnum {

	GROUP_CHAT("群聊"), 
	PRIVATE_CHAT("私聊");
	
	private String name;

	ChatTypeEnum(String name) {
		this.name = name;
	}
}

新建抽象命令Command


/**
 * 抽象命令：定义执行命令方法
 * 
 * @author huaisf
 *
 */
public interface Command {

	void execute();
}

新建具体命令GroupChatCommand与PrivateChatCommand

/**
 * 具体命令:对定义的抽象命令实现
 * 
 * @author huaisf
 *
 */
public class GroupChatCommand implements Command {

	private ChatRecord chatRecord;

	public GroupChatCommand() {
		chatRecord = new ChatRecord();
	}

	@Override
	public void execute() {
		System.out.println("群聊消息发送给房间内所有人");
		chatRecord.save();
	}

}


public class PrivateChatCommand implements Command {

	private ChatRecord chatRecord;

	public PrivateChatCommand() {
		chatRecord = new ChatRecord();
	}

	@Override
	public void execute() {
		System.out.println("私聊记录发送到对应人");
		chatRecord.save();
	}

}

新建接受者ChatRecord

/**
 * 接收者:对真正业务进行处理
 * 
 * @author huaisf
 *
 */
public class ChatRecord {

	public void save() {
		System.out.println("保存聊天记录成功");
	}
}

新建调用者CommandManager

/**
 * 调用者：调用具体命令进行处理
 * 
 * @author huaisf
 *
 */
public class CommandManager {

	public static HashMap map = new HashMap<>();

	static {
		map.put(ChatTypeEnum.GROUP_CHAT.name(), new GroupChatCommand());
		map.put(ChatTypeEnum.PRIVATE_CHAT.name(), new PrivateChatCommand());
	}

	public void saveRecord(ChatTypeEnum chatTypeEnum) {
		Command command = map.get(chatTypeEnum.name());
		command.execute();
	}
}

新建测试类Test

public class Test {

	public static void main(String[] args) {
		CommandManager commandManager = new CommandManager();

		// 群聊消息
		commandManager.saveRecord(ChatTypeEnum.GROUP_CHAT);

		// 私聊消息
		commandManager.saveRecord(ChatTypeEnum.PRIVATE_CHAT);
	}
}

五、迭代器模式

迭代器模式提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。在迭代器模式中存在抽象容器（Aggregate）、具体容器（ConcreteAggregate）、抽象迭代器（Iterator）、具体迭代器（ConcreteIterator）。使用迭代器模式可以以不同的方式遍历一个聚合对象，并将遍历算法进行封装。但增加新的聚合类需要新增对应迭代器，提高了系统复杂性。下面以数组及集合两种数据结构遍历为例：

新建抽象迭代器AbstractIterator

/**
 * 抽象迭代器:定义遍历元素所需要的方法
 * 
 * @author huaisf
 *
 */
public interface AbstractIterator {

	/**
	 * 获取下一个元素
	 * 
	 * @return
	 */
	Object next();

	/**
	 * 是否有下一个元素
	 * 
	 * @return
	 */
	boolean hashNext();
}

新建具体迭代器ArrayIterator与ListIterator

/**
 * 具体迭代器:对抽象迭代器定义的方法进行实现，本迭代器为数组迭代器
 * @author huaisf
 *
 */
public class ArrayIterator implements AbstractIterator {

	private int index = 0;
	private Object[] array;

	public ArrayIterator(Object[] array){
		this.array=array;
	}
	@Override
	public Object next() {
		if (index <= array.length) {
			return array[index-1];
		}
		return null;
	}

	@Override
	public boolean hashNext() {
		if (index >= array.length) {
			return false;
		}
		index+=1;
		return true;
	}

}


/**
 * 具体迭代器:对抽象迭代器定义的方法进行实现，本迭代器为集合迭代器
 * @author huaisf
 *
 */
public class ListIterator implements AbstractIterator {

	private int index = 0;
	private List