访问者模式是设计模式中行为型模式的一种（其他的还有如创建型、结构型），听说是设计模式中比较难理解的一种，最近项目中用到了该模式，所以今天总结和实践一下。

一、访问者模式要解决的问题：

稳定的数据结构和易变的操作耦合问题

二、动手实现访问者模式Demo

这里使用学校体育馆和访客的例子，体育馆里有一些场馆如羽毛球馆、篮球馆、乒乓球馆，学生可以到体育馆进行打球。

1. 不使用设计模式常规实现

先演示下没有使用访问者模式的实现，首先，学校体育馆抽象类如下：

public abstract class Gymnasium {
    protected String people;
    public Gymnasium(String people) {
        this.people = people;
    }
}

然后，几种体育场馆的实现类：

/**
 * 羽毛球馆
 */
public class BadmintonHall extends Gymnasium{
    public BadmintonHall(String people) {
        super(people);
    }

    @Override
    protected void playBall() {
        System.out.println(">>>>>>"+people+"在打羽毛球");
    }
}
/**
 * 篮球场馆
 */
public class BasketballCourt extends Gymnasium{

    public BasketballCourt(String people) {
        super(people);
    }

    @Override
    protected void playBall() {
        System.out.println(">>>>>>"+people+"在打篮球");
    }
}
/**
 * 乒乓球场馆
 */
public class TableTennisHall extends Gymnasium{

    public TableTennisHall(String people) {
        super(people);
    }

    @Override
    protected void playBall() {
        System.out.println(">>>>>>"+people+"在打乒乓球");
    }
}

测试结果

public class ClientTest {
    public static void main(String[] args) {
        List<Gymnasium> gymnasiums=new ArrayList<>();
        gymnasiums.add(new BadmintonHall("小张"));
        gymnasiums.add(new BasketballCourt("小王"));
        gymnasiums.add(new BasketballCourt("小亮"));
        gymnasiums.add(new TableTennisHall("小崔"));

        for (Gymnasium gymnasium : gymnasiums) {
            gymnasium.playBall();
        }
    }
}
// 运行结果：
>>>>>>小张在打羽毛球
>>>>>>小王在打篮球
>>>>>>小亮在打篮球
>>>>>>小崔在打乒乓球

这样就实现了我们想要的功能，试想一种情况，学校里的体育馆有时候不仅让我们课下打球，有时还需要上体育课，这个时候，每个体育场馆实现类都要增加一个上体育课的方法，这样其实违背了开闭原则，随着功能的不断增加，每个类代码会不断增多，如果我们不想频繁修改原有类，就可以按照访问者设计模式把业务操作提取到外边，访问者模式的类的基本结构如下：

• 抽象元素（Element），如体育场馆，包含了一个accept()接口
• 具体元素（ConcreteElement）,具体的体育场馆，如篮球场馆，乒乓球场馆，实现抽象元素的accept()方法
• 抽象访问者（Visitor）,为每一个具体元素定义一个visit操作方法
• 具体访问者（ConcreteVisitor）,也就是抽取出来的方法，指明了访问者访问时具体的操作内容
• 对象结构（ObjectStructure）,一个集合，用于存放元素对象，提供让访问者遍历内部元素的方法，通常由List、Set、Map等实现。

2. 访问者模式实现

访问者接口及其实现类如下：

public interface Visitor {
    void visit(BadmintonHall badmintonHall);
    void visit(BasketballCourt basketballCourt);
    void visit(TableTennisHall tableTennisHall);
}

public class PlayBallVisitor implements Visitor{
    @Override
    public void visit(BadmintonHall badmintonHall) {
        System.out.println(">>>>>>"+badmintonHall.people+"在打羽毛球");
    }

    @Override
    public void visit(BasketballCourt basketballCourt) {
        System.out.println(">>>>>>"+basketballCourt.people+"在打篮球");
    }

    @Override
    public void visit(TableTennisHall tableTennisHall) {
        System.out.println(">>>>>>"+tableTennisHall.people+"在打乒乓球");
    }
}

学校体育馆及其实现类

public abstract class Gymnasium {

    protected String people;

    public Gymnasium(String people) {
        this.people = people;
    }

    abstract void accept(Visitor visitor);
}
/**
 * 羽毛球馆
 */
public class BadmintonHall extends Gymnasium{
    public BadmintonHall(String people) {
        super(people);
    }

    @Override
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
/**
 * 篮球场
 */
public class BasketballCourt extends Gymnasium{

    public BasketballCourt(String people) {
        super(people);
    }

    @Override
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
/**
 * 乒乓球场馆
 */
public class TableTennisHall extends Gymnasium{

