[设计模式]职责链模式

开始写设计模式系列,希望自己可以坚持下来.

第七篇:职责链模式

什么是职责链模式

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

简易实现

Talk is cheap,我们来看下最为简易的职责链实现。

抽象的处理者：

package top.huyuxin.ChainofResponsibility;

public abstract class Handler {
public Handler nextHandler;

public abstract void handleRequest(String condition);
}

具体的处理者：

package top.huyuxin.ChainofResponsibility;

public class FirstHandler extends Handler {

@Override
public void handleRequest(String condition) {
if("first".equals(condition)){
System.out.println("firsthandler capture it!");
}else{
nextHandler.handleRequest(condition);
}
}

}

package top.huyuxin.ChainofResponsibility;

public class SecondHandler extends Handler {

@Override
public void handleRequest(String condition) {
if("second".equals(condition)){
System.out.println("secondhandler capture it!");
}else{
nextHandler.handleRequest(condition);
}
}
}

package top.huyuxin.ChainofResponsibility;

public class ThirdHandler extends Handler {

@Override
public void handleRequest(String condition) {
if("third".equals(condition)){
System.out.println("thirdhandler capture it!");
}else{
System.out.println("no one can capture it!");
}
}

}

使用：

package top.huyuxin.ChainofResponsibility;

public class Main {

public static void main(String[] args) {
Handler firstHandler = new FirstHandler();
Handler secondHandler = new SecondHandler();
Handler thirdHandler = new ThirdHandler();
firstHandler.nextHandler=secondHandler;
secondHandler.nextHandler=thirdHandler;

firstHandler.handleRequest("first");
System.out.println("-----------");
firstHandler.handleRequest("second");
System.out.println("-----------");
firstHandler.handleRequest("third");
System.out.println("-----------");
firstHandler.handleRequest("four");

}

}

输出：

firsthandler capture it!
-----------
secondhandler capture it!
-----------
thirdhandler capture it!
-----------
no one can capture it!

这就是简易的职责链，结构特别的简单，但是问题来了，对于稳定运行的代码他的职责链应该是相对固定的，那么难道我们每次使用都要new出每一个处理者并建立职责链吗？我们可以建立一个管理类将这个过程封装起来

package top.huyuxin.ChainofResponsibility;

public class HandlerManger {

private HandlerManger() {
super();
}

public static class HandlerManagerInstance{
private static HandlerManger instance=new HandlerManger();
public static HandlerManger getInstance() {
return instance;
}
}

private static Handler firstHandler;
private static Handler secondHandler;
private static Handler thirdHandler;

static{
firstHandler = new FirstHandler();
secondHandler = new SecondHandler();
thirdHandler = new ThirdHandler();
}

public void handleRequest(String condition){

firstHandler.nextHandler=secondHandler;
secondHandler.nextHandler=thirdHandler;
firstHandler.handleRequest(condition);
}

}

调用：

package top.huyuxin.ChainofResponsibility;

