架构与系统设计 / 系统课时

访问者分离结构与新增操作

访问者分离结构与新增操作

当一组对象的类型结构长期稳定,但围绕这些对象的操作不断增加时,把行为继续塞进各个类会让修改越来越分散。访问者模式把“对不同具体类型执行什么”集中到独立访问者中,适合报表、导出、校验等横切操作,同时也要接受双分派带来的耦合成本。

学习目标

  • 判断“结构稳定、操作常变”的场景是否适合访问者模式。
  • 理解 accept 与重载 visit 如何共同完成双分派。
  • 看清新增访问者与新增元素类型时不同的修改成本。

先识别真正的变化方向

访问者模式解决的不是“类太多”,而是操作增加时改动散落在整个对象结构中。假设语法树已经稳定包含 NumberNode、AddNode 等节点,但后续会不断增加打印、求值、类型检查、代码生成操作。若每个节点都实现这些行为,节点类会持续膨胀。

访问者把两类变化拆开:元素类只负责结构和最小业务数据,访问者负责一组相关操作。这样新增一种操作时,通常只新增一个访问者,而不必修改每个元素类。

双分派是怎样发生的

普通虚方法调用只根据接收者运行时类型选择实现。访问者需要同时根据“元素实际类型”和“访问者实现”决定执行逻辑,因此采用两次动态分派:先调用具体元素的 accept,再由元素把 this 传给访问者的重载 visit。

访问者模式双分派调用关系

下面的 Java 示例把“打印表达式”和“计算结果”从节点类中拆出去。节点结构不需要知道具体操作细节。

java
public class VisitorDemo {
    interface Node {
        void accept(Visitor visitor);
    }

    static final class NumberNode implements Node {
        final int value;

        NumberNode(int value) {
            this.value = value;
        }

        @Override
        public void accept(Visitor visitor) {
            visitor.visit(this);
        }
    }

    static final class AddNode implements Node {
        final Node left;
        final Node right;

        AddNode(Node left, Node right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public void accept(Visitor visitor) {
            visitor.visit(this);
        }
    }

    interface Visitor {
        void visit(NumberNode node);
        void visit(AddNode node);
    }

    static final class PrintVisitor implements Visitor {
        private final StringBuilder out = new StringBuilder();

        @Override
        public void visit(NumberNode node) {
            out.append(node.value);
        }

        @Override
        public void visit(AddNode node) {
            out.append("(");
            node.left.accept(this);
            out.append(" + ");
            node.right.accept(this);
            out.append(")");
        }

        String result() {
            return out.toString();
        }
    }

    static final class EvalVisitor implements Visitor {
        private int value;

        @Override
        public void visit(NumberNode node) {
            value = node.value;
        }

        @Override
        public void visit(AddNode node) {
            node.left.accept(this);
            int left = value;
            node.right.accept(this);
            int right = value;
            value = left + right;
        }

        int result() {
            return value;
        }
    }

    public static void main(String[] args) {
        Node expression = new AddNode(
                new NumberNode(7),
                new AddNode(new NumberNode(2), new NumberNode(3)));

        PrintVisitor printer = new PrintVisitor();
        expression.accept(printer);

        EvalVisitor evaluator = new EvalVisitor();
        expression.accept(evaluator);

        System.out.println(printer.result());
        System.out.println(evaluator.result());
    }
}

预期输出

text
(7 + (2 + 3))
12

新增操作为什么便宜

如果现在增加“统计节点数量”的需求,只需实现新的 Visitor,元素结构完全不动。访问者把同一操作针对所有元素类型的逻辑集中到一个类里,因此更容易审查完整性,也避免把报表、序列化、校验等外部职责塞回领域对象。

但这种集中也意味着访问者通常需要知道具体元素的公开数据。若为了让访问者工作而大量暴露内部状态,封装性会下降。此时可以让元素提供更窄的查询接口,而不是直接暴露可变字段。

什么时候该换一种设计

当对象结构和操作都频繁变化时,访问者会变得笨重;新增元素要同步修改所有访问者,新增操作又要增加新的访问者。对于只有两三个简单分支的场景,普通多态或策略模式通常更直接。

判断是否采用访问者时,先看变化轴:元素集合长期稳定、操作持续增加时收益最大;如果元素集合才是主要变化点,就应优先保持元素扩展开放,而不是把所有访问者绑定到固定类型集合上。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

访问者分离结构与新增操作

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通