设计模式-访问者模式详解

访问者模式详解

模式简介

定义

访问者模式（Visitor Pattern）是一种行为型设计模式，它允许在不改变各元素类的前提下定义作用于这些元素的新操作。访问者模式将数据结构与数据操作分离，使得操作集合可以相对自由地演化。

核心思想

双重分派：通过两次方法调用来确定操作的具体实现
操作分离：将数据结构与操作分离，操作可以独立变化
扩展开放：新增操作时无需修改现有类，符合开闭原则
访问统一：通过统一的访问接口处理不同类型的元素

模式结构

Visitor（访问者）：定义访问具体元素的操作接口
ConcreteVisitor（具体访问者）：实现访问者接口，定义具体操作
Element（元素）：定义接受访问者的接口
ConcreteElement（具体元素）：实现元素接口，提供接受访问者的方法
ObjectStructure（对象结构）：包含元素集合，提供遍历接口

核心流程

基本流程图

客户端请求创建具体访问者创建对象结构添加具体元素对象结构接受访问者遍历元素集合元素接受访问者访问者访问元素执行具体操作返回操作结果

双重分派流程图

客户端调用 ObjectStructure.accept(visitor) 遍历元素集合 Element.accept(visitor) Visitor.visit(this) 根据元素类型执行操作返回操作结果

详细流程步骤

1. 访问者创建流程

定义访问者接口实现具体访问者定义访问方法实现具体操作逻辑访问者准备就绪

2. 元素接受访问流程

元素接受访问者调用访问者访问方法传递this引用访问者获取元素类型执行对应操作返回操作结果

代码示例流程

java 复制代码

// 1. 创建访问者
Visitor visitor = new ConcreteVisitor();

// 2. 创建对象结构
ObjectStructure structure = new ObjectStructure();
structure.add(new ConcreteElementA());
structure.add(new ConcreteElementB());

// 3. 执行访问
structure.accept(visitor);

重难点分析

重点分析

1. 双重分派机制

java 复制代码

// 访问者接口
public interface Visitor {
    void visit(ConcreteElementA element);
    void visit(ConcreteElementB element);
}

// 元素接口
public interface Element {
    void accept(Visitor visitor);
}

// 具体元素A
public class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        // 第一次分派：根据元素类型调用对应的访问方法
        visitor.visit(this);
    }
}

// 具体访问者
public class ConcreteVisitor implements Visitor {
    @Override
    public void visit(ConcreteElementA element) {
        // 第二次分派：根据访问者类型执行具体操作
        System.out.println("访问者处理元素A");
    }
  
    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("访问者处理元素B");
    }
}

2. 对象结构管理

java 复制代码

public class ObjectStructure {
    private List<Element> elements = new ArrayList<>();
  
    public void add(Element element) {
        elements.add(element);
    }
  
    public void remove(Element element) {
        elements.remove(element);
    }
  
    public void accept(Visitor visitor) {
        // 遍历所有元素，让每个元素接受访问者
        for (Element element : elements) {
            element.accept(visitor);
        }
    }
  
    // 支持条件访问
    public void accept(Visitor visitor, Predicate<Element> filter) {
        elements.stream()
                .filter(filter)
                .forEach(element -> element.accept(visitor));
    }
}

3. 访问者模式与组合模式结合

java 复制代码

// 组合元素
public class CompositeElement implements Element {
    private List<Element> children = new ArrayList<>();
  
    @Override
    public void accept(Visitor visitor) {
        // 访问自身
        visitor.visit(this);
      
        // 访问子元素
        for (Element child : children) {
            child.accept(visitor);
        }
    }
  
    public void add(Element element) {
        children.add(element);
    }
}

// 访问者处理组合元素
public class CompositeVisitor implements Visitor {
    @Override
    public void visit(CompositeElement element) {
        System.out.println("处理组合元素");
    }
  
    @Override
    public void visit(ConcreteElementA element) {
        System.out.println("处理叶子元素A");
    }
}

难点分析

1. 类型安全问题

java 复制代码

// 使用泛型确保类型安全
public interface Visitor<T> {
    T visit(ConcreteElementA element);
    T visit(ConcreteElementB element);
}