public class Main {

public static void main(String[] args) {

HandlerManger handlerManger = HandlerManger.HandlerManagerInstance.getInstance();

handlerManger.handleRequest("first");
System.out.println("-----------");
handlerManger.handleRequest("second");
System.out.println("-----------");
handlerManger.handleRequest("third");
System.out.println("-----------");
handlerManger.handleRequest("four");

}

结果是一致的，。

实战

在实际的项目中请求条件的匹配简单的字符串判断是远远不够的，

我们需要将请求类也抽象出来。

抽象请求类：

package top.huyuxin.ChainofResponsibility.plus;

public abstract class AbstrastRequest {
//定义统一的请求级别
public static final int FIRST_REQUEST=1;
public static final int SECOND_REQUEST=2;
public static final int THIRD_REQUEST=3;
//可有可无，用于开发者创建请求时传入个性化且必要的初始化参数
private Object object;

public AbstrastRequest(Object object){
this.object=object;
}
//获取对应的参数
public Object getContent(){
return object;
}

public abstract int getRequestLevel();

}

具体的请求：

package top.huyuxin.ChainofResponsibility.plus;

import org.omg.CORBA.Request;

public class FirstRequest extends AbstrastRequest {

public FirstRequest(String name) {
super(name);
}

@Override
public int getRequestLevel() {
return FIRST_REQUEST;
}

@Override
public String toString() {
return "FirstRequest [name=" + getContent() + ", getRequestLevel()=" + getRequestLevel() + "]";
}
}

package top.huyuxin.ChainofResponsibility.plus;

public class SecondRequest extends AbstrastRequest {

public SecondRequest(int initflag) {
super(initflag);
}

@Override
public int getRequestLevel() {
return SECOND_REQUEST;
}

@Override
public String toString() {
return "SecondRequest [initflag=" + getContent() + ", getRequestLevel()=" + getRequestLevel() + "]";
}
}

package top.huyuxin.ChainofResponsibility.plus;

public class ThirdRequest extends AbstrastRequest {

public ThirdRequest(Boolean flag) {
super(flag);
}

@Override
public int getRequestLevel() {
return THIRD_REQUEST;
}

@Override
public String toString() {
return "ThirdRequest [flag=" + false + ", getRequestLevel()=" + getRequestLevel() + "]";
}

}

抽象的处理类：

package top.huyuxin.ChainofResponsibility.plus;

public abstract class AbstractHandler {

protected AbstractHandler nextHandler;

public final void handlerRequest(AbstrastRequest request){
if(getHandleLevel()==request.getRequestLevel()){
handle(request);
}else {
if(nextHandler!=null){
nextHandler.handle(request);
}else{
System.out.println("no handler can deal with the request!");
}
}
}

protected abstract int getHandleLevel();

protected abstract void handle(AbstrastRequest request);

}

具体的处理类：

package top.huyuxin.ChainofResponsibility.plus;

public class FirstHandler extends AbstractHandler {

@Override
protected int getHandleLevel() {
return AbstrastRequest.FIRST_REQUEST;
}

@Override
protected void handle(AbstrastRequest request) {
System.out.println("i can deal with the request:"+request.toString());
}

}

package top.huyuxin.ChainofResponsibility.plus;

public class SecondHandler extends AbstractHandler {

@Override
protected int getHandleLevel() {
return AbstrastRequest.SECOND_REQUEST;
}

@Override
protected void handle(AbstrastRequest request) {
System.out.println("i can deal with the request:"+request.toString());
}

}

package top.huyuxin.ChainofResponsibility.plus;

public class ThirdHandler extends AbstractHandler {

@Override
protected int getHandleLevel() {
return AbstrastRequest.THIRD_REQUEST;
}

@Override
protected void handle(AbstrastRequest request) {
System.out.println("i can deal with the request:"+request.toString());
}

}

职责链管理器：

package top.huyuxin.ChainofResponsibility.plus;

public class HandlerManger {

private HandlerManger() {
super();
}

public static class HandlerManagerInstance{
private static HandlerManger instance=new HandlerManger();
public static HandlerManger getInstance() {
return instance;
}
}

private static AbstractHandler firstHandler;
private static AbstractHandler secondHandler;
private static AbstractHandler thirdHandler;

static{
firstHandler = new FirstHandler();
secondHandler = new SecondHandler();
thirdHandler = new ThirdHandler();
}

public void handleRequest(AbstrastRequest request){

firstHandler.nextHandler=secondHandler;
secondHandler.nextHandler=thirdHandler;
firstHandler.handlerRequest(request);
}

}

调用：

package top.huyuxin.ChainofResponsibility.plus;

public class Main {

public static void main(String[] args) {
HandlerManger handlerManger=HandlerManger.HandlerManagerInstance.getInstance();

FirstRequest firstRequest=new FirstRequest("FirstRequest");
SecondRequest secondRequest=new SecondRequest(2);
ThirdRequest thirdRequest=new ThirdRequest(true);

handlerManger.handleRequest(firstRequest);
handlerManger.handleRequest(secondRequest);
handlerManger.handleRequest(thirdRequest);

}

}

结果：

i can deal with the request:FirstRequest [name=FirstRequest, getRequestLevel()=1]
i can deal with the request:SecondRequest [initflag=2, getRequestLevel()=2]
i can deal with the request:ThirdRequest [flag=false, getRequestLevel()=3]

我们将请求分离了出来丰富了请求的内容，使得能够在请求体内携带更多的信息。这些信息能够在请求的初始化以及处理类的处理中提供很大的帮助，并且我们将处理请求方法（handle）与请求分发分离（handlerRequest），使得逻辑更加的清晰。

职责链模式是比较简单的行为模式，他和状态模式比起来相似之处很多，但是又截然不同。

参考《Android源码设计模式解析与实战》中第九章–使编程更有灵活性——职责链模式