迹忆客 专注技术分享

今天，我们来学习最有用的模式之一， 访问者模式（Visitor Pattern）。

什么是访问者模式？ 好吧，让我们看一个例子。

假设你是在大学工作的软件工程师。 该大学很少有既定的荣誉标准。 这些标准可分为以下三类：以研究为中心、以学术为中心和混合方法。 每年，学校董事会都会随机选择一种策略，看看哪些学生和教授有资格获得奖励

假设你已经实现了以下类：

Student 类

public class Student extends Person {
    int researchScore;
    int academicScore;
    int hybridScore;

    public int getResearchScore() {
        return researchScore;
    }

    public void setResearchScore(int researchScore) {
        this.researchScore = researchScore;
    }

    public int getAcademicScore() {
        return academicScore;
    }

    public void setAcademicScore(int academicScore) {
        this.academicScore = academicScore;
    }

    public int getHybridScore() {
        return hybridScore;
    }

    public void setHybridScore(int hybridScore) {
        this.hybridScore = hybridScore;
    }

}

Professor 类

public class Professor extends Person {
    int researchScore;
    int academicScore;
    int hybridScore;

    public int getResearchScore() {
        return researchScore;
    }

    public void setResearchScore(int researchScore) {
        this.researchScore = researchScore;
    }

    public int getAcademicScore() {
        return academicScore;
    }

    public void setAcademicScore(int academicScore) {
        this.academicScore = academicScore;
    }

    public int getHybridScore() {
        return hybridScore;
    }

    public void setHybridScore(int hybridScore) {
        this.hybridScore = hybridScore;
    }
}

你已经实现了 Student、Professor POJO 类。 我们还有一个 Professor 和 Student 继承的父类 Person。 此外，为了评估分数以及哪些人有资格获得奖励，我们将实现一个 Manager 类，该类具有一个函数assessPeople(Person person, int strategy)，它将用不同的策略评估不同的人。

Manager 类

public class Manager {
    /**
     * 0 表示 research 方法
     * 1 表示 academic 方法
     * 2 表示 hybrid 方法
     */
    int strategy;

    public void assessPeople(Person person, int strategy) {
        // 很大程度上取决于 Person 的类型和 strategy 类型。
    }
}

现在，如果我们采用传统方法，我们将在 Manager 类中编写大量 if 语句：我们必须为每种类型的人（学生、教授）的每个奖项选择策略编写逻辑。 在我们的例子中，我们可以处理这个问题，但是如果我们想要评估 5,6,..10 种策略和 5 种人怎么办？ 代码将很快变得难以管理。

幸运的是，我们可以有以下访问者模式(Visitor Pattern)来拯救。 我们将设计一个简单的 Visitor 接口。 它只是声明了两个抽象函数，名称为 visit。

AssessVisitor 接口

public interface AssessVisitor {
    abstract public void Visit(Student student);
    abstract public void Visit(Professor professor);
}

这里要注意，我们还没有应用任何具体的策略。 相反，我们分别为这些策略创建了三个具体的类，如下所示：

ResearchApproach 类

public class ResearchApproach implements AssessVisitor {
    @Override
    public void Visit(Student student) {
        if(student.getResearchScore() >= 70) {
            System.out.println("The student is on deans list based on ResearchApproach");

        }
    }

    @Override
    public void Visit(Professor professor) {
        if(professor.getResearchScore() >= 70) {
            System.out.println("The professor is on deans list based on ResearchApproach");
        }
    }
}

AcademicApproach 类

public class AcademicApproach implements AssessVisitor {
    @Override
    public void Visit(Student student) {
        if(student.getResearchScore() >= 70) {
            System.out.println("The student is on deans list based on AcademicApproach");

        }
    }

    @Override
    public void Visit(Professor professor) {
        if(professor.getResearchScore() >= 70) {
            System.out.println("The professor is on deans list based on AcademicApproach");
        }
    }
}

HybridApproach 类

public class HybridApproach implements AssessVisitor {
    @Override
    public void Visit(Student student) {
        if(student.getResearchScore() >= 70) {
            System.out.println("The student is on deans list based on HybridApproach");

        }
    }

    @Override
    public void Visit(Professor professor) {
        if(professor.getResearchScore() >= 70) {
            System.out.println("The professor is on deans list based on HybridApproach");
        }
    }
}

在这两个类中，我们实现了具体的逻辑来评估候选人是否有资格获得奖励。

此外，我们将在 Person 类及其子类中添加一个 accept() 函数。

Person 类

public class Person {
    public void getAssessed(AssessVisitor visitor) {}
}

具有 getAssessed 方法的 Student类

public class Student extends Person {
    int researchScore;
    int academicScore;
    int hybridScore;

    public int getResearchScore() {
        return researchScore;
    }

    public void setResearchScore(int researchScore) {
        this.researchScore = researchScore;
    }

    public int getAcademicScore() {
        return academicScore;
    }

    public void setAcademicScore(int academicScore) {
        this.academicScore = academicScore;
    }

    public int getHybridScore() {
        return hybridScore;
    }

    public void setHybridScore(int hybridScore) {
        this.hybridScore = hybridScore;
    }

    @Override
    public void getAssessed(AssessVisitor visitor) {
        visitor.Visit(this);
    }
}

具有 getAssessed 方法的 Professor 类

public class Professor extends Person {
    int researchScore;
    int academicScore;
    int hybridScore;

    public int getResearchScore() {
        return researchScore;
    }

    public void setResearchScore(int researchScore) {
        this.researchScore = researchScore;
    }

    public int getAcademicScore() {
        return academicScore;
    }

    public void setAcademicScore(int academicScore) {
        this.academicScore = academicScore;
    }

    public int getHybridScore() {
        return hybridScore;
    }

    public void setHybridScore(int hybridScore) {
        this.hybridScore = hybridScore;
    }

    @Override
    public void getAssessed(AssessVisitor visitor) {
        visitor.Visit(this);
    }
}

现在，一切准备就绪，剩下要做的就是将我们的 Manager 类修改为简单的格式：

Manager 类

public class Manager {
    public void assessPeople(Person person, AssessVisitor visitor) {
        person.getAssessed(visitor);
    }
}

现在，一切都完成了。随意编写一个 main 方法来测试它是否有效！

现在，除了示例之外，我们将总结一下访问者模式。通常，如果行为（功能逻辑）发生变化，就会出现访问者模式，或者更抽象地说，访问者模式将算法模式的内容与其工作的对象分开。在我们的示例中，策略会发生变化，人员类型也会发生变化，我们将访问者模式将评估和人员类的逻辑解耦。

通常，访问者模式将有一个访问者接口，该接口具有为不同目标（类）定义的方法。然后，每当需要添加新的算法模式或改变一种算法模式时，我们只需要实现一个实现访问者接口的新类。然后，在对象的类中，我们需要添加一个接受访问者对象（任何实现访问者接口的东西）的方法，并调用visitor.visit(this)。之后，Java 的多态性处理其余部分。请参阅下面的 UML 图

正如上图显示的那样，访问方法的逻辑与对象是解耦的。

现在，我们已经了解了访问者模式的来龙去脉。 尝试写一个例子并从中获得乐趣！