// 具体访问者实现
public class TypeSafeVisitor implements Visitor<String> {
    @Override
    public String visit(ConcreteElementA element) {
        return "处理元素A的结果";
    }
  
    @Override
    public String visit(ConcreteElementB element) {
        return "处理元素B的结果";
    }
}

2. 访问者模式与开闭原则

java 复制代码

// 扩展新的访问者而不修改现有代码
public class NewOperationVisitor implements Visitor {
    @Override
    public void visit(ConcreteElementA element) {
        // 新操作，无需修改现有类
        System.out.println("新操作处理元素A");
    }
  
    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("新操作处理元素B");
    }
}

// 扩展新元素类型需要修改所有访问者
public class ConcreteElementC implements Element {
    @Override
    public void accept(Visitor visitor) {
        // 需要访问者支持新元素类型
        if (visitor instanceof ExtendedVisitor) {
            ((ExtendedVisitor) visitor).visit(this);
        }
    }
}

3. 性能考虑

java 复制代码

// 使用缓存避免重复计算
public class CachedVisitor implements Visitor {
    private Map<Element, Object> cache = new HashMap<>();
  
    @Override
    public Object visit(ConcreteElementA element) {
        return cache.computeIfAbsent(element, this::computeResult);
    }
  
    private Object computeResult(Element element) {
        // 复杂的计算逻辑
        return "计算结果";
    }
}

// 使用访问者模式进行批量操作
public class BatchVisitor implements Visitor {
    private List<Object> results = new ArrayList<>();
  
    @Override
    public void visit(ConcreteElementA element) {
        results.add(processElementA(element));
    }
  
    @Override
    public void visit(ConcreteElementB element) {
        results.add(processElementB(element));
    }
  
    public List<Object> getResults() {
        return results;
    }
}

Spring中的源码分析

1. Bean定义访问者模式

核心类：BeanDefinitionVisitor

java 复制代码

public class BeanDefinitionVisitor {
  
    // 访问Bean定义
    public void visitBeanDefinition(BeanDefinition beanDefinition) {
        // 访问Bean类名
        if (beanDefinition.hasBeanClassName()) {
            String className = beanDefinition.getBeanClassName();
            String newClassName = resolveStringValue(className);
            if (!className.equals(newClassName)) {
                beanDefinition.setBeanClassName(newClassName);
            }
        }
      
        // 访问属性值
        if (beanDefinition.hasPropertyValues()) {
            MutablePropertyValues pvs = beanDefinition.getPropertyValues();
            visitPropertyValues(pvs);
        }
    }
  
    // 访问属性值
    protected void visitPropertyValues(MutablePropertyValues pvs) {
        PropertyValue[] pvArray = pvs.getPropertyValues();
        for (PropertyValue pv : pvArray) {
            Object newVal = resolveValue(pv.getValue());
            if (newVal != pv.getValue()) {
                pvs.add(pv.getName(), newVal);
            }
        }
    }
}

2. 配置属性访问者

核心类：ConfigurationPropertiesBindingPostProcessor

java 复制代码

public class ConfigurationPropertiesBindingPostProcessor implements BeanPostProcessor {
  
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // 访问配置属性
        ConfigurationProperties annotation = AnnotationUtils.findAnnotation(
            bean.getClass(), ConfigurationProperties.class);
      
        if (annotation != null) {
            // 创建配置属性访问者
            ConfigurationPropertiesVisitor visitor = new ConfigurationPropertiesVisitor();
            visitor.visit(bean, annotation);
        }
      
        return bean;
    }
  
    // 配置属性访问者
    private static class ConfigurationPropertiesVisitor {
        public void visit(Object bean, ConfigurationProperties annotation) {
            // 访问Bean的属性
            BeanWrapper wrapper = new BeanWrapperImpl(bean);
            PropertyDescriptor[] descriptors = wrapper.getPropertyDescriptors();
          
            for (PropertyDescriptor descriptor : descriptors) {
                if (descriptor.getWriteMethod() != null) {
                    // 处理属性绑定
                    processProperty(bean, descriptor, annotation);
                }
            }
        }
    }
}

3. 事件监听器访问者

核心类：ApplicationListenerMethodAdapter

