设计模式之责任链模式（附实战代码）

请求的链式处理——职责链模式

if(条件1) {
    此时要调用balabalabala类去处理具体的逻辑

} else if (条件2){
    此时要调用dadadadadada类去处理具体的逻辑

} else if (条件3) {
    此时要调用aaaaaaaaaaaa类去处理具体的逻辑
}
           

好这段代码是不是很熟悉呢，对于一些多条件的逻辑处理这应该是很普遍的开发方法了吧，那么会有什么问题呢？

1、耦合度太高，如果条件改变，或者新增条件，就要修改代码，违反了“开闭原则”；

2、各个条件的逻辑处理类，都集中在一个类中，违反了“单一职责原则”，测试和维护难度大。

。。。。。。

好，下面我们进入正题

先来张偷来的图，显着高大上一些，哈哈哈哈

在职责链模式结构图中包含如下几个角色：

● Handler（抽象处理者）：它定义了一个处理请求的接口，一般设计为抽象类，由于不同的具体处理者处理请求的方式不同，因此在其中定义了抽象请求处理方法。因为每一个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象（如结构图中的successor），作为其对下家的引用。通过该引用，处理者可以连成一条链。

● ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

在职责链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

职责链模式的核心在于抽象处理者类的设计，抽象处理者的典型代码如下所示：

public abstract class ChainOfDutyService {

    protected ChainOfDutyService handlerService;//后继者

    public void setHandlerService(ChainOfDutyService handlerService) { //设置后继者
        this.handlerService = handlerService;
    }

    public abstract void processRequest(int count);//处理逻辑的方法
}
           

具体处理者类的典型代码如下：

public class HandlerOneService extends ChainOfDutyService {
    @Override
    public void processRequest(int count) {
        if (count < 100) {
            System.out.println("HandlerOneService处理，count: " + count);
        } else {
            this.handlerService.processRequest(count);
        }
    }
}
           

public class HandlerTwoService extends ChainOfDutyService {
    @Override
    public void processRequest(int count) {
        if (count >= 100 && count < 200) {
            System.out.println("HandlerTwoService处理， count: " + count);
        } else {
//            this.handlerService.processRequest(count);
        }
    }
}
           

职责链模式并不创建职责链，职责链的创建工作必须由系统的其他部分来完成，一般是在使用该职责链的客户端中创建职责链。职责链模式降低了请求的发送端和接收端之间的耦合，使多个对象都有机会处理这个请求。

客户端的典型代码如下：

public class ChainOfDutyController {

    public static void main(String[] args) {
        int count = 150;
        //1、创建具体处理者类(该处可交由Spring管理，省去new创建对象，比较low的方式)
        HandlerOneService handlerOneService = new HandlerOneService();
        HandlerTwoService handlerTwoService = new HandlerTwoService();
        //2、设置责任链
        handlerOneService.setHandlerService(handlerTwoService);
        //3、由首个设置责任链的具体处理类开始调用
        handlerOneService.processRequest(count);
    }
}
           

好啦，如果没看懂就去手动敲一遍吧，很好理解对吧，但是有些注意事项我还是要罗嗦两句，毕竟到了总结发言的时刻

1、客户端也就是控制类在设置后继者的时候不可形成闭环，如果形成闭环，同时条件都不满足，会循环调用至内存溢出
2、客户端也就是控制类在设置后继者的时候最后一个后继者没有else，否则不满足条件是进入else因为无后继者会报错空指针
3、调用处理方法是，要用首个设置后继者的实现类开始调用
           

职责链模式总结

职责链模式通过建立一条链来组织请求的处理者，请求将沿着链进行传递，请求发送者无须知道请求在何时、何处以及如何被处理，实现了请求发送者与处理者的解耦。在软件开发中，如果遇到有多个对象可以处理同一请求时可以应用职责链模式，例如在Web应用开发中创建一个过滤器(Filter)链来对请求数据进行过滤，在工作流系统中实现公文的分级审批等等，使用职责链模式可以较好地解决此类问题。

1.主要优点

职责链模式的主要优点如下：

(1) 职责链模式使得一个对象无须知道是其他哪一个对象处理其请求，对象仅需知道该请求会被处理即可，接收者和发送者都没有对方的明确信息，且链中的对象不需要知道链的结构，由客户端负责链的创建，降低了系统的耦合度。

(2) 请求处理对象仅需维持一个指向其后继者的引用，而不需要维持它对所有的候选处理者的引用，可简化对象的相互连接。

(3) 在给对象分派职责时，职责链可以给我们更多的灵活性，可以通过在运行时对该链进行动态的增加或修改来增加或改变处理一个请求的职责。

