访问者模式

目录

• 访问者模式
  • 案例
  • 模式介绍
  • 代码改造
  • 模式应用
  • 总结
  • 参考资料

访问者模式

案例

张三所在公司欲为某高校开发一套奖励审批系统，该系统可以实现教师奖励和学生奖励的审批(Award Check)，如果教师发表论文数超过10篇或者学生论文超过2篇可以评选科研奖，如果教师教学反馈分大于等于90分或者学生平均成绩大于等于90分可以评选成绩优秀奖。该系统主要用于判断候选人集合中的教师或学生是否符合某种获奖要求。张三想了想就开始动手写起来了。

1.首先他定义了一个父类：

// 父类，主要存放一些公共字段
public class Person {
    // 姓名
    private String name;
    // 论文数
    private int paperNums;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPaperNums() {
        return paperNums;
    }

    public void setPaperNums(int paperNums) {
        this.paperNums = paperNums;
    }
}

2.然后分别是两个实体类：

老师类：

// 老师类
public class Teacher extends Person {
    // 教学反馈分
    private int feedbackScore;

    public Teacher(String name, int paperNums, int feedbackScore) {
        this.setName(name);
        this.setPaperNums(paperNums);
        this.feedbackScore = feedbackScore;
    }

    public int getFeedbackScore() {
        return feedbackScore;
    }

    public void setFeedbackScore(int feedbackScore) {
        this.feedbackScore = feedbackScore;
    }
}

学生类：

// 学生类
public class Student extends Person {
    // 平均成绩
    private int averageScore;

    public Student(String name, int paperNums, int averageScore) {
        this.setName(name);
        this.setPaperNums(paperNums);
        this.averageScore = averageScore;
    }

    public int getAverageScore() {
        return averageScore;
    }

    public void setAverageScore(int averageScore) {
        this.averageScore = averageScore;
    }
}

3.奖励审批系统关键代码：

// 奖励审批系统
public class AwardCheckSystem {
    // 存放元素的容器
    private List<Person> personList = new ArrayList<>();

    // 添加元素方法
    public void addPerson(Person person) {
        personList.add(person);
    }

    // 系统判断评选资格核心代码
    public void awardCheck(String prize) {
        if (prize.equals("research")) {
            for (Person person : personList) {
                int paperNums = person.getPaperNums();
                if (person instanceof Teacher && paperNums > 10) {
                    System.out.println(person.getName() + "老师发表论文数为：" + paperNums + "，拥有评选科研奖资格");
                } else if (person instanceof Student && paperNums > 2) {
                    System.out.println(person.getName() + "同学发表论文数为：" + paperNums + "，拥有评选科研奖资格");
                }
            }
        } else if (prize.equals("excellent")) {
            for (Person person : personList) {
                if (person instanceof Teacher && ((Teacher) person).getFeedbackScore() >= 90) {
                    System.out.println(person.getName() + "老师发表教学反馈分为：" + ((Teacher) person).getFeedbackScore() + "，拥有评选成绩优秀奖资格");
                } else if (person instanceof Student && ((Student) person).getAverageScore() >= 90) {
                    System.out.println(person.getName() + "同学平均成绩为：" + ((Student) person).getAverageScore() + "，拥有评选成绩优秀奖资格");
                }
            }
        }
    }
}

4.客户端使用：

public class Main {
    public static void main(String[] args) {
        AwardCheckSystem awardCheckSystem = new AwardCheckSystem();
        awardCheckSystem.addPerson(new Teacher("张三", 9, 91));
        awardCheckSystem.addPerson(new Teacher("李四", 11, 89));
        awardCheckSystem.addPerson(new Student("王五", 1, 92));
        awardCheckSystem.addPerson(new Student("赵六", 3, 88));
        System.out.println("拥有评选科研奖资格的人有：");
        awardCheckSystem.awardCheck("research");
        System.out.println("----------------------------------------------");
        System.out.println("拥有评选成绩优秀奖资格的人有：");
        awardCheckSystem.awardCheck("excellent");
    }
}

