问题背景

我们来制作一台电脑，他的硬件有CPU和磁盘，CPU和磁盘类都有一个常量作为他们各自的数据，软件有操作系统来操作CPU和磁盘的常量值，不同的系统可以给CPU和磁盘写入不同的值，要求是不变CPU和磁盘的情况下可以动态升级系统。

解决方案：传统方案

传统方案就是我们直接写两个类CPU和Disk类，然后写一个操作系统类去聚合CPU类和Disk类，这样操作系统就可以操作了。

缺点：
耦合性太强，后期如果要升级系统，我们就要重新那一个cpu和磁盘和新的系统来组成一台电脑。这是不现实的，我们应该是CPU和磁盘不动的情况下动态升级系统。

访问者模式

基本介绍

1）访问者模式：在结构不变的情况下，可以动态改变内部元素的动作。例如上面的问题，结构不变的情况下，我们可以动态升级操作系统
2）主要将数据结构和数据操作分离，解决数据结构和操作耦合性问题。
3）访问者模式的基本工作原理是：在被访问的类里面加一个对外提供的接受访问者的类，然后被访问这将自己交给访问者类，这样访问者类就可以控制被访问者类
4）访问者模式主要应用场景：需要对一个对象结构中的对象进行很多不同操作 （这些操作彼此没有关联），同时需要避免让这些操作“污染”这些对象的类，可以选用访问者模式解决

原理UML类图

1）Element是被访问者接口，他提供一个方法accept来接收一个访问者对象来将自己传给访问者。
2）Visitor是访问者接口，访问者定义了操作被访问者数据的逻辑
3）ObjectStruture类用来存储被访问者
4）如果不明白可以对照下面真实实例的类图来理解

使用访问者模式解决问题

UML类图

1）Hardware是硬件接口，是被访问者，电脑的硬件CpuHardware和DiskHardware 都要继承这个接口
2）OperatingSystemVisitor是操作系统接口，是访问者，不同版本的操作系统都要继承这个接口
3）Computer是电脑类，它聚合了硬件CPU和Disk，通过传入的操作系统visitor类操作CPU和Disk

示例代码

/**
 * 硬件设施接口
 * @author wenqiang
 * @date 2023/6/1
 */
public interface Hardware {

    /**
     * 所有的硬件都可以被访问者访问
     *
     * @param visitor
     */
    void accept(OperatingSystemVisitor visitor);
}

/**
 * CPU
 *
 * @author wenqiang
 * @date 2023/6/1
 */
public class CpuHardware implements Hardware{

    private String commond;

    public String getCommond() {
        return commond;
    }

    public void setCommond(String commond) {
        this.commond = commond;
    }

    @Override
    public void accept(OperatingSystemVisitor visitor) {
        visitor.operateCpu(this);
    }
}

/**
 * 磁盘
 *
 * @author wenqiang
 * @date 2023/6/1
 */
public class DiskHardware implements Hardware{

    private String commond;

    public String getCommond() {
        return commond;
    }

    public void setCommond(String commond) {
        this.commond = commond;
    }

    @Override
    public void accept(OperatingSystemVisitor visitor) {
        visitor.operateDisk(this);
    }
}

/**
 * 访问者 操作系统
 *
 * @author wenqiang
 * @date 2023/6/1
 */
public interface OperatingSystemVisitor {
    /**
     * 访问者操作CPU
     *
     * @param cpu
     */
    void operateCpu(CpuHardware cpu);

    /**
     * 访问者操作Disk
     *
     * @param disk
     */
    void operateDisk(DiskHardware disk);
}

/**
 * 电脑
 * 
 * @author wenqiang
 * @date 2023/6/1
 */
public class Computer {

    private CpuHardware cpu;

    private DiskHardware disk;

    private OperatingSystemVisitor visitor;

    public Computer(OperatingSystemVisitor visitor) {
        cpu = new CpuHardware();
        disk = new DiskHardware();
        this.visitor = visitor;
    }

    public void printCpu() {
        cpu.accept(visitor);
        System.out.println("CPU输出：" + cpu.getCommond());
    }

    public void printDisk() {
        disk.accept(visitor);
        System.out.println("磁盘输出：" + disk.getCommond());
    }
}

第一个版本的操作系统我们写“1+1=1”，写错了指令，我们升级版本来更新这个指令，所以版本二变为了写“1+1=2”

/**
 * 访问者 操作系统版本1
 * 
 * @author wenqiang
 * @date 2023/6/1
 */
public class OperatingSystemVersion_1 implements OperatingSystemVisitor{

    @Override
    public void operateCpu(CpuHardware cpu) {
        cpu.setCommond("运算1+1=1");
    }

    @Override
    public void operateDisk(DiskHardware disk) {
        disk.setCommond("记住1+1=1");
    }
}

/**
 * 操作系统版本2
 * 
 * @author wenqiang
 * @date 2023/6/1
 */
public class OperatingSystemVersion_2 implements OperatingSystemVisitor{


    @Override
    public void operateCpu(CpuHardware cpu) {
        cpu.setCommond("运算1+1=2");
    }

    @Override
    public void operateDisk(DiskHardware disk) {
        disk.setCommond("记住1+1=2");
    }
}

使用者

/**
 * 使用者
 *
 * @author wenqiang
 * @date 2023/6/1
 */
public class Client {
    public static void main(String[] args) {
        OperatingSystemVisitor visitor_1 = new OperatingSystemVersion_1();
        Computer computer_1 = new Computer(visitor_1);
        computer_1.printCpu();
        computer_1.printDisk();

        // 我们发现系统编写错误了，升级系统
        OperatingSystemVisitor visitor_2 = new OperatingSystemVersion_2();
        Computer computer_2 = new Computer(visitor_2);
        computer_2.printCpu();
        computer_2.printDisk();
    }
}

运行结果

注意事项和细节

优点
1）访问者模式符合单一职责原则、让程序具有优秀的扩展性、灵活性非常高
2）访问者模式可以对功能进行统一，可以做报表、UI、拦截器与过滤器，适用于数据结构相对稳定的系统

缺点
1）具体元素对访问者公布细节，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的，这样造成了具体元素变更比较困难
2）违背了依赖倒转原则。访问者依赖的是具体元素，而不是抽象元素
3）因此，如果一个系统有比较稳定的数据结构，又有经常变化的功能需求，那么访问者模式就是比较合适的.