设计模式 ~ 行为型模式 ~ 访问者模式 ~ Visitor Pattern。

lyfGeek

已于 2023-02-24 19:45:29 修改

阅读量154

点赞数 1

分类专栏：设计模式。文章标签：访问者模式设计模式行为型模式

于 2020-12-21 16:57:58 首次发布

本文链接：https://blog.csdn.net/lyfGeek/article/details/111478676

版权

设计模式。专栏收录该内容

24 篇文章 0 订阅

订阅专栏

设计模式 ~ 行为型模式 ~ 访问者模式 ~ Visitor Pattern。

文章目录

- 设计模式 ~ 行为型模式 ~ 访问者模式 ~ Visitor Pattern。

概述。

定义。

封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。

结构。

访问者模式包含以下主要角色。

抽象访问者（Visitor）角色。
定义了对每一个元素（Element）访问的行为，ta 的参数就是可以访问的元素，ta 的方法个数理论上来讲与元素类个数（Element 的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变。
具体访问者（Concrete Visitor）角色。
给出对每一个元素类访问时所产生的具体行为。
抽象元素（Element）角色。
定义了一个接受访问者的方法（accept），其意义是指，每一个元素都要可以被访问者访问。
具体元素（Concrete Element）角色。
提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。
对象结构（Object Structure）角色。
定义当中所提到的对象结构，对象结构是一个抽象表述，具体点可以理解为一个具有容器性质或者复合对象特性的类，ta 会含有一组元素（Element），并且可以迭代这些元素，供访问者访问。

案例实现。

【eg.】给宠物喂食。

现在养宠物的人特别多，我们就以这个为例，当然宠物还分为狗，猫等，要给宠物喂食的话，主人可以喂，其他人也可以喂食。

访问者角色：给宠物喂食的人。
具体访问者角色：主人、其他人。
抽象元素角色：动物抽象类。
具体元素角色：宠物狗、宠物猫。
结构对象角色：主人家。

类图如下。

在这里插入图片描述
代码如下。

创建抽象访问者接口。

package com.geek.visitor.pattern;

/**
 * 抽象访问者角色接口。
 *
 * @author geek
 */
public interface IPerson {

    /**
     * 喂猫。
     *
     * @param cat
     */
    void feed(Cat cat);

    /**
     * 喂狗。
     *
     * @param dog
     */
    void feed(Dog dog);

}

创建不同的具体访问者角色（主人和其他人），都需要实现 Person接口

package com.geek.visitor.pattern;

/**
 * 具体访问者角色类。
 *
 * @author geek
 */
public class Owner implements IPerson {

    @Override
    public void feed(Cat cat) {
        System.out.println("主人喂食猫。");
    }

    @Override
    public void feed(Dog dog) {
        System.out.println("主人喂食狗。");
    }

}

package com.geek.visitor.pattern;

/**
 * 具体访问者角色类。
 *
 * @author geek
 */
public class Someone implements IPerson {

    @Override
    public void feed(Cat cat) {
        System.out.println("其他人喂食猫。");
    }

    @Override
    public void feed(Dog dog) {
        System.out.println("其他人喂食狗。");
    }

}

定义抽象节点 ~ 宠物。

package com.geek.visitor.pattern;

/**
 * 抽象元素角色。
 *
 * @author geek
 */
public interface IAnimal {

    /**
     * 接受访问者的访问。
     *
     * @param person
     */
    void accept(IPerson person);

}

定义实现 IAnimal接口的具体节点（元素）。

package com.geek.visitor.pattern;

/**
 * 具体元素角色类。
 *
 * @author geek
 */
public class Dog implements IAnimal {

    @Override
    public void accept(IPerson person) {
        person.feed(this);
        System.out.println("好好吃，汪汪汪！！！");
    }

}

package com.geek.visitor.pattern;

/**
 * 具体元素角色类。
 *
 * @author geek
 */
public class Cat implements IAnimal {

    /**
     * 接受访问者的访问。
     *
     * @param person
     */
    @Override
    public void accept(IPerson person) {
        person.feed(this);
        System.out.println("好好吃，喵喵喵！！！");
    }

}

定义对象结构，此案例中就是主人的家。

package com.geek.visitor.pattern;

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

/**
 * 对象结构类。
 *
 * @author geek
 */
public class Home {

    /**
     * 存储元素对象。
     */
    private final List<IAnimal> animalList = new ArrayList<IAnimal>();

    public void action(IPerson person) {
        for (IAnimal animal : this.animalList) {
            animal.accept(person);
        }
    }

    /**
     * 添加操作。
     *
     * @param animal
     */
    public void add(IAnimal animal) {
        this.animalList.add(animal);
    }

}

测试类

package com.geek.visitor.pattern;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        Home home = new Home();
        home.add(new Dog());
        home.add(new Cat());

        Owner owner = new Owner();
        home.action(owner);

        Someone someone = new Someone();
        home.action(someone);
    }

}

/*
Connected to the target VM, address: '127.0.0.1:50091', transport: 'socket'
主人喂食狗。
好好吃，汪汪汪！！！
主人喂食猫。
好好吃，喵喵喵！！！
其他人喂食狗。
好好吃，汪汪汪！！！
其他人喂食猫。
好好吃，喵喵喵！！！
Disconnected from the target VM, address: '127.0.0.1:50091', transport: 'socket'

Process finished with exit code 0
 */

优缺点。

优点。

扩展性好。
在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。

复用性好。
通过访问者来定义整个对象结构通用的功能，从而提高复用程度。

分离无关行为。
通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每一个访问者的功能都比较单一。

缺点。

对象结构变化很困难。
在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。
违反了依赖倒置原则。
访问者模式依赖了具体类，而没有依赖抽象类。

