• 0

  • 472

从抽象类开始,详解责任链模式

perpetual

python交流

1星期前

大家好,欢迎大家阅读设计模式专题。

今天我们继续介绍新的设计模式,和上次的链式模式不同,这一次要介绍的责任链模式不仅仅在Python当中有,在很多其他的语言当中同样支持,比如Java。Python和Java当中的这个设计模式是完全一样的,没有任何区别。

和之前介绍的设计模式相比,今天介绍的设计模式同样不难。我们非常容易想明白它的原理。

责任链

在我们日常的开发当中,经常会有上下游的依赖,比如当前我们需要开发一份新的数据,需要用到上游的某一份老数据才能生成。这时候需要我们写一个接口,然后上游也随之改造,把它们的新数据写到我们这个接口来。

这就带来了一个问题,也就是上下游耦合的问题,如果下游有一天变动了,上游也需要随着变动。如果是一对一的可能还好,如果一个上游存在多个下游,那么这会是一件很麻烦的事。每一个下游变动了,上游都需要调整。举个最简单的例子,比如下游想要做一个AB测试,想要一半流量进入A机器,一半流量进入B机器。这都需要上游配合。

这当然是很不合理的,在实际当中上游的数据可能是另外一个团队负责的,他们只对数据质量负责,并不一定会愿意配合。并且这样的配合也会导致效率低下。

为了解决这个问题,有了责任链的设计模式。我们把下游的响应方存入一条链路当中,上游在发送请求时不感知下游的接收情况以及相应细节。

说白了,用一句话来概括,就是用链路把下游串起来。我们来看一张图就明白了:

我们把图中的采购人员看成是数据上游的话,它只管提出请求,具体响应的人他是不知道的。根据申请金额的不同,审批的人员也会不一样。但是只会有一个人审批,如果当前人员审批不了就会上报,也就是交由后面一个节点处理。不得不说是非常形象了。

代码实现

那怎么把下游用一条链路串起来呢,其实也很简单,我们可以利用抽象类来实现。比如说我们可以这样:

class Handler:
    def __init__(self, next=None):
        self.next = next
        
    def handle(self, request):
 res = self.do_handle(request)  if not res and self.next:  self.next.handle(request)   def do_handle(self, request):  pass 复制代码

这里的handler就是实现链式调用的关键,在handle当中会首先自己进行处理,如果处理失败那么会调用下一个handle来进行。Handle类中do_handle的方法是抽象方法,我们希望每一个继承Handle的子类都能实现自己的do_handle逻辑。

所以如果是用Java来实现的话,会非常清晰,因为在Java当中有抽象类的相关概念。由于Python原生没有抽象类的相关设定,所以会稍微隐晦一些,但是逻辑是也一样的。

在我们代码实现之前,我们先来介绍一个无关紧要的包。这个包就是Python当中的six,其实这个包也不算是无关紧要,通过它可以写出兼容Python2和Python3的代码。但是实际上由于现在Python2已经快扫进历史的垃圾堆了,所以有没有这个包都没有关系,这里我们还是尊重原作者的代码,保留了这么一个包。我们用这个包作为注解,完成了抽象基类的构建。

抽象基类

首先,我们先来看这个抽象基类。在原生Python当中,其实是没有抽象基类这么一个概念的。抽象基类其实就是含有抽象方法的基类。

我们之前在介绍golang当中interface用法的时候曾经介绍过,我们来简单回忆一下。拿比较常见的Java语言举例。

比如说这是一个抽象基类:

abstract class Mammal {
    abstract void say();
    String name() {
        return "chengzhi";
    }
} 复制代码

对于这个类而言它是不可以直接创建实例的,因为我们可以看出来它有一个什么也没实现的方法say。这个方法前面加了一个关键字abstract即抽象的意思,表示这是一个抽象方法。类名的前面同样加了这个关键字,表示这是一个抽象类。

对于抽象类我们不能直接创建它的实例,我们只能创建实现了抽象类中抽象方法的子类的实例。

比如我们创建一个类实现它:

class Human extends Mammal{
    @override
 public void say() {
  System.out.println("perfect");
 }
} 复制代码

我们可以看出来Human这个类继承了Mammal这个抽象类,并且实现了抽象类当中的方法say。所以我们可以创建它的实例。抽象类是实现多态的一种重要的方法,在强变量类型的语言当中,我们通过抽象类抽象出了多个子类共同的结构。这样我们就可以通过父类的指针调用各种子类的对象了,这是非常方便的。

但是Python当中不支持,为什么Python不支持呢?其实也很简单,因为Python是弱变量类型语言。变量赋值的时候对于类型根本没有限制,我们可以做任何调用。

