设计模式学习笔记——责任链模式

责任链模式

责任链模式，使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

结构图

代码实现

请求类Request：

/**
* 请求类
*
* @author xukai 2016年4月4日 下午1:13:24
*
*/
public class Request {

Level level;

public Request(Level level) {
super();
this.level = level;
}

public Level getLevel() {
return level;
}

}

请求等级类Level：决定请求由谁来处理

/**
* 请求级别类
*
* @author xukai 2016年4月4日 下午1:20:51
*
*/
public class Level {

private int level = 0;

public Level(int level) {
this.level = level;
}

/**
* 当前等级大于或等于	return true<br>
* @param level
* @return
*/
public boolean above(Level level){
if(this.level >= level.level){
return true;
}
return false;
}

}

抽象处理类Handler：

/**
* 定义一个处理请示的接口
*
* @author xukai 2016年4月4日 下午1:07:22
*
*/
public abstract class Handler {

protected Handler nextHandler;

/**
* 处理请求
*
* @param request
* @return
*/
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;
}

/**
* 获取处理者处理等级
*
* @return
*/
protected abstract Level getHandlerLevel();

/**
* 处理请求，返回响应
*
* @param request
* @return
*/
public abstract Response response(Request request);

public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}

}

具体处理请求类ConcreteHandler1：

/**
* 具体处理者1
*
* @author xukai 2016年4月4日 下午1:26:31
*
*/
public class ConcreteHandler1 extends Handler {

@Override
protected Level getHandlerLevel() {
return new Level(1);
}

@Override
public Response response(Request request) {
System.out.println("请求被处理者1处理");
return null;
}

}

ConcreteHandler2：

/**
* 具体处理者2
*
* @author xukai 2016年4月4日 下午1:28:08
*
*/
public class ConcreteHandler2 extends Handler {

@Override
protected Level getHandlerLevel() {
return new Level(3);
}

@Override
public Response response(Request request) {
System.out.println("请求被处理者2处理");
return null;
}

}

处理请求直到返回的响应Response：

/**
* 响应类
*
* @author xukai 2016年4月4日 下午1:14:19
*
*/
public class Response {

}

客户端测试：

public class Client {

@SuppressWarnings("unused")
public static void main(String[] args) {

Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
Handler handler3 = new ConcreteHandler3();

handler1.setNextHandler(handler2);
handler2.setNextHandler(handler3);

Response response = handler1.handleRequest(new Request(new Level(2)));
response = handler1.handleRequest(new Request(new Level(4)));
response = handler1.handleRequest(new Request(new Level(6)));

}

}

控制台输出：

请求被处理者2处理
请求被处理者3处理
没有合适的处理者

总结

优点：责任链模式与if ...else相比，耦合性相对较低一些，条件判断都分散到了各个处理类中。

缺点：判定条件都要被执行一遍，当责任链较长时，性能问题严重。

*不要在链中出现循环引用的问题。