[Python设计模式] 第28章 男人和女人——访问者模式

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

题目

用程序模拟以下不同情况：

• 男人成功时，背后多半有一个伟大的女人；
• 女人成功时，背后多半有一个失败的男人；
• 男人失败时，闷头喝酒，谁也不用劝；
• 女人失败时，眼泪汪汪，谁也劝不了；
• 男人恋爱时，凡事不懂也要装逼；
• 女人恋爱时，遇事懂也装作不懂；

基础版本

from abc import ABCMeta,abstractmethod


class Person():
    
    __metaclass__ = ABCMeta
    
    def __init__(self):
        self.action = None
        
    @abstractmethod
    def get_conclusion(self):
        pass
    
class Man(Person):
    
    def get_conclusion(self):
        if self.action == "成功":
            print("男人成功时，背后多半有一个伟大的女人")
        elif self.action == "失败":
            print("男人失败时，闷头喝酒，谁也不用劝")
        elif self.action == "恋爱":
            print("男人恋爱时，凡事不懂也要装逼")
            
            
class Woman(Person):
    
    def get_conclusion(self):
        if self.action == "成功":
            print("女人成功时，背后多半有一个失败的男人")
        elif self.action == "失败":
            print("女人失败时，眼泪汪汪，谁也劝不了")
        elif self.action == "恋爱":
            print("女人恋爱时，遇事懂也装作不懂")


def main():
    
    persons = []
    man1 = Man()
    man1.action = "成功"
    persons.append(man1)
    woman1 = Woman()
    woman1.action = "成功"
    persons.append(woman1)
    
    man2 = Man()
    man2.action = "失败"
    persons.append(man2)
    woman2 = Woman()
    woman2.action = "失败"
    persons.append(woman2)
    
    man3 = Man()
    man3.action = "恋爱"
    persons.append(man3)
    woman3 = Woman()
    woman3.action = "恋爱"
    persons.append(woman3)
    
    for p in persons:
        p.get_conclusion()
        
main()

男人成功时，背后多半有一个伟大的女人
女人成功时，背后多半有一个失败的男人
男人失败时，闷头喝酒，谁也不用劝
女人失败时，眼泪汪汪，谁也劝不了
男人恋爱时，凡事不懂也要装逼
女人恋爱时，遇事懂也装作不懂

点评

上述代码算是初步的面向对象编程，但是在“Man”和“Woman”中那些“if-else”判断很复杂，如果再增加“结婚”状态，那需要增加分支判断。

这里我们可以使用访问者模式。

访问者模式

访问者模式，表示一个作用于某对象结构中各元素的操作。它使你可以在不改变各元素的类的前提下，定义作用于这些元素的新操作。[DP]

访问者模式的基本代码如下：

from abc import ABCMeta, abstractmethod


class Visitor():
    """
    Visitor类，为该对象结构中ConcretElement的每一个类声明一个Visit操作。
    """
    __metaclass__ = ABCMeta
    
    @abstractmethod
    def visit_concret_element_a(self, concret_element_a):
        pass
    
    @abstractmethod
    def visit_concret_element_b(self, concret_element_b):
        pass
    
    
class ConcretVisitor1(Visitor):
    """
    ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，
    而该算法片段乃是对应于结构中对象的类。
    """
    def visit_concret_element_a(self, concret_element_a):
        print("Visitor1 visit element A")
        
    def visit_concret_element_b(self, concret_element_b):
        print("Visitor1 visit element B")
        
    
class ConcretVisitor2(Visitor):
    """
    同上
    """
    def visit_concret_element_a(self, concret_element_a):
        print("Visitor2 visit element A")
        
    def visit_concret_element_b(self, concret_element_b):
        print("Visitor2 visit element B")
        
        
class Element():
    """
    Element类，定义一个Accept操作，它以一个访问者为参数
    """
    __metaclass__ = ABCMeta
    
    @abstractmethod
    def accept(self, visitor):
        pass
    
    
class ConcretElementA(Element):
    """
    具体元素类，实现Accept操作
    """
    def accept(self, visitor):
        visitor.visit_concret_element_a(self)
        
    def other_functions_a(self):
        pass
    

class ConcretElementB(Element):
    """
    具体元素类，实现Accept操作
    """
    def accept(self, visitor):
        visitor.visit_concret_element_b(self)
        
    def other_functions_b(self):
        pass
    
    
class ObjectStructure():
    """
    ObjectStructure类，能枚举他的元素，可以提供一个高层的接口以允许访问者访问它的元素。
    """
    def __init__(self):
        self.elements = []
        
    def accept(self, visitor):
        for element in self.elements:
            element.accept(visitor)
            
            
def main():
    o = ObjectStructure()
    o.elements.append(ConcretElementA())
    o.elements.append(ConcretElementB())
    
    v1 = ConcretVisitor1()
    v2 = ConcretVisitor2()
    
    o.accept(v1)
    o.accept(v2)
    
main()

Visitor1 visit element A
Visitor1 visit element B
Visitor2 visit element A
Visitor2 visit element B

改进版本——访问者模式

from abc import ABCMeta, abstractmethod


