职责链模式

职责链模式

职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者直接的耦合关系。將这多个对象连城一个链，并且沿着这条链传递该请求，直到有一个对象处理它为止。

这样接收者和发送者都没有对方的明确信息，他们之间是没有直接的作用关系，且链中的对象也不知道链的结构。结果就是职责链可以简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选接收者的引用。

对于我们使用者来说，我们可以随时增加或者修改处理一个请求的结构。增强了给对象指派职责的灵活性。不过一个请求极有可能在到达链的最末尾也没有得到处理，那么这个就需要在我们判断没有下一个节点的时候处理掉这个没有对应处理节点的请求。且如果是那种只要符合条件的都处理哈怎么办？（比如在一个请求中，如果你想修改的是服务器端的好几个数据库，那么在现有的每一个修改的数据库都有相应的节点，那么就应该按照最后一个的可处理节点来操作。{猜想，还没实验}）

总的来说职责链模式是一个具有时间等级（请求的唯一标志），可以不断添加新的职责，且让请求者和接收者感觉不到对方存在从而达到解耦请求与处理的设计模式。例如传送带上的物品，放上去的人只需要把自己需要传递的东西放上去，而使用物品的人从传送带拿下自己需要使用的物品，他们并不清楚是谁放的或者谁拿走的。

以一个log工具为例，共有4个等级的log

public abstract class Logger {

	public static final int ERROR = 0;
	public static final int DEBUG = 1;
	public static final int INFO = 2;
	public static final int VERBOSE = 3;
	
	
	protected int level;
	protected Logger nextLogger;
	
	public void setNextLogger(Logger logger) {
		this.nextLogger = logger;
	}
	
	public void logMessage(int level , String message) {
		if (this.level == level) {
			printMsg(message);
		} else if (nextLogger!=null) {
			nextLogger.logMessage(level, message);;
		}else {
			System.err.println("Unknow Error");
		}
		
	}
	
	public abstract void printMsg(String msg) ;
}

具体实现每一个等级的log

public class VerboseLogger extends Logger{

	public VerboseLogger(int level) {
		this.level = level;
	}
	
	@Override
	public void printMsg(String msg) {
		System.out.println("VERBOSE:"+msg);
	}
	
}

public class InfoLogger extends Logger{

	public InfoLogger(int level) {
		this.level = level;
	}
	
	@Override
	public void printMsg(String msg) {
		System.out.println("INFO:"+msg);
	}
	
}

public class DebugLogger extends Logger{

	
	public DebugLogger(int level) {
		this.level = level;
	}
	
	@Override
	public void printMsg(String msg) {
		System.out.println("DEBUG:"+msg);
	}
	
}

public class ErrorLogger extends Logger{

	
	 public ErrorLogger(int level) {
		super();
		this.level = level;
	}
	
	
	@Override
	public void printMsg(String msg) {
		System.err.println("ERROR:"+msg);
	}
	
}

生成一个工具类来生成职责链，将四个等级的log串联起来

public class LogUtil {

	public static Logger getLogger() {
		
		Logger verboseLogger = new VerboseLogger(Logger.VERBOSE);
		Logger infoLogger = new InfoLogger(Logger.INFO);
		Logger debugLogger = new DebugLogger(Logger.DEBUG);
		Logger errorLogger = new ErrorLogger(Logger.ERROR);
		
		
		errorLogger.setNextLogger(debugLogger);
		debugLogger.setNextLogger(infoLogger);
		infoLogger.setNextLogger(verboseLogger);
		
		return errorLogger;
	}
	
}

使用职责链输出我们的log

public static void main(String[] args) {

Logger logger = LogUtil.getLogger();

logger.logMessage(Logger.ERROR, "Error Information");

logger.logMessage(Logger.DEBUG, "Debug Information");

logger.logMessage(Logger.INFO, "Info Information");

logger.logMessage(Logger.VERBOSE, "Verbose Information");

}

结果如下：

ERROR:Error Information

DEBUG:Debug Information

INFO:Info Information

VERBOSE:Verbose Information

第二种

ERROR:Error InformationDEBUG:Debug Information

INFO:Info Information

VERBOSE:Verbose Information

现在还不清楚为什么会出现这个，需要等我重拾java来看看了。

由此可以看出：职责链是一个请求者的请求中转站，通过这个接口，我们可以将所有的请求都通过它前去寻找处理方法，从而不必要每一次请求都要找到对应的接收者，让请求者和接收者没有直接的相互关系，减少耦合，但是如果链比较长，势必影响性能。