使用场景。

对象结构相对稳定，但其操作算法经常变化的程序。
对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。

扩展。

访问者模式用到了一种双分派的技术。

分派。

变量被声明时的类型叫做变量的静态类型，有些人又把静态类型叫做明显类型；而变量所引用的对象的真实类型又叫做变量的实际类型。比如 Map map = new HashMap() ，map 变量的静态类型是 Map ，实际类型是 HashMap 。根据对象的类型而对方法进行的选择，就是分派（Dispatch)，分派（Dispatch）又分为两种，即静态分派和动态分派。

静态分派（Static Dispatch） 发生在编译时期，分派根据静态类型信息发生。静态分派对于我们来说并不陌生，方法重载就是静态分派。

动态分派（Dynamic Dispatch） 发生在运行时期，动态分派动态地置换掉某个方法。Java 通过方法的重写支持动态分派。

动态分派。

通过方法的重写支持动态分派。

package com.geek.visitor.pattern.dispatcher.dynamic;

/**
 * @author geek
 */
public class Animal {

    public void execute() {
        System.out.println("Animal");
    }

}

package com.geek.visitor.pattern.dispatcher.dynamic;

/**
 * @author geek
 */
public class Dog extends Animal {

    @Override
    public void execute() {
        System.out.println("dog");
    }

}

package com.geek.visitor.pattern.dispatcher.dynamic;

/**
 * @author geek
 */
public class Cat extends Animal {

    @Override
    public void execute() {
        System.out.println("cat");
    }

}

package com.geek.visitor.pattern.dispatcher.dynamic;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        Animal a = new Dog();
        a.execute();

        Animal a1 = new Cat();
        a1.execute();
    }

}

/*
Connected to the target VM, address: '127.0.0.1:50769', transport: 'socket'
dog
cat
Disconnected from the target VM, address: '127.0.0.1:50769', transport: 'socket'

Process finished with exit code 0
 */

上面代码的结果大家应该直接可以说出来，这不就是多态吗！运行执行的是子类中的方法。

Java 编译器在编译时期并不总是知道哪些代码会被执行，因为编译器仅仅知道对象的静态类型，而不知道对象的真实类型；而方法的调用则是根据对象的真实类型，而不是静态类型。

静态分派。

通过方法重载支持静态分派。

package com.geek.visitor.pattern.dispatcher.static1;

/**
 * @author geek
 */
public class Animal {
}

package com.geek.visitor.pattern.dispatcher.static1;

/**
 * @author geek
 */
public class Dog extends Animal {
}

package com.geek.visitor.pattern.dispatcher.static1;

/**
 * @author geek
 */
public class Cat extends Animal {
}

package com.geek.visitor.pattern.dispatcher.static1;

/**
 * @author geek
 */
public class Execute {

    public void execute(Animal a) {
        System.out.println("Animal");
    }

    public void execute(Dog d) {
        System.out.println("dog");
    }

    public void execute(Cat c) {
        System.out.println("cat");
    }

}

package com.geek.visitor.pattern.dispatcher.static1;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        Animal a = new Animal();
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        Execute execute = new Execute();
        execute.execute(a);
        execute.execute(a1);
        execute.execute(a2);
    }

}

/*
Connected to the target VM, address: '127.0.0.1:56868', transport: 'socket'
Animal
Animal
Animal
Disconnected from the target VM, address: '127.0.0.1:56868', transport: 'socket'

Process finished with exit code 0

 */

这个结果可能出乎一些人的意料了，为什么呢？

重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了。

双分派。

所谓双分派技术就是在选择一个方法的时候，不仅仅要根据消息接收者（receiver）的运行时区别，还要根据参数的运行时区别。

package com.geek.visitor.pattern.dispatcher.double1;

/**
 * @author geek
 */
public class Animal {

    public void accept(Execute exe) {
        exe.execute(this);
    }

}

package com.geek.visitor.pattern.dispatcher.double1;

/**
 * @author geek
 */
public class Dog extends Animal {

    public void accept(Execute execute) {
        execute.execute(this);
    }

}

package com.geek.visitor.pattern.dispatcher.double1;

/**
 * @author geek
 */
public class Cat extends Animal {

    public void accept(Execute exe) {
        exe.execute(this);
    }

}

package com.geek.visitor.pattern.dispatcher.double1;

/**
 * @author geek
 */
public class Execute {

    public void execute(Animal animal) {
        System.out.println("Animal");
    }

    public void execute(Dog dog) {
        System.out.println("dog");
    }

    public void execute(Cat cat) {
        System.out.println("cat");
    }

}

package com.geek.visitor.pattern.dispatcher.double1;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        Animal a = new Animal();
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        Execute execute = new Execute();
        a.accept(execute);
        a1.accept(execute);
        a2.accept(execute);
    }

}

/*
Connected to the target VM, address: '127.0.0.1:51069', transport: 'socket'
Animal
dog
cat
Disconnected from the target VM, address: '127.0.0.1:51069', transport: 'socket'

Process finished with exit code 0

 */

在上面代码中，客户端将 Execute 对象作为参数传递给 Animal 类型的变量调用的方法，这里完成第一次分派，这里是方法重写，所以是动态分派，也就是执行实际类型中的方法，同时也将自己 this 作为参数传递进去，这里就完成了第二次分派，这里的 Execute 类中有多个重载的方法，而传递进行的是 this，就是具体的实际类型的对象。

说到这里，我们已经明白双分派是怎么回事了，但是它有什么效果呢？就是可以实现方法的动态绑定，我们可以对上面的程序进行修改。

双分派实现动态绑定的本质，就是在重载方法委派的前面加上了继承体系中覆盖的环节，由于覆盖是动态的，所以重载就是动态的了。