设计模式-行为型模式-责任链模式

设计模式-行为型模式-责任链模式

定义

将请求沿着链传递，然后直到对象处理即可。

UML图

代码

基本的责任链

public class Test{
	public void test(int i, Request request){
		if(i == 1){
			Hander1.response(request);
		}
		
		if(i == 2){
			Hander2.response(request);
		}
		
		if(i == 3){
			Hander3.requese(request);
		}
	}
}

代码逻辑如上，只处理1，2,3情况，其余的情况都不处理。

责任链

// 对象
public class Level{
	private int level = 0;
	public Level(int level){
		this.level = level;
	}
	public boolean above(Level level){
		if(this.level >= level.level)
			return true;
		else
			return false;
	}
}

// 将对象进行封装
public class Request{
	Level level;
	public Request(Level level){
		this.level = level;
	}
	public Level getLevel(){
		return level;
	}
}

// 返回消息
public class Response{}

public abstract class Handler{
	private Handler nextHandler;
	public final Response handleRequest(Request request){
		Response response = null;
		// 根据处理器的优先级处理，如果优先级高，处理
		if(this.getHandlerLevel().above(request.getLevel())){
			// 如果寻找到处理器，进行处理
			response = this.response(request);
		}else{
			// 否则，进入下一个处理器
			if(this.nextHandler != null){
				this.nextHandler.handleRequest(request);
			}else{
				System.out.println("没有合适的处理器");
			}
		}
		return response;
	}
	// 设置下一个处理器
	public void setNextHandler(Handler handler){
		this.nextHandler = handler;
	}
	// 当前处理器
	protected abstract Level getHandlerLvel();
	// 进入处理器处理
	public abstract Response response(Request request);
}

// 第一个处理器
public class ConcreteHandler1 extends Handler{
	protected Level getHandlerLevel(){
		return new Level(1);
	}
	public Response response(Request request){
		System.out.println("处理1处理");
		return null;	// 下一个处理器为空
	}
}

// 第二个处理器
public class ConcreteHandler2 extends Handler{
	protected Level getHandlerLevel(){
		return new Level(3);
	}
	public Response response(Request request){
		System.out.println("处理1处理");
		return null;	// 下一个处理器为空
	}
}

// 第三个处理器
public class ConcreteHandler3 extends Handler{
	protected Level getHandlerLevel(){
		return new Level(5);
	}
	public Response response(Request request){
		System.out.println("处理1处理");
		return null;	// 下一个处理器为空
	}
}

// 最后定义场景
public class Client{
	public static void main(String[] args){
		// 新建处理器
		Handler handler1 = new ConcreteHandler1();
		Handler handler2 = new ConcreteHandler2();
		Handler handler3 = new ConcreteHandler3();
		
		// 设置下一个处理器
		// 处理器处理逻辑为先处理1，再处理2，再处理3
		handler1.setNextHandler(handler2);
		handler2.setNextHandler(handler3);
		
		// 进行处理
		Response response = handler1.handlerRequest(new Request(new Level(4)));
	}
}

总结

责任链模式核心在处理流，让对象在类之间流动，直到合适进行对象处理，并把下一个设置为空。
写法，当然就是新建几个处理器类，然后要处理的对象，处理类之间用next指向下一个，然后把处理的对象传入进去，如果找到合适的处理器，进行处理，并将下一个设置为空，完成责任链。
其中，几个处理器类可以抽象出一个抽象类，并把对象进行封装成一个类，以上为上方代码的设计思路。

应用

开发一个电商网站，支付过500元定金的用户，收到100元优惠卷，200元收到50元，没有支付过的，进入普通模式购买。
如果不用职责链，需要写入一大堆if语句。
将if语句拆分，使用职责链，将处理器类抽象出来，然后将购买的用户传入处理器，然后如果处理完成，下一个设置为空，返回结果。
另外一个应用，文件上传，使用的也是职责链。