java 复制代码

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
  
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        // 创建事件访问者
        EventVisitor visitor = new EventVisitor(event);
      
        // 访问监听器方法
        Method method = getMethod();
        visitor.visit(method);
    }
  
    // 事件访问者
    private static class EventVisitor {
        private final ApplicationEvent event;
      
        public EventVisitor(ApplicationEvent event) {
            this.event = event;
        }
      
        public void visit(Method method) {
            // 根据事件类型执行不同的处理逻辑
            if (event instanceof ContextRefreshedEvent) {
                handleContextRefreshed(method);
            } else if (event instanceof ContextClosedEvent) {
                handleContextClosed(method);
            }
            // 其他事件类型...
        }
    }
}

4. 注解处理器访问者

核心类：AnnotatedElementVisitor

java 复制代码

public class AnnotatedElementVisitor {
  
    public void visit(AnnotatedElement element) {
        // 访问类注解
        if (element instanceof Class) {
            visitClass((Class<?>) element);
        }
        // 访问方法注解
        else if (element instanceof Method) {
            visitMethod((Method) element);
        }
        // 访问字段注解
        else if (element instanceof Field) {
            visitField((Field) element);
        }
    }
  
    private void visitClass(Class<?> clazz) {
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            processAnnotation(annotation, clazz);
        }
    }
  
    private void visitMethod(Method method) {
        Annotation[] annotations = method.getAnnotations();
        for (Annotation annotation : annotations) {
            processAnnotation(annotation, method);
        }
    }
}

具体使用场景

1. 编译器AST访问

java 复制代码

// AST节点接口
public interface ASTNode {
    void accept(ASTVisitor visitor);
}

// 表达式节点
public class ExpressionNode implements ASTNode {
    private String operator;
    private ASTNode left;
    private ASTNode right;
  
    @Override
    public void accept(ASTVisitor visitor) {
        visitor.visit(this);
    }
}

// 变量节点
public class VariableNode implements ASTNode {
    private String name;
  
    @Override
    public void accept(ASTVisitor visitor) {
        visitor.visit(this);
    }
}

// AST访问者接口
public interface ASTVisitor {
    void visit(ExpressionNode node);
    void visit(VariableNode node);
    void visit(StatementNode node);
}

// 代码生成访问者
public class CodeGeneratorVisitor implements ASTVisitor {
    private StringBuilder code = new StringBuilder();
  
    @Override
    public void visit(ExpressionNode node) {
        node.getLeft().accept(this);
        code.append(" ").append(node.getOperator()).append(" ");
        node.getRight().accept(this);
    }
  
    @Override
    public void visit(VariableNode node) {
        code.append(node.getName());
    }
  
    public String getGeneratedCode() {
        return code.toString();
    }
}

// 语义分析访问者
public class SemanticAnalyzerVisitor implements ASTVisitor {
    private Map<String, Type> symbolTable = new HashMap<>();
  
    @Override
    public void visit(ExpressionNode node) {
        // 分析表达式类型
        Type leftType = analyzeType(node.getLeft());
        Type rightType = analyzeType(node.getRight());
      
        if (!leftType.isCompatibleWith(rightType)) {
            throw new SemanticError("类型不兼容");
        }
    }
  
    @Override
    public void visit(VariableNode node) {
        // 检查变量是否声明
        if (!symbolTable.containsKey(node.getName())) {
            throw new SemanticError("未声明的变量: " + node.getName());
        }
    }
}

2. 文件系统操作

java 复制代码

// 文件系统节点接口
public interface FileSystemNode {
    void accept(FileSystemVisitor visitor);
    String getName();
    long getSize();
}

// 文件节点
public class FileNode implements FileSystemNode {
    private String name;
    private long size;
  
    @Override
    public void accept(FileSystemVisitor visitor) {
        visitor.visit(this);
    }
  
    @Override
    public String getName() {
        return name;
    }
  
    @Override
    public long getSize() {
        return size;
    }
}

// 目录节点
public class DirectoryNode implements FileSystemNode {
    private String name;
    private List<FileSystemNode> children = new ArrayList<>();
  
    @Override
    public void accept(FileSystemVisitor visitor) {
        visitor.visit(this);
      
        // 访问子节点
        for (FileSystemNode child : children) {
            child.accept(visitor);
        }
    }
  
    public void addChild(FileSystemNode child) {
        children.add(child);
    }
}

