设计模式---访问者模式（Visitor Pattern）

冷不防 2022-11-26 07:41 163阅读 0赞

**目录**

1、测评系统的需求

2、访问者模式基本介绍

3、访问者模式原理类图

4、访问者模式应用实例

5、注意事项和细节

--------------------

# 1、测评系统的需求 #

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

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

1.  访问者模式（Visitor Pattern）,封装一些作用于某些数据结构的各元素的操作，它可以在不改变数据结构的前提下，定义作用这些元素的新的操作。
2.  主要将数据结构与数据操作分离，对数据结构和数据操作进行解耦。
3.  访问者模式的基本工作原理：在被访问的类里面加一个对外提供接待访问者的接口
4.  访问者模式的主要应用场景是：需要对一个对象结构中的对象进行很多不同操作（这些操作彼此没有关联），同时需要避免让这些操作“污染”这些对象的类，可以选用访问者模式进行解决。

# 3、访问者模式原理类图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70][]

*  Visitor: 抽象访问者。为该对象结构中的ConcreteElement的每个类提供一个visit操作。
 *  ConcreteVisitor: 是一个具体的访问者，实现每个有Visitor声明的操作，是每个操作实现的部分。
 *  ObjectStructure: 能枚举它的元素，可以提供一个高层的接口，用来允许访问者访问元素。
 *  Element:定义个accept方法，接收一个访问者对象。
 *  ConscreteElement:具体的元素类，实现accept方法。

# 4、访问者模式应用实例 #

需求：如刚开始提到的男女对歌手进行测评的需求。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 1][]

package com.mayun.study.designpattern.visitor;
    
    /**
     * 访问者抽象类
     */
    public abstract class Action {
        //得到男性的测评结果
        public  abstract void getManResult(Man man);
    
        //得到女性的测评结果
        public  abstract void getWoManResult(Woman woman);
    }

package com.mayun.study.designpattern.visitor;
    
    /**
     * 访问者实现类
     */
    public class Success extends Action {
        @Override
        public void getManResult(Man man) {
            System.out.println("男人给的评价是成功");
        }
    
        @Override
        public void getWoManResult(Woman woman) {
            System.out.println("女人给的评价是成功");
        }
    }

package com.mayun.study.designpattern.visitor;
    
    /**
     * 具体访问者
     */
    public class Faile extends Action {
        @Override
        public void getManResult(Man man) {
            System.out.println("男人给的评价是失败");
        }
    
        @Override
        public void getWoManResult(Woman woman) {
            System.out.println("女人给的评价是失败");
        }
    }

package com.mayun.study.designpattern.visitor;
    
    /**
     * 元素抽象类
     */
    public abstract class Person {
        //提供一个方法，让访问者可以访问
        public abstract void accept(Action action);
    }

package com.mayun.study.designpattern.visitor;
    
    /**
     * 具体的元素
     */
    public class Man extends Person {
        @Override
        public void accept(Action action) {
            action.getManResult(this);
        }
    }

package com.mayun.study.designpattern.visitor;
    
    /**
     * 说明：
     * 这里我们使用到了双分派，即首先在客户端程序中，将具体的状态作为参数传递给了woman
     * 然后，Woman这个类调用作为参数的具体方法getWoManResult ,同时将自己作为参数传入，完成第二次分派。
     *
     */
    public class Woman extends Person {
        @Override
        public void accept(Action action) {
            action.getWoManResult(this);
        }
    }

package com.mayun.study.designpattern.visitor;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * 数据结构，管理了很多类，man ，woman
     */
    public class ObjectStructor {
        //维护了一个集合
        private List<Person> personList = new LinkedList<>();
    
        //增加到list中
        public void attach(Person person) {
            personList.add(person);
        }
    
        //移除
        public void detach(Person person) {
            personList.remove(person);
        }
    
        //显示测评结果
        public void display(Action action) {
            for (Person person : personList) {
                person.accept(action);
            }
        }
    }

package com.mayun.study.designpattern.visitor;
    
    /**
     * 访问者测试类
     */
    public class Client {
        public static void main(String[] args) {
    
            ObjectStructor objectStructor = new ObjectStructor();
    
            objectStructor.attach(new Man());
            objectStructor.attach(new Woman());
    
            //成功
            Success success = new Success();
            objectStructor.display(success);
            System.out.println("------------------------");
            //失败
            Faile faile = new Faile();
            objectStructor.display(faile);
    
        }
    }

应用案例小结：

*  上面提到了双分派，所谓双分派，是指不管类怎么变化，我们都能找到期望的方法运行。双分派意味着得到执行的操作取决于请求的种类和两个接收者的类型。
 *  以上述实例为例：假设我们要添加一个Wait状态类，考察Man和Woman类的反应，由于使用了双分派，只需增加一个Action子类即可在客户端调用，不需要改动任何其它类的代码。

package com.mayun.study.designpattern.visitor;
    /**
     * 具体访问者
     */
    public class Wait extends Action {
        @Override
        public void getManResult(Man man) {
            System.out.println("男人给的评价是待定");
        }
    
        @Override
        public void getWoManResult(Woman woman) {
            System.out.println("女人给的评价是待定");
        }
    }

# 5、注意事项和细节 #

优点：

*  访问者模式符合单一职责原则，让程序具有优秀的扩展性，灵活性非常高。
 *  访问者模式可以对功能进行统一，可以做报表、UI、拦截器与过滤器，适用于数据结构相对稳定的系统。

缺点：

*  具体元素对访问者公布细节，也就是说访问者关注了其它类内部的细节，这是迪米特法则不建议的，这样造成了具体元素变更比较困难。
 *  违背了依赖倒置原则。访问者依赖的是具体元素，而不是抽象类。

因此，如果一个系统有比较稳定的数据结构，又有经常变化的功能需求，那么访问者模式就是比较适合的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70]: /images/20221124/ebd20a5c04854241bacf364c13ae480a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 1]: /images/20221124/1e34ecc085fc49a4a398ae5e87c4de3d.png