5.使用结果：

拥有评选科研奖资格的人有：
李四老师发表论文数为：11，拥有评选科研奖资格
赵六同学发表论文数为：3，拥有评选科研奖资格
----------------------------------------------
拥有评选成绩优秀奖资格的人有：
张三老师发表教学反馈分为：91，拥有评选成绩优秀奖资格
王五同学平均成绩为：92，拥有评选成绩优秀奖资格

张三很快就写出了奖励审批系统中最核心的代码，但是他觉得在awardCheck()方法中通过奖项名称和人员类型判断是否有资格评选奖项的代码看上去很是复杂，他想要改进一下。刚好在设计模式中对于这种集合对象中存在多种不同元素，同时对于这些不同元素不同的处理者会有不同的处理方式的情况可以使用访问者模式对其进行改进。

模式介绍

访问者模式(Visitor Pattern):提供一个作用于某对象结构中的各元素的操作表示，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。

角色构成

• Vistor（抽象访问者）：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作。
• ConcreteVisitor（具体访问者）：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。
• Element（抽象元素）：抽象元素一般是抽象类或者接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。【稍后将介绍为什么要这样设计。】
• ConcreteElement（具体元素）：具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。
• ObjectStructure（对象结构）：对象结构是一个元素的集合，它用于存放元素对象，并且提供了遍历其内部元素的方法。它可以结合组合模式来实现，也可以是一个简单的集合对象，如一个List对象或一个Set对象。

UML 类图

访问者模式是一种较为复杂的行为型设计模式，它不是那么容易理解的，这里再描述一下访问者模式的定义以及上面几个角色作用。

• 首先它是作用于某对象结构中的各元素的操作的，具体表现就是ObjectStructure（对象结构）保存了Element抽象元素中的各个ConcreteElement具体元素，并提供遍历操作各个具体元素的方法，类图中为accept()方法。

• 抽象元素Element中定义了accept(Visitor visitor)方法，用于接受访问者访问的方法，并在具体元素类ConcreteElement中的具体方法中调用访问者的方法同时将具体元素作为参数传递个访问者。

• 抽象访问者中定义了访问不同元素的接口方法，便于对象结构ObjectStructure类中方法的调用，同时具体访问者完成访问不同元素的具体实现代码。

这样就构成了访问者模式在不改变各元素的类的前提下定义作用于这些元素的新操作。

代码改造

1.首先是抽象元素与具体元素类：

抽象父类：

// 父类，主要存放一些公共字段
public abstract class Person {
    // 定义用于访问者访问的方法
    public abstract void accept(Award award);
}

老师类：

// 老师类
public class Teacher extends Person {
    // 实现访问者访问元素的方法
    @Override
    public void accept(Award award) {
        award.visit(this);
    }
}

学生类：

// 学生类
public class Student extends Person {
    // 实现访问者访问元素的方法
    @Override
    public void accept(Award award) {
        award.visit(this);
    }
}

这三个类相较于改造前的类主要是多了accept(Award award)方法，其他代码完全一样，因此省略了重复代码。

2.抽象访问者类：

// 抽象访问者，定义访问具体元素的方法
public interface Award {
    // 提供访问老师类接口
    void visit(Teacher person);
    // 提供访问学生类接口
    void visit(Student person);
}

3.两个具体访问者类：

科研奖资格判断类：

// 科研奖资格判断类（具体访问者类角色）
public class ResearchAward implements Award {
    @Override
    public void visit(Teacher person) {
        int paperNums = person.getPaperNums();
        if (paperNums > 10) {
            System.out.println(person.getName() + "老师发表论文数为：" + paperNums + "，拥有评选科研奖资格");
        }
    }