// 文件系统访问者接口
public interface FileSystemVisitor {
    void visit(FileNode file);
    void visit(DirectoryNode directory);
}

// 大小计算访问者
public class SizeCalculatorVisitor implements FileSystemVisitor {
    private long totalSize = 0;
  
    @Override
    public void visit(FileNode file) {
        totalSize += file.getSize();
    }
  
    @Override
    public void visit(DirectoryNode directory) {
        // 目录本身不占用空间，只计算子节点
    }
  
    public long getTotalSize() {
        return totalSize;
    }
}

// 文件搜索访问者
public class FileSearchVisitor implements FileSystemVisitor {
    private String searchPattern;
    private List<FileSystemNode> results = new ArrayList<>();
  
    public FileSearchVisitor(String pattern) {
        this.searchPattern = pattern;
    }
  
    @Override
    public void visit(FileNode file) {
        if (file.getName().contains(searchPattern)) {
            results.add(file);
        }
    }
  
    @Override
    public void visit(DirectoryNode directory) {
        if (directory.getName().contains(searchPattern)) {
            results.add(directory);
        }
    }
  
    public List<FileSystemNode> getResults() {
        return results;
    }
}

3. 数据库查询优化

java 复制代码

// 查询节点接口
public interface QueryNode {
    void accept(QueryVisitor visitor);
}

// 选择节点
public class SelectNode implements QueryNode {
    private List<String> columns;
    private QueryNode from;
    private QueryNode where;
  
    @Override
    public void accept(QueryVisitor visitor) {
        visitor.visit(this);
    }
}

// 连接节点
public class JoinNode implements QueryNode {
    private QueryNode left;
    private QueryNode right;
    private String joinType;
    private String condition;
  
    @Override
    public void accept(QueryVisitor visitor) {
        visitor.visit(this);
    }
}

// 查询访问者接口
public interface QueryVisitor {
    void visit(SelectNode node);
    void visit(JoinNode node);
    void visit(WhereNode node);
}

// 查询优化访问者
public class QueryOptimizerVisitor implements QueryVisitor {
    private List<String> optimizations = new ArrayList<>();
  
    @Override
    public void visit(SelectNode node) {
        // 优化选择列
        if (node.getColumns().contains("*")) {
            optimizations.add("避免使用SELECT *");
        }
      
        // 访问子节点
        if (node.getFrom() != null) {
            node.getFrom().accept(this);
        }
        if (node.getWhere() != null) {
            node.getWhere().accept(this);
        }
    }
  
    @Override
    public void visit(JoinNode node) {
        // 优化连接顺序
        optimizations.add("考虑连接顺序优化");
      
        // 访问子节点
        node.getLeft().accept(this);
        node.getRight().accept(this);
    }
  
    public List<String> getOptimizations() {
        return optimizations;
    }
}

// SQL生成访问者
public class SQLGeneratorVisitor implements QueryVisitor {
    private StringBuilder sql = new StringBuilder();
  
    @Override
    public void visit(SelectNode node) {
        sql.append("SELECT ");
        sql.append(String.join(", ", node.getColumns()));
        sql.append(" FROM ");
      
        if (node.getFrom() != null) {
            node.getFrom().accept(this);
        }
      
        if (node.getWhere() != null) {
            sql.append(" WHERE ");
            node.getWhere().accept(this);
        }
    }
  
    @Override
    public void visit(JoinNode node) {
        node.getLeft().accept(this);
        sql.append(" ").append(node.getJoinType()).append(" JOIN ");
        node.getRight().accept(this);
        sql.append(" ON ").append(node.getCondition());
    }
  
    public String getSQL() {
        return sql.toString();
    }
}

4. 图形渲染系统

java 复制代码

// 图形节点接口
public interface GraphicsNode {
    void accept(GraphicsVisitor visitor);
    Rectangle getBounds();
}

// 矩形节点
public class RectangleNode implements GraphicsNode {
    private int x, y, width, height;
    private Color color;
  
    @Override
    public void accept(GraphicsVisitor visitor) {
        visitor.visit(this);
    }
  
    @Override
    public Rectangle getBounds() {
        return new Rectangle(x, y, width, height);
    }
}

// 圆形节点
public class CircleNode implements GraphicsNode {
    private int x, y, radius;
    private Color color;
  