    public TableTennisHall(String people) {
        super(people);
    }
    @Override
    void accept(Visitor visitor) {
        visitor.visit(this);
    }

}

客户端测试，运行结果和之前相同

public class Client {
    public static void main(String[] args) {
        List<Gymnasium> gymnasiums=new ArrayList<>();
        gymnasiums.add(new BadmintonHall("小张"));
        gymnasiums.add(new BasketballCourt("小王"));
        gymnasiums.add(new BasketballCourt("小亮"));
        gymnasiums.add(new TableTennisHall("小崔"));

        PlayBallVisitor playBallVisitor=new PlayBallVisitor();
        for (Gymnasium gymnasium : gymnasiums) {
            gymnasium.accept(playBallVisitor);
        }
    }
}
// 运行结果如下：
>>>>>>小张在打羽毛球
>>>>>>小王在打篮球
>>>>>>小亮在打篮球
>>>>>>小崔在打乒乓球

3.试想一次扩展

假如新增一个上体育课的操作方法，此时只需要增加一个Visitor的实现类即可

public class PEVisitor implements Visitor{
    @Override
    public void visit(BadmintonHall badmintonHall) {
        System.out.println(">>>>>>"+badmintonHall.people+"在羽毛球馆教羽毛球课");
    }

    @Override
    public void visit(BasketballCourt basketballCourt) {
        System.out.println(">>>>>>"+basketballCourt.people+"在篮球馆指导学生练习篮球");
    }

    @Override
    public void visit(TableTennisHall tableTennisHall) {
        System.out.println(">>>>>>"+tableTennisHall.people+"在乒乓球馆指导学生练习乒乓球");
    }
}

测试结果如下：

public class Client {
    public static void main(String[] args) {
        List<Gymnasium> stuGymnasiums=new ArrayList<>();
        stuGymnasiums.add(new BadmintonHall("小张"));
        stuGymnasiums.add(new BasketballCourt("小王"));
        stuGymnasiums.add(new BasketballCourt("小亮"));
        stuGymnasiums.add(new TableTennisHall("小崔"));

        List<Gymnasium> gymnasiums=new ArrayList<>();
        gymnasiums.add(new BadmintonHall("张老师"));
        gymnasiums.add(new BasketballCourt("王老师"));
        gymnasiums.add(new TableTennisHall("李老师"));

        PlayBallVisitor playBallVisitor=new PlayBallVisitor();
        for (Gymnasium stuGymnasium : stuGymnasiums) {
            stuGymnasium.accept(playBallVisitor);
        }
        PEVisitor peVisitor=new PEVisitor();
        for (Gymnasium gymnasium : gymnasiums) {
            gymnasium.accept(peVisitor);
        }
    }
}
// 运行结果
>>>>>>小张在打羽毛球
>>>>>>小王在打篮球
>>>>>>小亮在打篮球
>>>>>>小崔在打乒乓球
>>>>>>张老师在羽毛球馆教羽毛球课
>>>>>>王老师在篮球馆指导学生练习篮球
>>>>>>李老师在乒乓球馆指导学生练习乒乓球

可以看到，访问者模式实现的关键是对Vistior类的抽取，以及每个元素Element有个关键的方法accept()，来接受Visitor的访问，accept方法在调用 visitor.visit(this)时候，就可以拿到当前具体元素的信息进行操作了。上面例子的类图如下：

三、访问者模式的应用场景

我们需要对一组对象进行一些业务操作，但为了避免不断的在对象中添加功能“污染”到原来的对象，导致类越来越臃肿，职责不够单一，可以使用访问者模式，将对象新增加的业务操作抽离出来，放在具体的访问者接口和实现类中。

实际应用中，如复杂的嵌套结构访问就可以使用访问者模式，如对文件系统的遍历，文件系统是一个树状结构，包含文件和文件夹等元素。使用访问者模式可以设计一个访问者，用于执行不同的操作，比如计算文件夹大小、统计文件数量等。如java.nio.file包中的FileVistor类，就用到了访问者模式。

四、优缺点

优点：

• 符合单一职责原则；
• 新增新访问操作，只需要实现一个访问类，符合开闭原则；
• 灵活、易扩展；

缺点：

• 代码可读性差，不了解该模式，则难以理解；
• 新增新元素的时候，需要修改抽象访问者和具体访问者实现类，违背开闭原则；
• 访问某个元素时，可能没有访问元素私有成员变量和方法的必要权限

五、访问者模式中的伪动态双分派概念

访问者模式中的伪动态双分派，是指在执行操作时，根据两个元素的类型动态地选择执行哪个方法。这个"伪动态双分派"是因为在很多编程语言中，并没有真正支持双分派（double dispatch），而是通过一些技巧来实现类似的效果。上面代码中我们元素实现了

@Override
    void accept(Visitor visitor) {
        visitor.visit(this);
    }

这里的伪动态双分派体现在accept方法的调用上。第一次单分派，是执行的哪一个元素的accept方法，第二次分派是执行的哪个visitor的visit方法。根据元素类型和访问者类型的动态选择方法的调用，从而达到双分派的效果。

分派的概念，就是指在运行时确定程序应该调用哪个具体的方法或函数的过程。分派的方式可以分为静态分派和动态分派两种，静态分派在编译器，如方法重装，动态分派在运行期，如方法重写。

参考文档：
https://refactoringguru.cn/design-patterns/visitor