设计模式-行为型之访问者(Visitor)模式

定义

• 将数据结构和对数据结构的操作分离。

使用场景

• 稳定的数据结构和易变的操作耦合问题。
• 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。

UML图

代码实现

代码来源：https://www.jianshu.com/p/1f1049d0a0f4
年底，CEO和CTO开始评定员工一年的工作绩效，员工分为工程师和经理，CTO关注工程师的代码量、经理的新产品数量；CEO关注的是工程师的KPI和经理的KPI以及新产品数量。
由于CEO和CTO对于不同员工的关注点是不一样的，这就需要对不同员工类型进行不同的处理。访问者模式此时可以派上用场了。

// 员工基类
public abstract class Staff {
     

    public String name;
    public int kpi;// 员工KPI

    public Staff(String name) {
     
        this.name = name;
        kpi = new Random().nextInt(10);
    }
    // 核心方法，接受Visitor的访问
    public abstract void accept(Visitor visitor);
}
// 工程师
public class Engineer extends Staff {
     

    public Engineer(String name) {
     
        super(name);
    }

    @Override
    public void accept(Visitor visitor) {
     
        visitor.visit(this);
    }
    // 工程师一年的代码数量
    public int getCodeLines() {
     
        return new Random().nextInt(10 * 10000);
    }
}
// 经理
public class Manager extends Staff {
     

    public Manager(String name) {
     
        super(name);
    }

    @Override
    public void accept(Visitor visitor) {
     
        visitor.visit(this);
    }
    // 一年做的产品数量
    public int getProducts() {
     
        return new Random().nextInt(10);
    }
}
// 员工业务报表类（对象结构）
public class BusinessReport {
     

    private List<Staff> mStaffs = new LinkedList<>();

    public BusinessReport() {
     
        mStaffs.add(new Manager("经理-A"));
        mStaffs.add(new Engineer("工程师-A"));
        mStaffs.add(new Engineer("工程师-B"));
        mStaffs.add(new Engineer("工程师-C"));
        mStaffs.add(new Manager("经理-B"));
        mStaffs.add(new Engineer("工程师-D"));
    }

    /**
     * 为访问者展示报表
     * @param visitor 公司高层，如CEO、CTO
     */
    public void showReport(Visitor visitor) {
     
        for (Staff staff : mStaffs) {
     
            staff.accept(visitor);
        }
    }
}
public interface Visitor {
     

    // 访问工程师类型
    void visit(Engineer engineer);

    // 访问经理类型
    void visit(Manager manager);
}
// CEO访问者
public class CEOVisitor implements Visitor {
     
    @Override
    public void visit(Engineer engineer) {
     
        System.out.println("工程师: " + engineer.name + ", KPI: " + engineer.kpi);
    }

    @Override
    public void visit(Manager manager) {
     
        System.out.println("经理: " + manager.name + ", KPI: " + manager.kpi +
                ", 新产品数量: " + manager.getProducts());
    }
}
// CTO访问者
public class CTOVisitor implements Visitor {
     
    @Override
    public void visit(Engineer engineer) {
     
        System.out.println("工程师: " + engineer.name + ", 代码行数: " + engineer.getCodeLines());
    }

    @Override
    public void visit(Manager manager) {
     
        System.out.println("经理: " + manager.name + ", 产品数量: " + manager.getProducts());
    }
}

总结

• 稳定的数据结构和易变的操作耦合问题；将对象本身与对象的访问操作分离。

• 优点：
  – 符合单一职责原则。
  – 优秀的扩展性、灵活性。

• 缺点：
  – 具体元素对访问者公布细节，违反了迪米特原则。
  – 违反了依赖倒置原则，依赖了具体类，没有依赖抽象。

• 使用场景：
  – 一个对象结构（BusinessReport ）包含多个类型（manager、Engineer ）的对象，希望对这些对象实施一些依赖其具体类型的操作。不同类型的对象可以有不同的访问操作。
  – 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而且需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。