    @Override
    public void accept(GraphicsVisitor visitor) {
        visitor.visit(this);
    }
  
    @Override
    public Rectangle getBounds() {
        return new Rectangle(x - radius, y - radius, radius * 2, radius * 2);
    }
}

// 图形访问者接口
public interface GraphicsVisitor {
    void visit(RectangleNode node);
    void visit(CircleNode node);
    void visit(TextNode node);
}

// 渲染访问者
public class RenderVisitor implements GraphicsVisitor {
    private Graphics2D graphics;
  
    public RenderVisitor(Graphics2D graphics) {
        this.graphics = graphics;
    }
  
    @Override
    public void visit(RectangleNode node) {
        graphics.setColor(node.getColor());
        graphics.fillRect(node.getX(), node.getY(), node.getWidth(), node.getHeight());
    }
  
    @Override
    public void visit(CircleNode node) {
        graphics.setColor(node.getColor());
        graphics.fillOval(node.getX() - node.getRadius(), 
                         node.getY() - node.getRadius(), 
                         node.getRadius() * 2, 
                         node.getRadius() * 2);
    }
}

// 碰撞检测访问者
public class CollisionDetectionVisitor implements GraphicsVisitor {
    private Rectangle targetBounds;
    private List<GraphicsNode> collisions = new ArrayList<>();
  
    public CollisionDetectionVisitor(Rectangle targetBounds) {
        this.targetBounds = targetBounds;
    }
  
    @Override
    public void visit(RectangleNode node) {
        if (node.getBounds().intersects(targetBounds)) {
            collisions.add(node);
        }
    }
  
    @Override
    public void visit(CircleNode node) {
        if (node.getBounds().intersects(targetBounds)) {
            collisions.add(node);
        }
    }
  
    public List<GraphicsNode> getCollisions() {
        return collisions;
    }
}

5. 配置验证系统

java 复制代码

// 配置节点接口
public interface ConfigNode {
    void accept(ConfigVisitor visitor);
    String getPath();
    Object getValue();
}

// 配置项节点
public class ConfigItemNode implements ConfigNode {
    private String path;
    private Object value;
    private String type;
  
    @Override
    public void accept(ConfigVisitor visitor) {
        visitor.visit(this);
    }
  
    @Override
    public String getPath() {
        return path;
    }
  
    @Override
    public Object getValue() {
        return value;
    }
}

// 配置访问者接口
public interface ConfigVisitor {
    void visit(ConfigItemNode node);
    void visit(ConfigSectionNode node);
}

// 配置验证访问者
public class ConfigValidatorVisitor implements ConfigVisitor {
    private List<String> errors = new ArrayList<>();
    private Map<String, String> rules = new HashMap<>();
  
    public ConfigValidatorVisitor(Map<String, String> rules) {
        this.rules = rules;
    }
  
    @Override
    public void visit(ConfigItemNode node) {
        String rule = rules.get(node.getPath());
        if (rule != null) {
            if (!validateValue(node.getValue(), rule)) {
                errors.add("配置项 " + node.getPath() + " 验证失败: " + rule);
            }
        }
    }
  
    private boolean validateValue(Object value, String rule) {
        // 根据规则验证值
        if (rule.equals("required") && value == null) {
            return false;
        }
        if (rule.startsWith("min:") && value instanceof Number) {
            double min = Double.parseDouble(rule.substring(4));
            return ((Number) value).doubleValue() >= min;
        }
        // 其他验证规则...
        return true;
    }
  
    public List<String> getErrors() {
        return errors;
    }
}

面试高频点

1. 基本概念类

Q: 什么是访问者模式？

A: 访问者模式是一种行为型设计模式，它允许在不改变各元素类的前提下定义作用于这些元素的新操作。通过将数据结构与数据操作分离，使得操作集合可以相对自由地演化。

Q: 访问者模式的核心组件有哪些？

Visitor（访问者）：定义访问具体元素的操作接口
ConcreteVisitor（具体访问者）：实现访问者接口，定义具体操作
Element（元素）：定义接受访问者的接口
ConcreteElement（具体元素）：实现元素接口，提供接受访问者的方法
ObjectStructure（对象结构）：包含元素集合，提供遍历接口

2. 设计原理类