举个例子,比如我们当下有A、B和C这三个类的实例。哪怕这三个类毫无关系,我们也可以用一个变量去分别接收这些实例然后调用同名的方法。

a = [A(), B(), C()]
for i in a:
    i.say()
复制代码

只要A、B和C这三个类当中都有叫做say的方法,那么上面这段逻辑就不会报错。因此Python非常灵活,可以说是几乎没有限制,那么当然也就没有必要设计这么一个抽象类的设定了。

但问题是我们开发的时候并不是这样的,比如说我们在设计的时候希望能够让类之间有继承的关系,并且希望继承了某个父类的类都能实现某一个方法。由于Python原生没有相关的设定,导致我们很难在编码的排查错误。比如说我们忘记实现了某个方法,由于Python没有编译的过程,我们只有运行到报错的地方才会遇到问题,这显然是不行的,会有很大的隐患。

所以Python开发者想了一个办法就是设计了一个装饰器,叫做abc。这里的abc不是随意起的名字,其实是abstract basement class的缩写。加上了这个装饰器之后,它会替我们去检查所有子类有没有实现抽象方法。如果没有的话,那么会报错提示我们。

我们用上six和abc这两个包之后实现出来的基类是这样的:

import abc
import six


@six.add_metaclass(abc.ABCMeta)
class Handler(object):   def __init__(self, successor=None):  self.successor = successor   def handle(self, request):  res = self.check_range(request)  if not res and self.successor:  self.successor.handle(request)   # 抽象方法  @abc.abstractmethod  def check_range(self, request):  pass 复制代码

实现类

我们把抽象类相关的概念以及责任链的原理理解了之后,就可以很简单地写出来实现类了。

所谓的实现类也就是抽象类的子类,实现了各自的抽象方法。这样我们在每个节点当中调用self.successor.handle的时候才可以执行。因为每一个successor都是继承了同样一个抽象类的实现类,它们都必然实现了handle这个抽象方法。所以整个调用的过程就像是链条一样串联了起来。

在这个例子当中,我们用数字表示每个handler的处理范围。只有落在范围里的请求才会被响应,如果当前handler无法响应,那么就会调用successor的handle继续尝试。

class ConcreteHandler(Handler):

    @staticmethod
    def check_range(request):
        if 0 <= request < 10:
 print('request {} handled in handler 0'.format(request))  return True   class ConcreteHandler1(Handler):   start, end = 10, 20   def check_range(self, request):  if self.start <= request < self.end:  print('request {} handled in handler 1'.format(request))  return True   class ConcreteHandler2(Handler):   def check_range(self, request):  start, end = self.get_interval()  if start <= request < end:  print('request {} handled in handler 2'.format(request))  return True   @staticmethod  def get_interval():  return (20, 30)   class FallBackHandler(Handler):   @staticmethod  def check_range(request):  print('end of chain, no handler for {}'.format(request))  return False 复制代码

这里要注意一下FallBackHandler这个类,这个类表示责任链的结尾,也就是它是最后一个节点。如果请求一直穿过前面的节点送到了它这里,就表示前面没有相应的handler,这个请求无法响应。

最后我们来看下实际运行的例子:

if __name__ == '__main__':
    h0 = ConcreteHandler()
    h1 = ConcreteHandler1()
    h2 = ConcreteHandler2(FallBackHandler())
    h0.successor = h1
 h1.successor = h2   requests = [2, 5, 14, 22, 18, 3, 35, 27, 20]  for x in requests:  h0.handle(x) 复制代码

我们可以看到我们创建了一系列handler的实例,然后将它们串联了起来。如果我们运行这段代码的话会发现我们不同的请求被不同的handler响应了。

到这里关于责任链这个设计模式的介绍就结束了,这个设计模式非常巧妙,将上游和下游分裂开来,彼此之间消除了耦合。但是这也并不是完美的,它也有自己的缺点,一个很明显的缺点就是这样的效率会比较低。因为一层层链路传递都是需要时间的,尤其是这些链路如果还要远程调用的话,那么每一层转换都会有延迟以及相应时间,所以整个系统的效率可能会不高。

还有呢就是我们调试的时候可能会不太方便,错误不太容易排查。除此之外还有一些其他的优缺点,大家可以自己思考一下,在下方留言。

衷心祝愿大家每天都有所收获。如果还喜欢今天的内容的话,请来一个三连支持吧~(点赞、关注、转发

原文链接,求个关注

本文使用 mdnice 排版

- END -

免责声明:文章版权归原作者所有,其内容与观点不代表Unitimes立场,亦不构成任何投资意见或建议。

Python

472

相关文章推荐

未登录头像

暂无评论