[Python设计模式] 第24章 加薪审批——职责链模式

  • Z时代
  • 2024-01-10
  • 分类：综合

python

github地址:https://github.com/cheesezh/python_design_patterns

题目

用程序模拟以下情景

  • 员工向经理发起加薪申请，经理无权决定，需要向总监汇报，加薪额度超过总监权力范围，需要向总经理汇报;

  • 员工还可以提交请加申请，经理可以决定2天以下的假，总监可以决定5天以下的假，其余都要上报总经理;

基础版本

class Request():
    def __init__(self):
        self.type = None  # 申请类型
        self.content = None  # 申请内容
        self.number = 0  # 申请数量
class Manager():
    def __init__(self, name):
        self.name = name
    def get_result(self, manager_level, request):
        if manager_level == "经理":
            if request.type == "请假" and request.number <=2:
                print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
            else:
                print("{}:{} 数量 {} 我无权处理".format(self.name, request.content, request.number))
        elif manager_level == "总监":
            if request.type == "请假" and request.number <=5:
                print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
            else:
                print("{}:{} 数量 {} 我无权处理".format(self.name, request.content, request.number))
        elif manager_level == "总经理":
            if request.type == "请假":
                print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
            elif request.type == "加薪" and request.number <= 500:
                print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
            elif request.type == "加薪" and request.number > 500:
                print("{}:{} 数量 {} 再说吧".format(self.name, request.content, request.number))
def main():
    jingli = Manager("经理")
    zongjian = Manager("总监")
    zongjingli = Manager("总经理")
    request = Request()
    request.type = "加薪"
    request.content = "贺贺请求加薪"
    request.number = 1000
    jingli.get_result(jingli.name, request)
    zongjian.get_result(zongjian.name, request)
    zongjingli.get_result(zongjingli.name, request)
    request.type = "请假"
    request.content = "贺贺请求请假"
    request.number = 3
    jingli.get_result(jingli.name, request)
    zongjian.get_result(zongjian.name, request)
    zongjingli.get_result(zongjingli.name, request)
main()

经理:贺贺请求加薪 数量 1000 我无权处理
总监:贺贺请求加薪 数量 1000 我无权处理
总经理:贺贺请求加薪 数量 1000 再说吧
经理:贺贺请求请假 数量 3 我无权处理
总监:贺贺请求请假 数量 3 被批准
总经理:贺贺请求请假 数量 3 被批准

点评

  • Manager类的get_result方法比较长，有太多的分支判断，不是好的设计；

  • Mangeer类有太多的责任，违背了单一职责的原则，增加新的管理者，需要修改这个类，违背了开放封闭原则；

职责链模式

职责链模式，使得多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，知道有一个对象处理它为止[DP]。

职责链模式基本结构

from abc import ABCMeta, abstractmethod
class Handler():
    __metaclass__ = ABCMeta
    def __init__(self):
        self.successor = None  # 设置继任者
    @abstractmethod
    def handle_request(self, request):
        pass
class ConcretHandler1(Handler):
    """
    处理0-10的请求
    """
    def handle_request(self, request):
        if request >=0 and request < 10:
            print("handler1 handle request [ {} ]".format(request))
        elif self.successor != None:  # 由继任者处理请求
            self.successor.handle_request(request)
class ConcretHandler2(Handler):
    """
    处理10-20的请求
    """
    def handle_request(self, request):
        if request >=10 and request < 20:
            print("handler2 handle request [ {} ]".format(request))
        elif self.successor != None:  # 由继任者处理请求
            self.successor.handle_request(request)
class ConcretHandler3(Handler):
    """
    处理20-30的请求
    """
    def handle_request(self, request):
        if request >=20 and request < 30:
            print("handler3 handle request [ {} ]".format(request))
        elif self.successor != None:  # 由继任者处理请求
            self.successor.handle_request(request)
def main():
    h1 = ConcretHandler1()
    h2 = ConcretHandler2()
    h3 = ConcretHandler3()
    h1.successor = h2
    h2.successor = h3
    requests = [2, 5, 14, 22, 18, 3, 27, 20]
    for i in requests:
        h1.handle_request(i)
main()

handler1 handle request [ 2 ]
handler1 handle request [ 5 ]
handler2 handle request [ 14 ]
handler3 handle request [ 22 ]
handler2 handle request [ 18 ]
handler1 handle request [ 3 ]
handler3 handle request [ 27 ]
handler3 handle request [ 20 ]

点评

  • 当客户提交一个请求时，请求是沿着职责链传递直至有一个ConcretHandler对象负责处理它

  • 接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构

  • 职责链可以简化对象的相互链接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接收者的引用

  • 可以随时增加或修改处理一个请求的结构，增强了给对象指派职责的灵活性

  • 一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理

  • 最重要的两点

    • 需要实现给每个具体管理者设置它的上司，也就是它的后继者

    • 需要在每个具体管理者类处理请求时，做出判断，是可以处理请求，还是必须“推卸责任”，转移到后继者

职责链模式——加薪代码

from abc import ABCMeta, abstractmethod
class Manager():
    __metaclass__ = ABCMeta
    def __init__(self, name):
        self.name = name
        self.successor = None
    @abstractmethod
    def handle_request(self, request):
        pass
class CommonManager(Manager):
    def handle_request(self, request):
        if request.type == "请假" and request.number <=2:
            print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
        elif self.successor != None:
            self.successor.handle_request(request)
class Majordomo(Manager):
    def handle_request(self, request):
        if request.type == "请假" and request.number <=5:
            print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
        elif self.successor != None:
            self.successor.handle_request(request)
class GeneralManager(Manager):
    def handle_request(self, request):
        if request.type == "请假":
            print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
        elif request.type == "加薪" and request.number <= 500:
            print("{}:{} 数量 {} 被批准".format(self.name, request.content, request.number))
        elif request.type == "加薪" and request.number > 500:
            print("{}:{} 数量 {} 再说吧".format(self.name, request.content, request.number))
def main():
    jingli = CommonManager("经理")
    zongjian = Majordomo("总监")
    zongjingli = GeneralManager("总经理")
    jingli.successor = zongjian
    zongjian.successor = zongjingli
    request = Request()
    request.type = "加薪"
    request.content = "贺贺请求加薪"
    request.number = 1000
    jingli.handle_request(request)
    request.type = "请假"
    request.content = "贺贺请求请假"
    request.number = 3
    jingli.handle_request(request)
main()

总经理:贺贺请求加薪 数量 1000 再说吧
总监:贺贺请求请假 数量 3 被批准

职责链模式和状态模式

  • 职责链模式，主要处理requet和handler的问题，当handler收到requet时，判断是否自己是否可以处理，处理逻辑在handler中；

  • 状态模式，主要处理state和context的问题，当state变化时，改变context的state，继续调用context的处理逻辑，处理逻辑在context中；

以上是 [Python设计模式] 第24章 加薪审批——职责链模式 的全部内容， 来源链接： utcz.com/z/389231.html

回到顶部