设计模式——访问者模式

访问者模式

1、测评系统需求

1）将观众分为男人和女人，对歌手进行测评，当看完某个歌手表演后，得到他们对该歌手不同的评价（评价有不同的种类，比如成功、失败等）

2）传统方案

Person为父类，Man和Woman继承Person类。对Man和Woman分别进行判断

3）传统方案问题分析

如果系统比较小，还是ok的，但是考虑系统增加越来越多新的功能时，对代码改动较大，违反了ocp原则。

扩展性不好，比如增加了新的人员类型，或者管理方法，都不好做。

2、访问者模式的基本介绍

1）访问者模式（Visitor Pattern），封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。

2）主要将数据结构与数据操作分离，解决数据结构和操作耦合性问题。

3）访问者模式的基本工作原理是：在被访问的类里面加一个对外提供接待访问者的接口。

4）访问者模式主要应用场景是：需要对一个对象结构中的对象进行很多不同操作（这些操作彼此没有关联），同时需要避免让这些操作“污染”这些对象的类，可以选用访问者模式解决。

3、结构

1）抽象访问者（Visitor）角色：定义了对每一个元素（Element）访问的行为，为该对象结构中的ConcreteElement的每一个类声明一个visit操作。它的参数就是可以访问的元素，它的方法个数理论上来讲与元素类个数（Element的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变。

2）具体访问者（ConcreteVisitor）角色：给出对每一个元素类访问时所产生的具体行为。实现每个有Visitor声明的操作，是每个操作实现的部分。

3）抽象元素（Element）角色：定义了一个接受访问者的方法（accept），其意义是指，每一个元素都要可以被访问者访问。

4）具体元素（ConcreteElement）角色：提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。ConcreteElement为具体元素，实现了accept方法。

5）对象结构（Object Structure）角色：定义当中所提到的对象结构，对象结构是一个抽象表述，具体点可以理解为一个具有容器性质或者复合对象特性的类，它会含有一组元素（Element），并且可以迭代这些元素，供访问者访问。ObjectStructure能枚举它的元素，可以提供一个高层的接口，用来允许访问者访问元素。

4、应用实例代码实现

【1】男女评价案例

public abstract class Person {
    // 提供一个方法，让访问者可以访问
    public abstract void accept(Action action);
}

public class Man extends Person {
    public void accept(Action action) {
        action.getManResult(this);
    }
}

// 1. 这里我们使用到了双分派，即首先在客户端程序中，将具体状态作为参数传递Woman中（第一次分派）
// 2. 然后Woman类调用作为参数的具体方法中方法getWomanResult，同时将自己（this）作为参数传入，完成第二次的分派。
public class Woman extends Person {
    public void accept(Action action) {
        action.getWomanResult(this);
    }
}

public abstract class Action {
    // 得到男性的测评
    public abstract void getManResult(Man man);
    
    // 得到女性的测评
    public abstract void getWomanResult(Woman woman);
}

public class Success extends Action {
    @Override
    public void getManResult(Man man) {
        System.out.println(" 男人给到评价该歌手很成功！");
    }
    
    @Override
    public void getWomanResult(Woman woman) {
        System.out.println(" 女人给的评价该歌手很成功！");
    }
}

public class Fali extends Action {
    @Override
    public void getManResult(Man man) {
        System.out.println(" 男人给到评价该歌手很失败！");
    }
    
    @Override
    public void getWomanResult(Woman woman) {
        System.out.println(" 女人给的评价该歌手很失败！");
    }
}

public class ObjectStructure {
    // 维护了一个集合
    private List<Person> persons = new LinkedList<>();
    
    // 增加到list
    public void attach(Person p) {
        persons.add(p);
    }
    
    // 移除
    public void detach(Person p) {
        persons.remove(p);
    }
    
    // 显示测评情况
    public void display(Action action) {
        for(Person p: persons) {
            p.accept(action);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建ObjectStructure
        ObjectStructure objectStructure = new ObjectStructure();
        
        objectStructure.attach(new Man());
        objectStructure.attach(new Woman());
        
        // 成功
        Success success = new Success();
        objectStructure.display(success);
        
        // 失败
        Fail fail = new Fail();
        objectStructure.diaplay(fail);
    }
}

【2】给宠物喂食案例

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

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

类图如下：

// 抽象访问者角色
public interface Person {
    // 喂食宠物猫
    void feed(Cat cat);
    
    // 喂食宠物狗
    void feed(Dog dog);
}

// 具体访问者角色（自己）
public class Owner implements Person {
    public void feed(Cat cat) {
        System.out.println("主人喂食猫");
    }
    
    public void feed(Dog dog) {
        System.out.println("主人喂食狗");
    }
}

// 具体访问者角色（其他人）
public class SomeOne implements Person {
    public void feed(Cat cat) {
        System.out.println("其他人喂食猫");
    }
    
    public void feed(Dog dog) {
        System.out.println("其他人喂食狗");
    }
}

// 抽象元素角色类
public interface Animal {
    // 接受访问者访问的功能
    void accept(Person person);
}

// 具体元素角色类（宠物猫）
public class Cat implements Animal {
    // 访问者给宠物猫喂食
    public void accept(Person person) {
        person.feed(this);
        System.out.println("好好吃，喵喵喵。。。");
    }
}

// 具体元素角色类（宠物狗）
public class Dog implements Animal {
    // 访问者给宠物狗喂食
    public void accept(Person person) {
        person.feed(this);
        System.out.println("好好吃，汪汪汪。。。");
    }
}

// 对象结构类
public class Home {
    // 声明集合对象，用来存储元素对象
    private List<Animal> nodeList = new ArrayList<Animal>();
    
    // 添加元素功能
    public void add(Animal animal) {
        nodeList.add(animal);
    }
    
    public void action(Person person) {
        // 遍历集合，获取每一个元素，让访问者访问每一个元素
        for(Animal animal : nodeList) {
            animal.accept(person);
        }
    }
}

public class Client {
    public static void main() {
        // 创建Home对象
        Home home = new Home();
        
        // 添加元素到Home对象中
        home.add(new Dog());
        home.add(new Cat());
        
        // 创建主人对象
        Owner owner = new Owner();
        // 让主人喂食所有的宠物
        home.action(owner);
    }
}

5、访问者模式的注意事项

【优点】

1）扩展性好

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

访问者模式符合单一职责原则、让程序具有优秀的扩展性、灵活性非常高。

2）复用性好

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

3）分离无关行为

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

访问者模式可以对功能进行统一，可以做报表、UI、拦截器与过滤器，适用于数据结构相对稳定的系统。

【缺点】

1）对象结构变化很困难

具体元素对访问者公布细节，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的，这样造成了具体元素变更比较困难。

在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，者违背了”开闭原则”。

2）违背了依赖倒转原则。访问者依赖的是具体元素，而不是抽象元素。

【使用场景】

1）对象结构相对稳定，又有经常变化的功能需求，那么访问者模式就是比较合适的。

2）对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。

6、扩展

【1】分派

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

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

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

【2】双分派

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

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

public class Dog extends Animal {
    public void accept(Execute exe) {
        exe.execute(this);
    }
}

public class Cat extends Animal {
    public void accept(Execute exe) {
        exe.execute(this);
    }
}

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");
    }
}

public class Client {
    public static void main(String[] args) {
        Animal a = new Animal();
        Animal d = new Dog();
        Animal c = new Cat();
        
        Execute exe = new Execute();
        a.accept(exe);
        d.accept(exe);
        c.accept(exe);
    }
}

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

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