设计模式详解-访问者模式
设计模式详解：访问者模式
一、模式概述
访问者模式（Visitor Pattern）是行为型设计模式中最具扩展性的模式，其核心意图在于表示一个作用于某对象结构中的各元素的操作，使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。这一模式将数据结构与作用于结构上的操作解耦，使得新增操作变得容易，无需修改既有元素类。
访问者模式的命名揭示了其本质——"访问者"即外来的操作者，它遍历对象结构，对每个元素执行特定操作。在编译器设计中，语法树节点（变量声明、赋值语句、条件判断等）是稳定的，但需要对它们进行的操作（类型检查、代码生成、优化分析、格式化输出）却不断演进。访问者模式使编译器能够在不修改AST节点类的前提下，持续添加新的编译阶段。
访问者模式的深层价值在于**双重分派（Double Dispatch）**机制。在面向对象中，方法调用通常是单分派：根据运行时对象的实际类型选择方法。访问者模式通过两次虚方法调用——元素接受访问者，访问者访问元素——实现了基于两个对象类型的动态分派。这一机制使系统能够根据元素类型和访问者类型的组合，执行不同的操作逻辑。
二、模式结构
访问者模式包含五个核心角色，形成稳定的访问-接受结构：
抽象访问者（Visitor）：声明访问每个具体元素的接口，为每个元素类定义一个visit操作。
具体访问者（Concrete Visitor）：实现抽象访问者声明的操作，实现算法的一部分。
抽象元素（Element）：声明接受访问者的接口，通常定义accept(Visitor)方法。
具体元素（Concrete Element）：实现接受接口，调用访问者相应的visit方法。
对象结构（Object Structure）：能够枚举其元素，可以提供一个高层接口让访问者访问其元素。
访问者模式的关键在于元素类稳定、操作频繁变化的场景。如果元素类频繁增加，访问者模式会导致所有访问者类都需要修改，反而不适用。
三、深度案例：企业级编译器与代码分析平台
以下展示一个真实场景下的访问者模式应用——金融领域的领域特定语言（DSL）编译器，支持规则表达式、定价公式、风控策略的解析、验证、优化与代码生成。
3.1 问题域分析：AST操作的爆炸
java
// 反模式：在AST节点中硬编码所有操作
public abstract class AstNode {
// 类型检查
public abstract Type checkType();
// 常量折叠
public abstract AstNode foldConstants();
// 代码生成
public abstract String generateCode();
// 优化分析
public abstract OptimizationReport analyzeOptimizations();
// 格式化输出
public abstract String format(int indent);
// 安全分析
public abstract SecurityReport analyzeSecurity();
// 复杂度计算
public abstract ComplexityScore calculateComplexity();
// 每新增一种操作，修改所有节点类！
}
上述代码每新增一种编译阶段或分析操作，需修改数十个AST节点类，违反开闭原则。访问者模式将操作提取为独立的访问者类。
3.2 抽象层：元素与访问者契约
java
/**
* 抽象元素：AST节点
* 定义接受访问者的接口
*/
public interface AstNode {
/**
* 接受访问者：双重分派的关键
*/
<R> R accept(AstVisitor<R> visitor);
/**
* 获取节点位置（用于错误定位）
*/
SourceLocation getLocation();
/**
* 获取子节点
*/
List<AstNode> getChildren();
/**
* 获取节点类型标识
*/
NodeType getNodeType();
}
/**
* 抽象访问者：参数化返回类型，支持多种访问目的
*/
public interface AstVisitor<R> {
// 表达式节点
R visitBinaryExpression(BinaryExpression node);
R visitUnaryExpression(UnaryExpression node);
R visitLiteral(Literal node);
R visitVariableReference(VariableReference node);
R visitFunctionCall(FunctionCall node);
R visitTernaryExpression(TernaryExpression node);
R visitMemberAccess(MemberAccess node);
R visitArrayAccess(ArrayAccess node);
// 语句节点
R visitAssignment(Assignment node);
R visitIfStatement(IfStatement node);
R visitWhileStatement(WhileStatement node);
R visitForStatement(ForStatement node);
R visitReturnStatement(ReturnStatement node);
R visitBlockStatement(BlockStatement node);
R visitVariableDeclaration(VariableDeclaration node);
// 声明节点
R visitFunctionDeclaration(FunctionDeclaration node);
R visitRuleDeclaration(RuleDeclaration node);
R visitParameterDeclaration(ParameterDeclaration node);
// 类型节点
R visitPrimitiveType(PrimitiveType node);
R visitArrayType(ArrayType node);
R visitFunctionType(FunctionType node);
R visitUserType(UserType node);
// 辅助方法：默认遍历逻辑
default R visitChildren(AstNode node) {
R result = null;
for (AstNode child : node.getChildren()) {
result = child.accept(this);
}
return result;
}
}
3.3 具体元素：AST节点实现
java
/**
* 具体元素：二元表达式
*/
public class BinaryExpression implements AstNode {
private final SourceLocation location;
private final BinaryOperator operator;
private final AstNode left;
private final AstNode right;
private final Type inferredType;
public BinaryExpression(SourceLocation location, BinaryOperator operator,
AstNode left, AstNode right, Type inferredType) {
this.location = location;
this.operator = operator;
this.left = left;
this.right = right;
this.inferredType = inferredType;
}
@Override
public <R> R accept(AstVisitor<R> visitor) {
// 双重分派：调用访问者的特定visit方法
return visitor.visitBinaryExpression(this);
}
@Override
public List<AstNode> getChildren() {
return List.of(left, right);
}
// Getters...
public BinaryOperator getOperator() { return operator; }
public AstNode getLeft() { return left; }
public AstNode getRight() { return right; }
public Type getInferredType() { return inferredType; }
}
/**
* 具体元素：函数调用
*/
public class FunctionCall implements AstNode {
private final SourceLocation location;
private final String functionName;
private final List<AstNode> arguments;
private final FunctionType functionType;
private final boolean isBuiltin;
public FunctionCall(SourceLocation location, String functionName,
List<AstNode> arguments, FunctionType functionType,
boolean isBuiltin) {
this.location = location;
this.functionName = functionName;
this.arguments = arguments;
this.functionType = functionType;
this.isBuiltin = isBuiltin;
}
@Override
public <R> R accept(AstVisitor<R> visitor) {
return visitor.visitFunctionCall(this);
}
@Override
public List<AstNode> getChildren() {
return new ArrayList<>(arguments);
}
// Getters...
}
/**
* 具体元素：规则声明（DSL顶层结构）
*/
public class RuleDeclaration implements AstNode {
private final SourceLocation location;
private final String ruleName;
private final List<ParameterDeclaration> parameters;
private final AstNode condition;
private final AstNode action;
private final List<String> tags;
private final Severity severity;
@Override
public <R> R accept(AstVisitor<R> visitor) {
return visitor.visitRuleDeclaration(this);
}
@Override
public List<AstNode> getChildren() {
List<AstNode> children = new ArrayList<>();
children.addAll(parameters);
children.add(condition);
children.add(action);
return children;
}
// Getters...
}
3.4 具体访问者：类型检查
java
/**
* 具体访问者：类型检查器
* 验证表达式类型一致性，推断缺失类型
*/
public class TypeChecker implements AstVisitor<Type> {
private final TypeEnvironment environment;
private final List<TypeError> errors = new ArrayList<>();
public TypeChecker(TypeEnvironment environment) {
this.environment = environment;
}
@Override
public Type visitBinaryExpression(BinaryExpression node) {
Type leftType = node.getLeft().accept(this);
Type rightType = node.getRight().accept(this);
switch (node.getOperator()) {
case ADD:
case SUBTRACT:
case MULTIPLY:
case DIVIDE:
// 算术运算：要求数值类型
if (!leftType.isNumeric()) {
errors.add(new TypeError(node.getLeft().getLocation(),
"算术运算左操作数必须是数值类型，实际为: " + leftType));
}
if (!rightType.isNumeric()) {
errors.add(new TypeError(node.getRight().getLocation(),
"算术运算右操作数必须是数值类型，实际为: " + rightType));
}
// 类型提升
return promoteNumericType(leftType, rightType);
case EQUAL:
case NOT_EQUAL:
// 相等比较：要求可比较类型
if (!leftType.isComparableWith(rightType)) {
errors.add(new TypeError(node.getLocation(),
"不可比较的类型: " + leftType + " 与 " + rightType));
}
return PrimitiveType.BOOLEAN;
case LESS_THAN:
case LESS_EQUAL:
case GREATER_THAN:
case GREATER_EQUAL:
// 序比较：要求有序类型
if (!leftType.isOrdered()) {
errors.add(new TypeError(node.getLeft().getLocation(),
"序比较要求有序类型，实际为: " + leftType));
}
return PrimitiveType.BOOLEAN;
case AND:
case OR:
// 逻辑运算：要求布尔类型
if (leftType != PrimitiveType.BOOLEAN) {
errors.add(new TypeError(node.getLeft().getLocation(),
"逻辑运算要求布尔类型，实际为: " + leftType));
}
if (rightType != PrimitiveType.BOOLEAN) {
errors.add(new TypeError(node.getRight().getLocation(),
"逻辑运算要求布尔类型，实际为: " + rightType));
}
return PrimitiveType.BOOLEAN;
default:
throw new UnsupportedOperationException("未知运算符: " + node.getOperator());
}
}
@Override
public Type visitFunctionCall(FunctionCall node) {
// 检查参数类型
FunctionType functionType = node.getFunctionType();
List<Type> paramTypes = functionType.getParameterTypes();
List<AstNode> arguments = node.getArguments();
if (arguments.size() != paramTypes.size()) {
errors.add(new TypeError(node.getLocation(),
"参数数量不匹配: 期望 " + paramTypes.size() + ", 实际 " + arguments.size()));
}
for (int i = 0; i < Math.min(arguments.size(), paramTypes.size()); i++) {
Type argType = arguments.get(i).accept(this);
Type expectedType = paramTypes.get(i);
if (!argType.isAssignableTo(expectedType)) {
errors.add(new TypeError(arguments.get(i).getLocation(),
"参数 " + (i+1) + " 类型不匹配: 期望 " + expectedType + ", 实际 " + argType));
}
}
return functionType.getReturnType();
}
@Override
public Type visitRuleDeclaration(RuleDeclaration node) {
// 规则声明创建新的作用域
TypeEnvironment localEnv = environment.newScope();
// 注册参数
for (ParameterDeclaration param : node.getParameters()) {
localEnv.declare(param.getName(), param.getType());
}
// 检查条件表达式
Type conditionType = node.getCondition().accept(
new TypeChecker(localEnv));
if (conditionType != PrimitiveType.BOOLEAN) {
errors.add(new TypeError(node.getCondition().getLocation(),
"规则条件必须是布尔类型，实际为: " + conditionType));
}
// 检查动作表达式
node.getAction().accept(new TypeChecker(localEnv));
return PrimitiveType.VOID;
}
@Override
public Type visitLiteral(Literal node) {
return node.getType(); // 字面量自带类型
}
@Override
public Type visitVariableReference(VariableReference node) {
Type type = environment.lookup(node.getName());
if (type == null) {
errors.add(new TypeError(node.getLocation(),
"未定义的变量: " + node.getName()));
return PrimitiveType.UNKNOWN;
}
return type;
}
// 其余visit方法...
public boolean hasErrors() {
return !errors.isEmpty();
}
public List<TypeError> getErrors() {
return Collections.unmodifiableList(errors);
}
private Type promoteNumericType(Type left, Type right) {
if (left == PrimitiveType.DECIMAL || right == PrimitiveType.DECIMAL) {
return PrimitiveType.DECIMAL;
}
if (left == PrimitiveType.DOUBLE || right == PrimitiveType.DOUBLE) {
return PrimitiveType.DOUBLE;
}
if (left == PrimitiveType.LONG || right == PrimitiveType.LONG) {
return PrimitiveType.LONG;
}
return PrimitiveType.INTEGER;
}
}
3.5 具体访问者：代码生成器
java
/**
* 具体访问者：Java代码生成器
* 将DSL编译为可执行的Java代码
*/
public class JavaCodeGenerator implements AstVisitor<String> {
private final StringBuilder code = new StringBuilder();
private final Indentation indent = new Indentation(4);
private final SymbolTable symbols = new SymbolTable();
@Override
public String visitBinaryExpression(BinaryExpression node) {
String left = node.getLeft().accept(this);
String right = node.getRight().accept(this);
String op = switch (node.getOperator()) {
case ADD -> "+";
case SUBTRACT -> "-";
case MULTIPLY -> "*";
case DIVIDE -> "/";
case EQUAL -> "==";
case NOT_EQUAL -> "!=";
case LESS_THAN -> "<";
case LESS_EQUAL -> "<=";
case GREATER_THAN -> ">";
case GREATER_EQUAL -> ">=";
case AND -> "&&";
case OR -> "||";
};
// 处理运算符优先级
boolean needParen = needsParentheses(node.getLeft(), node.getOperator());
String leftExpr = needParen ? "(" + left + ")" : left;
needParen = needsParentheses(node.getRight(), node.getOperator());
String rightExpr = needParen ? "(" + right + ")" : right;
return leftExpr + " " + op + " " + rightExpr;
}
@Override
public String visitFunctionCall(FunctionCall node) {
StringBuilder call = new StringBuilder();
if (node.isBuiltin()) {
// 内置函数映射到运行时库
call.append("RuntimeLibrary.");
call.append(mapBuiltinName(node.getFunctionName()));
} else {
call.append(symbols.resolveQualifiedName(node.getFunctionName()));
}
call.append("(");
List<String> args = node.getArguments().stream()
.map(arg -> arg.accept(this))
.collect(Collectors.toList());
call.append(String.join(", ", args));
call.append(")");
// 处理返回类型转换
if (node.getFunctionType().getReturnType() != PrimitiveType.VOID) {
return maybeCast(call.toString(), node.getFunctionType().getReturnType());
}
return call.toString();
}
@Override
public String visitRuleDeclaration(RuleDeclaration node) {
code.append("public class ").append(toClassName(node.getRuleName()))
.append(" implements Rule {").append("\n");
indent.increase();
// 生成字段
for (ParameterDeclaration param : node.getParameters()) {
code.append(indent).append("private final ")
.append(toJavaType(param.getType())).append(" ")
.append(param.getName()).append(";\n");
}
// 生成构造器
code.append(indent).append("public ")
.append(toClassName(node.getRuleName())).append("(");
String params = node.getParameters().stream()
.map(p -> toJavaType(p.getType()) + " " + p.getName())
.collect(Collectors.joining(", "));
code.append(params).append(") {\n");
indent.increase();
for (ParameterDeclaration param : node.getParameters()) {
code.append(indent).append("this.").append(param.getName())
.append(" = ").append(param.getName()).append(";\n");
}
indent.decrease();
code.append(indent).append("}\n\n");
// 生成evaluate方法
code.append(indent).append("@Override\n");
code.append(indent).append("public RuleResult evaluate(EvaluationContext ctx) {\n");
indent.increase();
// 条件判断
code.append(indent).append("if (");
code.append(node.getCondition().accept(this));
code.append(") {\n");
indent.increase();
// 执行动作
code.append(indent).append("return ");
code.append(node.getAction().accept(this));
code.append(";\n");
indent.decrease();
code.append(indent).append("}\n");
code.append(indent).append("return RuleResult.noMatch();\n");
indent.decrease();
code.append(indent).append("}\n");
indent.decrease();
code.append("}\n");
return code.toString();
}
@Override
public String visitIfStatement(IfStatement node) {
StringBuilder result = new StringBuilder();
result.append("if (").append(node.getCondition().accept(this)).append(") {\n");
indent.increase();
result.append(indent).append(node.getThenBranch().accept(this)).append("\n");
indent.decrease();
result.append(indent).append("}");
if (node.getElseBranch() != null) {
result.append(" else {\n");
indent.increase();
result.append(indent).append(node.getElseBranch().accept(this)).append("\n");
indent.decrease();
result.append(indent).append("}");
}
return result.toString();
}
// 辅助方法
private String toJavaType(Type type) {
return switch (type) {
case PrimitiveType.INTEGER -> "Integer";
case PrimitiveType.LONG -> "Long";
case PrimitiveType.DOUBLE -> "Double";
case PrimitiveType.DECIMAL -> "BigDecimal";
case PrimitiveType.BOOLEAN -> "Boolean";
case PrimitiveType.STRING -> "String";
case PrimitiveType.DATE -> "LocalDate";
case PrimitiveType.DATETIME -> "LocalDateTime";
case ArrayType at -> "List<" + toJavaType(at.getElementType()) + ">";
default -> "Object";
};
}
private String toClassName(String ruleName) {
return Arrays.stream(ruleName.split("_"))
.map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))
.collect(Collectors.joining()) + "Rule";
}
private String mapBuiltinName(String dslName) {
return switch (dslName) {
case "abs" -> "mathAbs";
case "round" -> "mathRound";
case "max" -> "mathMax";
case "min" -> "mathMin";
case "contains" -> "stringContains";
case "starts_with" -> "stringStartsWith";
case "date_diff" -> "dateDiffDays";
case "now" -> "currentTimestamp";
default -> dslName;
};
}
}
3.6 具体访问者：安全分析器
java
/**
* 具体访问者：安全分析器
* 检测潜在的安全风险：注入、越权、信息泄露
*/
public class SecurityAnalyzer implements AstVisitor<SecurityReport> {
private final List<SecurityIssue> issues = new ArrayList<>();
private final SecurityPolicy policy;
private final DataClassificationService classificationService;
public SecurityAnalyzer(SecurityPolicy policy,
DataClassificationService classificationService) {
this.policy = policy;
this.classificationService = classificationService;
}
@Override
public SecurityReport visitFunctionCall(FunctionCall node) {
// 检查危险函数调用
if (isDangerousFunction(node.getFunctionName())) {
issues.add(new SecurityIssue(
Severity.HIGH,
"DANGEROUS_FUNCTION",
node.getLocation(),
"调用危险函数: " + node.getFunctionName(),
"使用安全的替代函数或添加输入校验"
));
}
// 检查SQL注入风险
if (isSqlFunction(node.getFunctionName())) {
for (AstNode arg : node.getArguments()) {
if (arg instanceof VariableReference) {
issues.add(new SecurityIssue(
Severity.CRITICAL,
"SQL_INJECTION_RISK",
arg.getLocation(),
"SQL函数参数可能包含用户输入",
"使用参数化查询或预编译语句"
));
}
}
}
// 递归检查参数
for (AstNode arg : node.getArguments()) {
arg.accept(this);
}
return aggregateReport();
}
@Override
public SecurityReport visitVariableReference(VariableReference node) {
// 检查敏感数据访问
DataClassification classification = classificationService
.classify(node.getName());
if (classification.isSensitive()) {
// 检查是否在允许的上下文中使用
if (!policy.isAllowedInContext(node.getName(), getCurrentContext())) {
issues.add(new SecurityIssue(
Severity.HIGH,
"SENSITIVE_DATA_EXPOSURE",
node.getLocation(),
"敏感数据 '" + node.getName() + "' 可能在不安全上下文中使用",
"添加脱敏处理或访问控制"
));
}
}
return aggregateReport();
}
@Override
public SecurityReport visitMemberAccess(MemberAccess node) {
// 检查越权访问
if (node.getObject() instanceof VariableReference objRef) {
String objectType = resolveType(objRef);
if (isProtectedResource(objectType)) {
String accessedField = node.getMemberName();
if (!policy.hasFieldAccess(objectType, accessedField, getCurrentRole())) {
issues.add(new SecurityIssue(
Severity.MEDIUM,
"UNAUTHORIZED_FIELD_ACCESS",
node.getLocation(),
"无权访问 " + objectType + "." + accessedField,
"申请权限或修改访问策略"
));
}
}
}
node.getObject().accept(this);
return aggregateReport();
}
@Override
public SecurityReport visitRuleDeclaration(RuleDeclaration node) {
// 检查规则权限
for (String tag : node.getTags()) {
if (policy.isRestrictedTag(tag) && !hasRuleCreationPermission(tag)) {
issues.add(new SecurityIssue(
Severity.HIGH,
"UNAUTHORIZED_RULE_CREATION",
node.getLocation(),
"无权创建标记为 '" + tag + "' 的规则",
"联系管理员申请权限"
));
}
}
// 检查规则复杂度（防止DoS）
ComplexityScore complexity = calculateComplexity(node);
if (complexity.getScore() > policy.getMaxRuleComplexity()) {
issues.add(new SecurityIssue(
Severity.MEDIUM,
"EXCESSIVE_RULE_COMPLEXITY",
node.getLocation(),
"规则复杂度 " + complexity.getScore() + " 超过限制 " + policy.getMaxRuleComplexity(),
"拆分规则或优化表达式"
));
}
// 递归检查子节点
visitChildren(node);
return aggregateReport();
}
private SecurityReport aggregateReport() {
return new SecurityReport(
issues.isEmpty() ? SecurityStatus.PASS : SecurityStatus.FAIL,
new ArrayList<>(issues)
);
}
private boolean isDangerousFunction(String name) {
return Set.of("eval", "exec", "system", "deserialize").contains(name);
}
private boolean isSqlFunction(String name) {
return name.toLowerCase().startsWith("sql_") || name.equals("query");
}
}
3.7 对象结构与遍历控制
java
/**
* 对象结构：AST抽象语法树
* 提供高层访问接口
*/
public class AbstractSyntaxTree {
private final List<AstNode> rootNodes;
private final SourceFile sourceFile;
public AbstractSyntaxTree(List<AstNode> rootNodes, SourceFile sourceFile) {
this.rootNodes = rootNodes;
this.sourceFile = sourceFile;
}
/**
* 接受访问者：遍历整棵树
*/
public <R> R accept(AstVisitor<R> visitor) {
R result = null;
for (AstNode node : rootNodes) {
result = node.accept(visitor);
}
return result;
}
/**
* 选择性遍历：仅访问特定类型的节点
*/
public <R> List<R> acceptForNodesOfType(AstVisitor<R> visitor,
Predicate<AstNode> filter) {
List<R> results = new ArrayList<>();
for (AstNode node : rootNodes) {
collectMatching(node, visitor, filter, results);
}
return results;
}
private <R> void collectMatching(AstNode node, AstVisitor<R> visitor,
Predicate<AstNode> filter, List<R> results) {
if (filter.test(node)) {
results.add(node.accept(visitor));
}
for (AstNode child : node.getChildren()) {
collectMatching(child, visitor, filter, results);
}
}
/**
* 并行遍历：利用ForkJoinPool加速分析
*/
public <R> List<R> acceptParallel(AstVisitor<R> visitor) {
return rootNodes.parallelStream()
.map(node -> node.accept(visitor))
.collect(Collectors.toList());
}
}
四、访问者模式的高级主题
4.1 访问者组合：多阶段编译管道
java
/**
* 编译管道：组合多个访问者形成编译阶段
*/
public class CompilationPipeline {
private final List<CompilationPhase> phases;
public CompilationResult compile(AbstractSyntaxTree ast) {
CompilationContext context = new CompilationContext();
for (CompilationPhase phase : phases) {
AstVisitor<?> visitor = phase.createVisitor(context);
Object result = ast.accept(visitor);
if (phase.isTerminal() && hasErrors(result)) {
return CompilationResult.failure(context.getErrors());
}
// 阶段间传递信息
context.putPhaseResult(phase.getName(), result);
// 支持AST转换
if (visitor instanceof TransformingVisitor) {
ast = ((TransformingVisitor) visitor).getTransformedTree();
}
}
return CompilationResult.success(context);
}
}
// 具体阶段
public class TypeCheckPhase implements CompilationPhase {
@Override
public AstVisitor<?> createVisitor(CompilationContext context) {
return new TypeChecker(context.getTypeEnvironment());
}
}
public class OptimizationPhase implements CompilationPhase {
@Override
public AstVisitor<?> createVisitor(CompilationContext context) {
return new ConstantFolder(); // 常量折叠
}
}
public class CodeGenPhase implements CompilationPhase {
@Override
public AstVisitor<?> createVisitor(CompilationContext context) {
return new JavaCodeGenerator();
}
}
4.2 反射式访问者：减少样板代码
java
/**
* 反射式访问者基类：自动分发到visit方法
*/
public abstract class ReflectiveAstVisitor<R> implements AstVisitor<R> {
@Override
public R accept(AstNode node) {
// 通过反射找到对应的visit方法
try {
Method method = getClass().getMethod("visit", node.getClass());
return (R) method.invoke(this, node);
} catch (NoSuchMethodException e) {
return visitDefault(node);
} catch (Exception e) {
throw new VisitorException("反射调用失败", e);
}
}
protected R visitDefault(AstNode node) {
return visitChildren(node);
}
}
五、访问者模式与相关模式的辨析
访问者 vs 迭代器：迭代器遍历元素，访问者对元素执行操作。二者常结合：迭代器遍历，访问者处理。
访问者 vs 策略：策略封装单一算法，访问者封装对多种元素的操作。策略是"一维选择"，访问者是"二维分派"。
访问者 vs 装饰器：装饰器增强元素功能，访问者添加外部操作。装饰器修改元素行为，访问者不修改元素。
六、设计陷阱与规避策略
陷阱一：元素类频繁新增
每新增元素类，所有访问者需新增visit方法。解决方案：使用反射式访问者，或评估是否适用访问者模式。
陷阱二：访问者状态管理
复杂访问者状态难以维护。解决方案：将状态提取为独立上下文对象，或使用访问者组合。
陷阱三：循环访问
元素A访问元素B，B又访问A。解决方案：访问标记、访问栈检测，或限制访问方向。
七、结语
访问者模式是应对稳定数据结构、频繁变化操作的核心工具。它将操作逻辑从数据类中彻底提取，使系统能够在不修改既有类的前提下持续扩展功能。在编译器、代码分析、报表生成、模型转换等场景中，访问者模式是不可或缺的架构模式。理解其双重分派机制、掌握多阶段组合、反射优化等高级技术，警惕元素膨胀、状态管理、循环访问等工程陷阱，是构建可扩展分析系统的能力核心。访问者模式的精髓在于承认操作的无尽演化，以访问者为载体，在稳定与变化之间建立优雅的隔离边界。