Q: 什么是双重分派？访问者模式如何实现双重分派？

A: 双重分派是指通过两次方法调用来确定操作的具体实现。

java 复制代码

// 第一次分派：根据元素类型调用对应的访问方法
public class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this); // 传递this，确定元素类型
    }
}

// 第二次分派：根据访问者类型执行具体操作
public class ConcreteVisitor implements Visitor {
    @Override
    public void visit(ConcreteElementA element) {
        // 根据元素类型执行具体操作
        System.out.println("处理元素A");
    }
}

Q: 访问者模式与策略模式的区别？

访问者模式：针对不同元素类型执行不同操作，操作与元素类型绑定
策略模式：针对同一对象的不同算法，算法可以动态切换
访问者模式：通过双重分派实现
策略模式：通过单一分派实现

3. 实现细节类

Q: 如何实现类型安全的访问者模式？

java 复制代码

// 使用泛型确保类型安全
public interface Visitor<T> {
    T visit(ConcreteElementA element);
    T visit(ConcreteElementB element);
}

// 具体访问者实现
public class TypeSafeVisitor implements Visitor<String> {
    @Override
    public String visit(ConcreteElementA element) {
        return "处理元素A的结果";
    }
  
    @Override
    public String visit(ConcreteElementB element) {
        return "处理元素B的结果";
    }
}

Q: 如何实现访问者模式的条件访问？

java 复制代码

public class ObjectStructure {
    private List<Element> elements = new ArrayList<>();
  
    // 条件访问
    public void accept(Visitor visitor, Predicate<Element> filter) {
        elements.stream()
                .filter(filter)
                .forEach(element -> element.accept(visitor));
    }
  
    // 使用示例
    public void processSpecificElements(Visitor visitor) {
        accept(visitor, element -> element instanceof ConcreteElementA);
    }
}

4. 性能优化类

Q: 访问者模式可能遇到哪些性能问题？

频繁方法调用：双重分派导致方法调用开销
内存占用：大量访问者对象占用内存
类型检查开销：运行时类型检查成本

解决方案：

java 复制代码

// 使用缓存避免重复计算
public class CachedVisitor implements Visitor {
    private Map<Element, Object> cache = new HashMap<>();
  
    @Override
    public Object visit(ConcreteElementA element) {
        return cache.computeIfAbsent(element, this::computeResult);
    }
  
    private Object computeResult(Element element) {
        // 复杂的计算逻辑
        return "计算结果";
    }
}

// 使用批量处理
public class BatchVisitor implements Visitor {
    private List<Object> results = new ArrayList<>();
  
    @Override
    public void visit(ConcreteElementA element) {
        results.add(processElementA(element));
    }
  
    public List<Object> getResults() {
        return results;
    }
}

5. 实际应用类

Q: 在Spring框架中，哪些地方使用了访问者模式的思想？

Bean定义处理：BeanDefinitionVisitor访问Bean定义
配置属性绑定：ConfigurationPropertiesBindingPostProcessor访问配置属性
事件处理：ApplicationListenerMethodAdapter访问事件监听器
注解处理：AnnotatedElementVisitor访问注解元素

Q: 访问者模式在编译器中的应用？

java 复制代码

// AST访问者模式
public interface ASTVisitor {
    void visit(ExpressionNode node);
    void visit(VariableNode node);
    void visit(StatementNode node);
}

// 代码生成访问者
public class CodeGeneratorVisitor implements ASTVisitor {
    private StringBuilder code = new StringBuilder();
  
    @Override
    public void visit(ExpressionNode node) {
        node.getLeft().accept(this);
        code.append(" ").append(node.getOperator()).append(" ");
        node.getRight().accept(this);
    }
  
    public String getGeneratedCode() {
        return code.toString();
    }
}

// 语义分析访问者
public class SemanticAnalyzerVisitor implements ASTVisitor {
    private Map<String, Type> symbolTable = new HashMap<>();
  
    @Override
    public void visit(VariableNode node) {
        if (!symbolTable.containsKey(node.getName())) {
            throw new SemanticError("未声明的变量: " + node.getName());
        }
    }
}

6. 设计权衡类

Q: 访问者模式的优缺点？

A:
优点：

符合开闭原则，易于扩展新操作
将数据结构与操作分离
可以集中管理相关操作
支持复杂的对象结构操作

