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

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);
		}
	}
}

// 对象
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)));
	}
}