(4) 在系统中增加一个新的具体请求处理者时无须修改原有系统的代码，只需要在客户端重新建链即可，从这一点来看是符合“开闭原则”的。

2.主要缺点

职责链模式的主要缺点如下：

(1) 由于一个请求没有明确的接收者，那么就不能保证它一定会被处理，该请求可能一直到链的末端都得不到处理；一个请求也可能因职责链没有被正确配置而得不到处理。

(2) 对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响，而且在进行代码调试时不太方便。

(3) 如果建链不当，可能会造成循环调用，将导致系统陷入死循环。

3.适用场景

在以下情况下可以考虑使用职责链模式：

(1) 有多个对象可以处理同一个请求，具体哪个对象处理该请求待运行时刻再确定，客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及它是如何处理的。

(2) 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

(3) 可动态指定一组对象处理请求，客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序。

实战，正好学习了，就应用在项目中了

/**
 * @auther fanxuebo
 * @desc 责任链模式抽象类
 * @Company 假装加密
 * @create 2018/11/22 13:56
 */
public abstract class ChainOfDutyService {

    protected ChainOfDutyService handlerService;//后继者

    public void setHandlerService(ChainOfDutyService handlerService) { //设置后继者
        this.handlerService = handlerService;
    }

    public abstract void processRequest(CgpCbmRfMain cgpCbmRfMain);//处理逻辑的方法
}
           

/**
 * @auther fanxuebo
 * @desc 责任链模式实现，处理者1
 * @Company 假装加密
 * @create 2018/11/22 13:58
 */
@Service
public class HandlerQuotaAdjServiceImpl extends ChainOfDutyService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HandlerQuotaAdjServiceImpl.class);

    @Transactional
    @Override
    public void processRequest(CgpCbmRfMain cgpCbmRfMain) {
        if ("quotaAdj".equals(cgpCbmRfMain.getApplyType())) {
            略
        } else {
            this.handlerService.processRequest(cgpCbmRfMain);
        }
    }
}
           

/**
 * @auther fanxuebo
 * @desc 责任链模式实现，处理者2
 * @Company 假装加密
 * @create 2018/11/22 14:19
 */
@Service
public class HandlerNewStoreApplyServiceImpl extends ChainOfDutyService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HandlerNewStoreApplyServiceImpl.class);

    @Transactional
    @Override
    public void processRequest(CgpCbmRfMain cgpCbmRfMain) {
        if ("newStoreApply".equals(cgpCbmRfMain.getApplyType())) {
           略
        } else {
            this.handlerService.processRequest(cgpCbmRfMain);
        }
    }
}
           

/**
 * @auther fanxuebo
 * @desc 责任链模式实现，处理者3
 * @Company 假装加密
 * @create 2018/11/22 14:22
 */
@Service
public class HandlerQuotaApplyServiceImpl extends ChainOfDutyService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HandlerNewStoreApplyServiceImpl.class);

    @Transactional
    @Override
    public void processRequest(CgpCbmRfMain cgpCbmRfMain) {
        if ("quotaApply".equals(cgpCbmRfMain.getApplyType())) {
            略
        } else {
            LOGGER.error("不存在的申请类型");
            throw new RuntimeException();
        }
    }
}
           

/**
 * @auther fanxuebo
 * @desc 实际业务类，使用责任链设计模式
 * @Company 假装加密
 * @create 2018/11/23 11:55
 */
@SuppressWarnings("all")
@Service
public class HandlerApprovalServiceImpl implements HandlerApprovalService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HandlerApprovalServiceImpl.class);

    @Autowired
    private HandlerQuotaAdjService handlerQuotaAdjService;
    @Autowired
    private HandlerNewStoreApplyService handlerNewStoreApplyService;
    @Autowired
    private HandlerQuotaApplyService handlerQuotaApplyService;

    /**
     * @Author fanxuebo
     * @Date 2018/11/23 11:59
     * @Description 实际业务方法
     **/
    @Transactional
    @Override
    public CommonResDto toHandlerApproval(CgpCbmRfMain cgpCbmRfMain) {
       略
            //1、创建具体处理者类(该处已交由Spring管理)
            //2、设置责任链
            handlerQuotaAdjService.setHandlerService(handlerNewStoreApplyService);
            handlerNewStoreApplyService.setHandlerService(handlerQuotaApplyService);
            //3、由首个设置责任链的具体处理类开始调用
            handlerQuotaAdjService.processRequest(cgpCbmRfMain);
        
        略
    }
}
           

一直在模仿，一直在超越！