设计模式---职责链（Chain Of Responsibility）

本文链接：https://blog.csdn.net/jdhellfire/article/details/90801249

一.需求的提出：

研发流程中，一个缺陷的生命周期如下：

提交缺陷（测试人员）->CCB审核(CCB)->开发团队审核(SM)->解决缺陷(开发人员)

现尝试编写一段Demo代码来示意，这个处理过程。

二.无设计的实现版本：

class Handler:
    def __init__(self, role):
        self._role = role

    def deal_with_bug(self, bug):
        # 处理逻辑简单示意一下
        if self._role == 'Tester':
            print('Tester:提交缺陷:%s' % bug)
        elif self._role == 'CCB':
            print('CCB:缺陷审核通过:%s' % bug)
        elif self._role == 'SM':
            print('SM:开发团队指派解决:%s' % bug)
        else:
            print('DEV:解决缺陷:%s' % bug)

if __name__ == '__main__':
    Bug = "传输建链失败"

    Tester = Handler('Tester')
    CCB = Handler('CCB')
    SM = Handler('SM')
    DEV = Handler('DEV')

    Tester.deal_with_bug(Bug)
    CCB.deal_with_bug(Bug)
    SM.deal_with_bug(Bug)
    DEV.deal_with_bug(Bug)

存在的问题：

违背开放封闭原则：
Handler类如果在需求发生变更需要引入更多的处理角色的时候，难免需要对deal_with_bug函数进行修改。实例代码逻辑简单可能感觉不出有太大危害，但是如果是代码逻辑复杂的工程项目则有引入缺陷的风险。
违背单一职责原则：
Handler类职责过多，几种角色的处理逻辑全部塞到deal_with_bug一个函数中。

三.驱动表的方式进行重构:

在面向过程编程的泛型中，驱动表是常用的抽象方式。针对deal_with_bug函数中由于if…else结构。采用驱动表的方式进行抽象。并将不同角色的处理动作的实现也从deal_with_bug函数中抽离，从而解决了单一职责问题和一定的开放封闭原则问题。

但驱动表的dict结构，在新需求引入的时候还是会存在一定的修改。

def tester_deal(bug):
    print('Tester:提交缺陷:%s' % bug)


def ccb_deal(bug):
    print('CCB:缺陷审核通过:%s' % bug)


def sm_deal(bug):
    print('SM:开发团队指派解决:%s' % bug)


def dev_deal(bug):
    print('DEV:解决缺陷:%s' % bug)


deal = \
    {
        'Tester': tester_deal,
        'CCB': ccb_deal,
        'SM': sm_deal,
        'DEV': dev_deal
    }


class Handler:
    def __init__(self, role):
        self._role = role

    def deal_with_bug(self, bug):
        deal[self._role](bug)


if __name__ == '__main__':
    Bug = "传输建链失败"

    Tester = Handler('Tester')
    CCB = Handler('CCB')
    SM = Handler('SM')
    DEV = Handler('DEV')

    Tester.deal_with_bug(Bug)
    CCB.deal_with_bug(Bug)
    SM.deal_with_bug(Bug)
    DEV.deal_with_bug(Bug)

四职责链方式重构：

职责链 是在多个对象都有机会处理同一个请求的情况下，为了避免对象之间的耦合将处理对象串成一条链，将请求在链中依次传递并处理。

在这里插入图片描述

from abc import ABCMeta, abstractmethod


class Handler(metaclass=ABCMeta):
    def __init__(self):
        self._next = None

    def set_next_handler(self, next_handler):
        self._next = next_handler

    @abstractmethod
    def deal_with(self, bug):
        pass


class Tester(Handler):
    def deal_with(self, bug):
        print('Tester:提交缺陷:%s' % bug)
        self._next.deal_with(bug)


class CCB(Handler):
    def deal_with(self, bug):
        print('CCB:缺陷审核通过:%s' % bug)
        self._next.deal_with(bug)


class SM(Handler):
    def deal_with(self, bug):
        print('SM:开发团队指派解决:%s' % bug)
        self._next.deal_with(bug)


class DEV(Handler):
    def deal_with(self, bug):
        print('DEV:解决缺陷:%s' % bug)


if __name__ == '__main__':
    Bug = "传输建链失败"

    tester = Tester()
    ccb = CCB()
    sm = SM()
    dev = DEV()
	
	#定义职责链
    sm.set_next_handler(dev)
    ccb.set_next_handler(sm)
    tester.set_next_handler(ccb)
	
	#从链首触发职责链上的所有节点进行处理
    tester.deal_with(Bug)

可以看到通过职责链方式重构以后，面向对象的味道更浓，新需求引入后，也不存在对原有对象的任何修改，开放封闭原则也遵守得更好。