设计模式（二十三）访问者模式

1、定义

　　封装某些作用于某种数据结构中各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新操作。

2、类型：行为类模式

3、类图

 　　主要角色：

　　　　抽象访问者：抽象类或者接口，声明访问者可以访问哪些元素，具体到程序中就是visit方法中的参数定义哪些对象是可以被访问的；

　　　　访问者：实现抽象访问者所声明的方法，它影响到访问者访问到一个类后该干什么，要做什么事情；

　　　　抽象元素类：抽象类或者接口，声明接受哪一类访问者访问，程序上是通过accept方法中的参数来定义的，抽象类一般有两类方法，一部分是本身的业务逻辑，另外就是允许接收哪类访问者                                        来访问；

　　　　元素类：实现抽象元素类所声明的accept方法，通常都是visitor.visit(this),基本上已经形成一种定式了；

　　　　结构对象：一个元素的容器，一般包含一个容纳多个不同类、不同接口的容器，如List、Set、Map等，在项目中一般很少抽象出这个角色。

4、代码实例

/**
 * @author it-小林
 * @desc   元素接口
 * @date 2021年10月14日 19:38
 */
public interface ComputerPart {

    public void accept(ComputerPartVisitor computerPartVisitor);
}

/**
 * @author it-小林
 * @desc   访问者接口
 * @date 2021年10月14日 19:39
 */
public interface ComputerPartVisitor {
    public void visit(Computer computer);
    public void visit(Mouse mouse);
    public void visit(Keyboard keyboard);
    public void visit(Monitor monitor);
}

/**
 * @author it-小林
 * @desc   鼠标
 * @date 2021年10月14日 19:44
 */
public class Mouse implements ComputerPart{

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}

/**
 * @author it-小林
 * @desc   键盘
 * @date 2021年10月14日 19:40
 */
public class Keyboard implements ComputerPart{
    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}

/**
 * @author it-小林
 * @desc   显示器
 * @date 2021年10月14日 19:42
 */
public class Monitor implements ComputerPart{
    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}

/**
 * @author it-小林
 * @desc   电脑
 * @date 2021年10月14日 19:45
 */
public class Computer implements ComputerPart{
    ComputerPart[] parts;

    public Computer() {
        parts = new ComputerPart[]{new Mouse(), new Keyboard(), new Monitor()};
    }

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        for (ComputerPart computerPart: parts) {
            computerPart.accept(computerPartVisitor);
        }
        computerPartVisitor.visit(this);
    }
}

/**
 * @author it-小林
 * @desc   具体访问者
 * @date 2021年10月14日 19:51
 */
public class ComputerPartDisplayVisitor implements ComputerPartVisitor{

    @Override
    public void visit(Computer computer) {
        System.out.println("Displaying Computer.");
    }

    @Override
    public void visit(Mouse mouse) {
        System.out.println("Displaying Mouse.");
    }

    @Override
    public void visit(Keyboard keyboard) {
        System.out.println("Displaying Keyboard.");
    }

    @Override
    public void visit(Monitor monitor) {
        System.out.println("Displaying Monitor.");
    }
}

/**
 * @author it-小林
 * @desc   客户端
 * @date 2021年10月14日 19:54
 */
public class Client {
    public static void main(String[] args) {
        ComputerPart computer = new Computer();
        computer.accept(new ComputerPartDisplayVisitor());
    }
}

5、优点

• 符合单一职责原则；
• 优秀的扩展性；
• 灵活性。

6、缺点

• 具体元素对访问者公布细节，违反了迪米特原则；
• 具体元素变更比较困难；
• 违反了依赖倒置原则，依赖了具体类，没有依赖抽象。

7、应用场景：

1. 对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作；
2. 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。