`访问者`模式：如何使用`Python`在不修改`对象`类的情况下`添加`新操作。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

访问者模式：在Python中优雅地扩展对象行为

大家好，今天我们要深入探讨一个非常实用的设计模式——访问者模式（Visitor Pattern）。它允许我们在不修改对象类结构的前提下，为一个对象结构（例如，一个树形结构）中的对象添加新的操作。这在需要频繁扩展对象行为，但又不希望修改现有类的情况下，尤其有用。

1. 模式动机：解耦行为与对象结构

在软件开发中，我们经常会遇到这样的场景：需要对一组对象执行多种不同的操作。如果将这些操作直接添加到对象类中，会导致类变得臃肿且难以维护。更糟糕的是，如果这些操作的逻辑经常变化，那么每次修改对象类都需要进行测试和部署，风险很高。

访问者模式的核心思想是将这些操作从对象类中分离出来，放到一个独立的“访问者”类中。这样，当我们需要添加新的操作时，只需要创建一个新的访问者类，而无需修改现有的对象类。这大大提高了代码的可维护性和可扩展性。

2. 模式结构：角色与职责

访问者模式主要包含以下几个角色：

Visitor（访问者）：定义了访问对象结构中每个元素的接口。通常，每个具体元素都有一个对应的visit方法。
ConcreteVisitor（具体访问者）：实现了Visitor接口，定义了对对象结构中每个元素的具体操作。
Element（元素）：定义了accept方法，用于接受访问者的访问。
ConcreteElement（具体元素）：实现了Element接口，具体表示对象结构中的元素。在accept方法中，它会调用访问者的visit方法，并将自身作为参数传递给访问者。
ObjectStructure（对象结构）：维护一个包含Element对象的集合。它提供一个方法，允许访问者访问集合中的每个元素。

可以用一张表来清晰地展示这些角色：

角色	职责
Visitor	定义了访问对象结构中每个元素的接口（`visit`方法）。
ConcreteVisitor	实现了Visitor接口，为对象结构中的每个元素定义了具体的访问操作。
Element	定义了`accept(visitor)`方法，用于接受访问者的访问。
ConcreteElement	实现了Element接口。在`accept`方法中，调用`visitor.visit(self)`，将自身传递给访问者。
ObjectStructure	维护一个Element对象的集合，并提供一个`accept(visitor)`方法，遍历集合中的所有元素，并调用每个元素的`accept(visitor)`方法，让访问者访问它们。

3. 模式实现：Python代码示例

让我们通过一个具体的例子来演示如何在Python中使用访问者模式。假设我们有一个表示几何图形的类结构，包含圆形（Circle）、矩形（Rectangle）和三角形（Triangle）。我们希望能够对这些图形进行不同的操作，例如计算面积、计算周长、绘制图形等。

首先，定义Element接口：

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def accept(self, visitor):
        pass

然后，定义具体的Element类：

import math

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def accept(self, visitor):
        visitor.visit_circle(self)

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def accept(self, visitor):
        visitor.visit_rectangle(self)

class Triangle(Shape):
    def __init__(self, base, height, side1, side2):
        self.base = base
        self.height = height
        self.side1 = side1
        self.side2 = side2

    def accept(self, visitor):
        visitor.visit_triangle(self)

接下来，定义Visitor接口：

from abc import ABC, abstractmethod

class ShapeVisitor(ABC):
    @abstractmethod
    def visit_circle(self, circle):
        pass

    @abstractmethod
    def visit_rectangle(self, rectangle):
        pass

    @abstractmethod
    def visit_triangle(self, triangle):
        pass

现在，定义具体的Visitor类，例如计算面积的访问者：

class AreaCalculator(ShapeVisitor):
    def visit_circle(self, circle):
        area = math.pi * circle.radius * circle.radius
        print(f"Circle area: {area}")

    def visit_rectangle(self, rectangle):
        area = rectangle.width * rectangle.height
        print(f"Rectangle area: {area}")

    def visit_triangle(self, triangle):
        area = 0.5 * triangle.base * triangle.height
        print(f"Triangle area: {area}")

再定义一个具体的Visitor类，例如计算周长的访问者：

class PerimeterCalculator(ShapeVisitor):
    def visit_circle(self, circle):
        perimeter = 2 * math.pi * circle.radius
        print(f"Circle perimeter: {perimeter}")

    def visit_rectangle(self, rectangle):
        perimeter = 2 * (rectangle.width + rectangle.height)
        print(f"Rectangle perimeter: {perimeter}")

    def visit_triangle(self, triangle):
        perimeter = triangle.base + triangle.side1 + triangle.side2
        print(f"Triangle perimeter: {perimeter}")