缺点：

增加新元素类型困难，需要修改所有访问者
破坏了元素的封装性
双重分派增加了复杂性
可能影响性能

Q: 什么时候不应该使用访问者模式？

元素类型经常变化：新增元素类型需要修改所有访问者
操作简单：简单操作不需要复杂的状态管理
性能要求极高：双重分派可能影响性能
元素封装性重要：访问者模式会破坏封装性

使用总结

适用场景总结

1. 必须使用访问者模式的场景

编译器AST处理：语法分析、语义分析、代码生成
文件系统操作：文件搜索、大小计算、权限检查
图形渲染系统：渲染、碰撞检测、变换操作
配置验证系统：配置项验证、规则检查
数据库查询优化：查询分析、优化建议

2. 可以考虑使用的场景

报表生成：不同类型数据的报表生成
数据转换：不同格式数据的转换
日志分析：不同类型日志的分析处理
测试框架：不同类型测试的执行

最佳实践建议

1. 访问者模式设计原则

java 复制代码

// 建议：使用泛型提高类型安全性
public interface Visitor<T> {
    T visit(ConcreteElementA element);
    T visit(ConcreteElementB element);
}

// 建议：实现访问者基类
public abstract class BaseVisitor<T> implements Visitor<T> {
    protected T defaultResult() {
        return null;
    }
  
    @Override
    public T visit(ConcreteElementA element) {
        return defaultResult();
    }
  
    @Override
    public T visit(ConcreteElementB element) {
        return defaultResult();
    }
}

2. 性能优化建议

java 复制代码

// 建议：使用访问者模式进行批量操作
public class BatchVisitor implements Visitor {
    private List<Object> results = new ArrayList<>();
  
    @Override
    public void visit(ConcreteElementA element) {
        results.add(processElementA(element));
    }
  
    @Override
    public void visit(ConcreteElementB element) {
        results.add(processElementB(element));
    }
  
    public List<Object> getResults() {
        return results;
    }
}

// 建议：使用缓存避免重复计算
public class CachedVisitor implements Visitor {
    private Map<Element, Object> cache = new HashMap<>();
  
    @Override
    public Object visit(ConcreteElementA element) {
        return cache.computeIfAbsent(element, this::computeResult);
    }
}

3. 错误处理建议

java 复制代码

// 建议：实现错误处理机制
public class RobustVisitor implements Visitor {
    private List<String> errors = new ArrayList<>();
  
    @Override
    public void visit(ConcreteElementA element) {
        try {
            processElementA(element);
        } catch (Exception e) {
            errors.add("处理元素A时出错: " + e.getMessage());
        }
    }
  
    public List<String> getErrors() {
        return errors;
    }
  
    public boolean hasErrors() {
        return !errors.isEmpty();
    }
}

与其他模式的结合

1. 与组合模式结合

java 复制代码

// 组合元素访问者模式
public class CompositeElement implements Element {
    private List<Element> children = new ArrayList<>();
  
    @Override
    public void accept(Visitor visitor) {
        // 访问自身
        visitor.visit(this);
      
        // 访问子元素
        for (Element child : children) {
            child.accept(visitor);
        }
    }
  
    public void add(Element element) {
        children.add(element);
    }
}

2. 与策略模式结合

java 复制代码

// 策略访问者模式
public class StrategyVisitor implements Visitor {
    private ProcessingStrategy strategy;
  
    public StrategyVisitor(ProcessingStrategy strategy) {
        this.strategy = strategy;
    }
  
    @Override
    public void visit(ConcreteElementA element) {
        strategy.processElementA(element);
    }
  
    @Override
    public void visit(ConcreteElementB element) {
        strategy.processElementB(element);
    }
}

总结

访问者模式是一个强大的设计模式，特别适用于需要对复杂对象结构进行多种操作的场景。通过双重分派机制，它实现了数据结构与操作的分离，符合开闭原则。在实际应用中，需要根据具体需求选择合适的实现策略，并注意性能优化和错误处理。

关键要点：

双重分派：通过两次方法调用确定操作实现
操作分离：将数据结构与操作分离
扩展开放：新增操作时无需修改现有类
类型安全：使用泛型确保类型安全
性能考虑：注意方法调用开销和内存占用