    @Override
    public void visit(Student person) {
        int paperNums = person.getPaperNums();
        if (paperNums > 2) {
            System.out.println(person.getName() + "同学发表论文数为：" + paperNums + "，拥有评选科研奖资格");
        }
    }
}

成绩优秀奖资格判断类：

// 成绩优秀奖资格判断类（具体访问者类）
public class ExcellentAward implements Award {
    @Override
    public void visit(Teacher person) {
        if (person.getFeedbackScore() >= 90) {
            System.out.println(person.getName() + "老师发表教学反馈分为：" + person.getFeedbackScore() + "，拥有评选成绩优秀奖资格");
        }
    }

    @Override
    public void visit(Student person) {
        if (person.getAverageScore() >= 90) {
            System.out.println(person.getName() + "同学平均成绩为：" + person.getAverageScore() + "，拥有评选成绩优秀奖资格");
        }
    }
}

4.对象结构类：

// 奖励审批系统（对象结构类角色）
public class AwardCheckSystem {
    // 存放元素的容器
    private List<Person> personList = new ArrayList<>();

    // 添加元素方法
    public void addPerson(Person person) {
        personList.add(person);
    }

    // 系统判断评选资格核心代码
    public void awardCheck(Award award) {
        for (Person person : personList) {
            person.accept(award);
        }
    }
}

5.客户端使用：

public class Main {
    public static void main(String[] args) {
        AwardCheckSystem awardCheckSystem = new AwardCheckSystem();
        awardCheckSystem.addPerson(new Teacher("张三", 9, 91));
        awardCheckSystem.addPerson(new Teacher("李四", 11, 89));
        awardCheckSystem.addPerson(new Student("王五", 1, 92));
        awardCheckSystem.addPerson(new Student("赵六", 3, 88));
        System.out.println("拥有评选科研奖资格的人有：");
        awardCheckSystem.awardCheck(new ResearchAward());
        System.out.println("----------------------------------------------");
        System.out.println("拥有评选成绩优秀奖资格的人有：");
        awardCheckSystem.awardCheck(new ExcellentAward());
    }
}

拥有评选科研奖资格的人有：
李四老师发表论文数为：11，拥有评选科研奖资格
赵六同学发表论文数为：3，拥有评选科研奖资格
----------------------------------------------
拥有评选成绩优秀奖资格的人有：
张三老师发表教学反馈分为：91，拥有评选成绩优秀奖资格
王五同学平均成绩为：92，拥有评选成绩优秀奖资格

经过改造之后输出结果和上面的一摸一样，但奖励审批系统判断奖项评选资格的核心代码变得非常简洁。同时如果要有其他的奖项资格判断，只需要增加一个新的具体访问者类并在新的奖项资格判断类中添加具体的判断逻辑就可以了，大大提高了系统的可扩展性。

访问者模式也有一个很是明显的问题，它在添加新的访问者的时候是很容易的，但在添加新的元素时较为麻烦。在这个奖项审批系统案例里面因为需求就是判断老师和学生是否有评奖资格，涉及到的元素只有老师和学生，应该也不会出现变化，但是还有可能评选其他奖项的资格，所以这里用访问者模式是很合适的。

模式应用

访问者模式在合适的场景下使用之后，会使代码变得更加灵活易于扩展。下面通过介绍它在 Spring 中的具体应用，让我们对模式的应用更加深刻。

1.首先是 pom.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>design-pattern</artifactId>
        <groupId>com.phoegel</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>vistor</artifactId>

    <properties>
        <spring.version>5.1.15.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

</project>

2.简单的定义一个实体类：

public class Person {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.然后是 spring 配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:person.properties"/>

    <bean id="person" class="com.phoegel.visitor.analysis.Person" scope="prototype">
        <property name="name" value="${person.name}"/>
        <property name="age" value="${person.age}"/>
    </bean>
</beans>

4.这里使用占位符的方式初始化Person类实例，因此配置一个person.properties文件：

person.name=张三
person.age=18

5.然后简单的使用：

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person);
    }
}

