20【访问者设计模式】

---

二十、访问者设计模式

20.1 访问者设计模式简介

20.1.1 访问者设计模式概述

访问者设计模式（Visitor Pattern）：是一种将数据结构与数据操作分离的设计模式，该模式封装一些作用于操作其内部的数据的步骤，可以在不改变数据结构的前提下定义作用于这些元素的新操作；

生活中的访问者模式场景也非常多；

如：一个家庭中有非常多的成员，如孩子、父亲、母亲等；这些家庭成员都有非常多的一些属性/行为，作为访问者的我们（丈夫、妻子）都可以去对家庭成员的信息进行访问，但是不同的角色访问的感兴趣的内容是不一样的；例如丈夫关心孩子的兴趣爱好、平时的生活信息，关心父母的饮食、社会生活等；而妻子则关心孩子的身高体重、饮食爱好，关心父母的饮食习惯、起居生活等；

可见不同的访问者，对同一类事物所关注点是不一样的；下面我们将使用访问者设计模式来实现这一案例；

20.1.2 访问者设计模式的UML类图

访问者模式主要有5个角色：

• 1）抽象元素（Element）：定义了一个接受访问者的方法（accept），表示所有的元素都要可以被访问者访问。
• 2）具体元素（ConcreteElement）： 提供接受访问方法（accpet）的具体实现，通常情况下是使用访问者提供的访问该元素类的方法：visitor.visit(this)。
• 3）抽象访问者（Visitor）：定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素类个数（Element的实现类个数）是一样的，因为要保证访问者能够访问所有的元素。因此，访问者模式要求元素类的个数不能经常变动。
• 4）具体访问者（ConcreteVisitor）：提供访问者的具体实现。
• 5）对象结构（Object Structure）：维护元素集合，并提供方法接受访问者对这些元素操作。

20.2 访问者设计模式的实现

我们前面举了一个家庭的案例，在上述案例中；我们根据UML类图来找到对应的角色：

• 孩子、父母：属于具体元素，具备很多的属性和行为，就是访问者模式中提到的数据结构
• 丈夫、妻子：属于具体访问者，用于访问孩子、父母的属性和行为，就是访问者模式中提到的数据操作

接下来我们使用代码来实现刚刚描述的场景；

• 1）定义抽象元素：

package com.pattern.demo01;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author lscl
 * @version 1.0
 * @intro: 家人类,接受其他人的访问(抽象元素)
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class IFamily {
    private String name;
    private Integer age;
    // 基本信息
    public abstract void basic();

    // 饮食信息
    public abstract void diet();

    // 生活信息
    public abstract void live();

    public abstract void accept(IVisitor visitor);
}

• 2）定义具体元素（孩子）：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 孩子类(具体的元素)
 */
public class ChildFamily extends IFamily {

    public ChildFamily(String name, Integer age) {
        super(name, age);
    }

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

    // 基本信息
    public void basic() {
        System.out.println("【" + getName() + "】的身高:【170】");
        System.out.println("【" + getName() + "】的体重:【65KG】");
        System.out.println("-------------------");
    }

    // 饮食信息
    public void diet() {
        System.out.println("【" + getName() + "】喜欢吃红烧肉");
        System.out.println("【" + getName() + "】喜欢喝可乐");
        System.out.println("-------------------");
    }

    // 生活信息
    public void live() {
        System.out.println("【" + getName() + "】平时喜欢跟小红在一起玩");
        System.out.println("【" + getName() + "】晚上8.30喜欢看少儿频道");
        System.out.println("-------------------");
    }
}

• 3）定义具体元素（父母）：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 父母类(具体的元素)
 */
public class ParentFamily extends IFamily {

    public ParentFamily(String name, Integer age) {
        super(name, age);
    }


    // 基本信息
    public void basic() {
        System.out.println("【" + getName() + "】身高:【162】");
        System.out.println("【" + getName() + "】体重:【48kg】");
        System.out.println("-------------------");
    }

    // 饮食信息
    public void diet() {
        System.out.println("【" + getName() + "】喜欢吃青菜");
        System.out.println("【" + getName() + "】喜欢喝茶");
        System.out.println("-------------------");
    }

    // 生活信息
    public void live() {
        System.out.println("【" + getName() + "】平时喜欢跟隔壁老王下棋");
        System.out.println("【" + getName() + "】晚上7.30喜欢看新闻联播");
        System.out.println("-------------------");
    }

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

• 4）定义抽象访问者：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 抽象访问者
 */
public interface IVisitor {
    
    // 用于访问孩子的信息
    public void visit(ChildFamily childFamily);

    // 用于访问父母的信息
    public void visit(ParentFamily parentFamily);
}

• 5）定义具体访问者（丈夫）：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 爸爸访问者(具体访问者)
 */
public class FatherVisitor implements IVisitor {
    @Override
    public void visit(ChildFamily childFamily) {

        // 爸爸关心孩子的基本信息、生活等...
        childFamily.basic();
        childFamily.live();
    }

    @Override
    public void visit(ParentFamily parentFamily) {

        // 爸爸关心父母的基本信息、饮食、生活等
        parentFamily.basic();
        parentFamily.diet();
        parentFamily.live();
    }
}

• 6）定义具体访问者（妻子）：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 妈妈访问者(具体访问者)
 */
public class MotherVisitor implements IVisitor {
    @Override
    public void visit(ChildFamily childFamily) {

        // 妈妈关心孩子的基本信息、饮食等...
        childFamily.basic();
        childFamily.diet();
    }

    @Override
    public void visit(ParentFamily parentFamily) {

        // 妈妈关心父母的饮食、生活等
        parentFamily.diet();
        parentFamily.live();
    }
}

• 7）结构对象：

package com.pattern.demo01;

import java.util.ArrayList;
import java.util.List;

/**
 * @author lscl
 * @version 1.0
 * @intro: 结构对象: 提供方法接受访问者对该集合所有元素的操作
 */
public class ObjectStructure {

    private List<IFamily> families=new ArrayList<>();

    // 添加元素
    public void addElement(IFamily family){
        families.add(family);
    }

    // 移除元素
    public void removeElement(IFamily family){
        families.remove(family);
    }

    // 访问元素,不同的访问者访问到的内容是不一样的
    public void accept(IVisitor visitor){
        for (IFamily family : families) {
            family.accept(visitor);
        }
    }
}

• 8）测试类：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        ObjectStructure structure=new ObjectStructure();
        structure.addElement(new ChildFamily("小刚",17));
        structure.addElement(new ParentFamily("爸",56));
        structure.addElement(new ChildFamily("妈",53));

        System.out.println("**************丈夫关心孩子们和父母**************");
        structure.accept(new FatherVisitor());

        System.out.println("**************妻子关心孩子们和父母**************");
        structure.accept(new MotherVisitor());
    }
}

20.3 访问者设计模式的优缺点

• 优点：
  • 1）解耦了数据结构与数据操作，使得操作集合可以独立变化
  • 2）可以通过扩展访问者角色来实现对数据的不同操作，扩展性好
  • 3）各角色职责分离，符合单一职责原则
• 缺点：
  • 1）无法增加元素类：若系统数据结构对象易于发生变化，如经常有新的元素增加进来，则访问者必须增加对应元素的操作，违背了开闭原则；
  • 2）访问者模式为了实现不同的访问者访问不同的元素达到不同的效果，所以访问者依赖的是具体元素类型，而不是抽象类，违背了依赖倒置原则；