高级设计模式：责任链与访问者

概述

高级设计模式是解决复杂问题的常用方案。本教程介绍责任链、访问者和解释器模式。

1. 责任链模式

// 责任链模式：将请求沿着处理链传递
public abstract class Handler {
    protected Handler next;
    
    public Handler setNext(Handler next) {
        this.next = next;
        return next;
    }
    
    public abstract void handle(Request request);
}

public class ConcreteHandler1 extends Handler {
    @Override
    public void handle(Request request) {
        if (canHandle(request)) {
            System.out.println("Handler1处理");
        } else if (next != null) {
            next.handle(request);
        }
    }
    
    private boolean canHandle(Request request) {
        return request.getType() == 1;
    }
}

public class ConcreteHandler2 extends Handler {
    @Override
    public void handle(Request request) {
        if (canHandle(request)) {
            System.out.println("Handler2处理");
        } else if (next != null) {
            next.handle(request);
        }
    }
    
    private boolean canHandle(Request request) {
        return request.getType() == 2;
    }
}

2. 访问者模式

// 访问者模式：在不修改类的情况下添加新操作
public interface Visitor {
    void visit(ElementA element);
    void visit(ElementB element);
}

public class ConcreteVisitor implements Visitor {
    @Override
    public void visit(ElementA element) {
        System.out.println("访问ElementA");
    }
    
    @Override
    public void visit(ElementB element) {
        System.out.println("访问ElementB");
    }
}

public interface Element {
    void accept(Visitor visitor);
}

public class ElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class ElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

3. 解释器模式

// 解释器模式：定义语法并解释执行
public interface Expression {
    int interpret();
}

public class NumberExpression implements Expression {
    private int number;
    
    public NumberExpression(int number) {
        this.number = number;
    }
    
    @Override
    public int interpret() {
        return number;
    }
}

public class AddExpression implements Expression {
    private Expression left;
    private Expression right;
    
    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
    
    @Override
    public int interpret() {
        return left.interpret() + right.interpret();
    }
}

4. 实际应用示例

过滤器链

@Component
public class FilterChain {
    private final List<Filter> filters;
    
    public void doFilter(Request request, Response response) {
        for (Filter filter : filters) {
            if (!filter.doFilter(request, response)) {
                return;
            }
        }
    }
}

public interface Filter {
    boolean doFilter(Request request, Response response);
}

AST遍历

public class ASTVisitor {
    public void visit(Node node) {
        if (node instanceof NumberNode) {
            visitNumber((NumberNode) node);
        } else if (node instanceof OperatorNode) {
            visitOperator((OperatorNode) node);
        }
    }
    
    private void visitNumber(NumberNode node) {
        System.out.println("数字: " + node.getValue());
    }
    
    private void visitOperator(OperatorNode node) {
        System.out.println("运算符: " + node.getOperator());
        visit(node.getLeft());
        visit(node.getRight());
    }
}

5. 最佳实践

1. 责任链模式：用于请求处理、日志记录等
2. 访问者模式：用于AST遍历、文档处理等
3. 解释器模式：用于DSL、规则引擎等
4. 组合使用：多种模式可以组合使用
5. 适度使用：避免过度设计

总结

高级设计模式是解决复杂问题的常用方案。掌握责任链、访问者和解释器模式，可以编写更灵活、更可维护的代码。