6.使用结果：

Person{name='张三', age=18}

这里只是简单的输出了初始化对象的信息。重点是想要说明的这里使用占位符${}的方式将配置文件person.properties的信息设置到对象字段里面，在 Spring 中是通过PropertySourcesPlaceholderConfigurer类中的processProperties()方法中完成的，而方法内部又调用了PlaceholderConfigurerSupport类中的doProcessProperties()方法，在doProcessProperties内部就使用到了BeanDefinitionVisitor类，这个类就代表了访问者类。通过追踪源码可以下面的关键代码：

protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
      StringValueResolver valueResolver) {

   // 通过 BeanDefinitionVisitor 类的 visitBeanDefinition() 方法来实现访问者模式的核心思想
   BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);

   String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
   for (String curName : beanNames) {
      if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {
         BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName);
         try {
            visitor.visitBeanDefinition(bd);
         }
         catch (Exception ex) {
            throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage(), ex);
         }
      }
   }
   beanFactoryToProcess.resolveAliases(valueResolver);
   beanFactoryToProcess.addEmbeddedValueResolver(valueResolver);
}

其中BeanDefinitionVisitor类的visitBeanDefinition()方法如下：

public void visitBeanDefinition(BeanDefinition beanDefinition) {
   visitParentName(beanDefinition);
   visitBeanClassName(beanDefinition);
   visitFactoryBeanName(beanDefinition);
   visitFactoryMethodName(beanDefinition);
   visitScope(beanDefinition);
   if (beanDefinition.hasPropertyValues()) {
      visitPropertyValues(beanDefinition.getPropertyValues());
   }
   if (beanDefinition.hasConstructorArgumentValues()) {
      ConstructorArgumentValues cas = beanDefinition.getConstructorArgumentValues();
      visitIndexedArgumentValues(cas.getIndexedArgumentValues());
      visitGenericArgumentValues(cas.getGenericArgumentValues());
   }
}

观察visitBeanDefinition()方法的方法签名，可以发现BeanDefinition是一个接口，也就是访问者模式中的抽象元素角色，而它的子类有RootBeanDefinition、ChildBeanDefinition和GenericBeanDefinition等等，这些可以理解为具体的元素角色。需要注意的是，这里的BeanDefinition明显是一个实现类，也就是说在 Spring 中并没有抽象出抽象访问者来对具体访问者类进行扩展，但是访问者模式的思想在上面几个类之间的运用得到了充分的体现。

总结

主要优点

• 增加新的访问操作很方便。使用访问者模式，增加新的访问操作就意味着增加一个新的具体访问者类，实现简单，无须修改源代码，符合“开闭原则”。
• 将有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个的元素类中。类的职责更加清晰，有利于对象结构中元素对象的复用，相同的对象结构可以供多个不同的访问者访问。
• 让用户能够在不修改现有元素类层次结构的情况下，定义作用于该层次结构的操作。

主要缺点

• 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”的要求。
• 破坏封装。访问者模式要求访问者对象访问并调用每一个元素对象的操作，这意味着元素对象有时候必须暴露一些自己的内部操作和内部状态，否则无法供访问者访问。

适用场景

• 一个对象结构包含多个类型的对象，希望对这些对象实施一些依赖其具体类型的操作。在访问者中针对每一种具体的类型都提供了一个访问操作，不同类型的对象可以有不同的访问操作。
• 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。访问者模式使得我们可以将相关的访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的访问操作分离。
• 对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。

参考资料

• 大话设计模式
• 设计模式Java版本-刘伟
• 设计模式深入浅出--24.访问者模式简单实例及其在JDK、Spring中的应用

本篇文章github代码地址：https://github.com/Phoegel/design-pattern/tree/main/visitor
转载请说明出处，本篇博客地址：https://www.cnblogs.com/phoegel/p/14278953.html