class Action():
    """
    状态抽象类，Visitor类，为该对象结构中ConcretElement的每一个类声明一个Visit操作。
    """
    __metaclass__ = ABCMeta
    
    @abstractmethod
    def get_man_conclusion(self, man):
        pass
    
    @abstractmethod
    def get_woman_conclusion(self, woman):
        pass
    
    
class Success(Action):
    """
    成功状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，
    而该算法片段乃是对应于结构中对象的类。
    """
    def get_man_conclusion(self, man):
        print("男人成功时，背后多半有一个伟大的女人")
        
    def get_woman_conclusion(self, woman):
        print("女人成功时，背后多半有一个失败的男人")
        
    
class Failing(Action):
    """
    失败状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，
    而该算法片段乃是对应于结构中对象的类。
    """
    def get_man_conclusion(self, man):
        print("男人失败时，闷头喝酒，谁也不用劝")
        
    def get_woman_conclusion(self, woman):
        print("女人失败时，眼泪汪汪，谁也劝不了")
        
        
class Amativeness(Action):
    """
    恋爱状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，
    而该算法片段乃是对应于结构中对象的类。
    """
    def get_man_conclusion(self, man):
        print("男人恋爱时，凡事不懂也要装逼")
        
    def get_woman_conclusion(self, woman):
        print("女人恋爱时，遇事懂也装作不懂")
        
        
        
class Person():
    """
    人抽象类，Element类，定义一个Accept操作，它以一个访问者为参数
    """
    __metaclass__ = ABCMeta
    
    @abstractmethod
    def accept(self, visitor):
        pass
    
    
class Man(Person):
    """
    男人类，具体元素类，实现Accept操作
    """
    def accept(self, visitor):
        """
        双分派技术：
        第一次分派：首先在客户端程序中将具体状态作为参数传递给“男人”类完成一次分派；
        第二次分派：然后“男人”类调用作为参数的“具体状态”中的方法“男人反应”，同事将自己(self)作为参数传递进去；
        """
        visitor.get_man_conclusion(self)
        
    def other_functions_a(self):
        pass
    

class Woman(Person):
    """
    女人类，具体元素类，实现Accept操作
    """
    def accept(self, visitor):
        visitor.get_woman_conclusion(self)
        
    def other_functions_b(self):
        pass
    
    
class ObjectStructure():
    """
    ObjectStructure类，能枚举他的元素，可以提供一个高层的接口以允许访问者访问它的元素。
    """
    def __init__(self):
        self.elements = []
        
    def accept(self, visitor):
        for element in self.elements:
            element.accept(visitor)
            
            
def main():
    o = ObjectStructure()
    o.elements.append(Man())
    o.elements.append(Woman())
    
    v1 = Success()
    v2 = Failing()
    v3 = Amativeness()
    
    o.accept(v1)
    print("-"*10)
    o.accept(v2)
    print("-"*10)
    o.accept(v3)
    
main()

print()
print("由于使用了双分派技术，当新增`结婚`状态时，只需要新增一个状态子类，然后修改客户端即可。")
print()

class Marriage(Action):
    
    def get_man_conclusion(self, man):
        print("男人结婚时，有妻徒刑遥无期")
        
    def get_woman_conclusion(self, woman):
        print("女人结婚时，婚姻保险保平安")
        
def main():
    o = ObjectStructure()
    o.elements.append(Man())
    o.elements.append(Woman())
    
    v1 = Success()
    v2 = Failing()
    v3 = Amativeness()
    v4 = Marriage()
    
    o.accept(v1)
    print("-"*10)
    o.accept(v2)
    print("-"*10)
    o.accept(v3)
    print("-"*10)
    o.accept(v4)
    
main()

男人成功时，背后多半有一个伟大的女人
女人成功时，背后多半有一个失败的男人
----------
男人失败时，闷头喝酒，谁也不用劝
女人失败时，眼泪汪汪，谁也劝不了
----------
男人恋爱时，凡事不懂也要装逼
女人恋爱时，遇事懂也装作不懂

由于使用了双分派技术，当新增`结婚`状态时，只需要新增一个状态子类，然后修改客户端即可。

男人成功时，背后多半有一个伟大的女人
女人成功时，背后多半有一个失败的男人
----------
男人失败时，闷头喝酒，谁也不用劝
女人失败时，眼泪汪汪，谁也劝不了
----------
男人恋爱时，凡事不懂也要装逼
女人恋爱时，遇事懂也装作不懂
----------
男人结婚时，有妻徒刑遥无期
女人结婚时，婚姻保险保平安

点评

访问者模式适用于数据结构相对稳定的系统，它把数据结构和作用于数据结构上的操作之间的耦合解脱开，使得操作结合可以相对自由地演化。

访问这模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，那就比较适合使用访问者模式，因为访问者模式使得算法操作的增加变得容易。反之，如果系统的数据结构对象易于变化，经常要有新的数据对象增加进来，就不适合使用访问者模式。

访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。

访问者模式的缺点其实就是增加新的数据结构变得困难了。

GoF四人中的一个作者说过，大多数时候并不需要访问者模式，但当一旦需要访问者模式时，那就是真的需要它了。因为我们很难找到数据结构不变化的情况，所以用访问者模式的机会也就不太多。