最后，定义ObjectStructure类：

class ShapeStructure:
    def __init__(self):
        self.shapes = []

    def add_shape(self, shape):
        self.shapes.append(shape)

    def accept(self, visitor):
        for shape in self.shapes:
            shape.accept(visitor)

使用示例：

# 创建一些图形对象
circle = Circle(5)
rectangle = Rectangle(4, 6)
triangle = Triangle(3, 4, 5, 5)

# 创建对象结构
structure = ShapeStructure()
structure.add_shape(circle)
structure.add_shape(rectangle)
structure.add_shape(triangle)

# 创建访问者对象
area_calculator = AreaCalculator()
perimeter_calculator = PerimeterCalculator()

# 访问对象结构
print("Calculating areas:")
structure.accept(area_calculator)

print("nCalculating perimeters:")
structure.accept(perimeter_calculator)

这个示例展示了如何使用访问者模式来计算不同形状的面积和周长，而无需修改Circle、Rectangle和Triangle类。如果我们需要添加新的操作，例如绘制图形，只需要创建一个新的ShapeVisitor的子类即可。

4. 模式优点：灵活扩展，解耦对象行为

访问者模式的主要优点包括：

易于扩展： 可以很容易地添加新的操作，而无需修改现有的对象类。这符合开闭原则。
解耦对象行为： 将操作从对象类中分离出来，使得对象类更加简洁和易于维护。
提高代码复用性： 不同的访问者可以复用相同的对象结构。
集中相关操作： 将相关的操作集中在一个访问者类中，使得代码更易于理解和维护。

5. 模式缺点：增加复杂性，违反单一职责原则

访问者模式也存在一些缺点：

增加代码复杂性： 引入了访问者和元素等多个角色，增加了代码的复杂性。
违反单一职责原则： 访问者类可能需要处理多个不同类型的元素，这可能导致访问者类变得臃肿。
对象结构变化敏感： 如果对象结构发生变化（例如，添加了新的元素类型），那么需要修改所有的访问者类。
不易于添加新的元素： 如果需要添加新的元素类型，需要修改Visitor接口和所有具体的Visitor类，这可能会带来较大的工作量。

6. 适用场景：何时使用访问者模式

访问者模式适用于以下场景：

需要对一个对象结构中的对象执行多种不同的操作，且这些操作的逻辑经常变化。
对象结构比较稳定，但需要经常添加新的操作。
需要对对象结构中的对象执行一些与对象本身无关的操作，例如统计信息、数据转换等。
当一个对象结构包含许多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。

7. 模式变体：双重分派

访问者模式的核心是双重分派（Double Dispatch）。传统的单分派（例如，Java或Python中的方法调用）是基于调用方法的对象类型来决定执行哪个方法。双重分派则是在单分派的基础上，再根据被调用方法的参数类型来决定执行哪个方法。

在访问者模式中，第一次分派发生在shape.accept(visitor)，根据shape的实际类型（例如，Circle、Rectangle）来决定调用哪个accept方法。第二次分派发生在visitor.visit_circle(self)，根据visitor的实际类型（例如，AreaCalculator、PerimeterCalculator）以及circle的类型来决定调用哪个visit方法。

双重分派使得我们可以在运行时根据对象和访问者的类型来动态地选择执行哪个操作。

8. 与其他模式的关系：访问者与迭代器

访问者模式通常与迭代器模式一起使用。迭代器模式用于遍历对象结构中的元素，而访问者模式用于对这些元素执行操作。对象结构可以使用迭代器来提供一个统一的访问接口，允许访问者遍历结构中的所有元素。

例如，在上面的例子中，ShapeStructure可以使用迭代器来遍历其中的Shape对象。这样，访问者就可以通过迭代器来访问对象结构中的每个元素，而无需关心对象结构的具体实现。

9. 模式的优缺点权衡

优点	缺点
易于添加新操作，符合开闭原则	代码复杂性增加，引入多个角色
解耦对象行为，对象类更加简洁	可能违反单一职责原则，访问者类可能过于臃肿
提高代码复用性，不同的访问者可以复用相同的对象结构	对象结构变化敏感，添加新的元素类型需要修改所有访问者类
集中相关操作，代码更易于理解和维护

10. 总结与思考

访问者模式是一种强大的设计模式，它可以帮助我们优雅地扩展对象行为，而无需修改现有的对象类。然而，它也增加了代码的复杂性，并且对对象结构的变化比较敏感。因此，在使用访问者模式时，需要仔细权衡其优缺点，并根据具体的应用场景做出选择。当需要经常添加新的操作，并且对象结构相对稳定时，访问者模式是一个不错的选择。理解双重分派的概念是掌握访问者模式的关键。