设计模式 _第十三招式_访问者模式

左手的ㄟ右手 2024-04-19 06:03 71阅读 0赞

## 一、定义 ##

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

## 二、代码演示 ##

2.1 通用类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]  
2.2 角色说明

*  Visitor(抽象访问者)  
    抽象类或者接口，声明访问者哪些可以访问哪些元素，具体到程序中就是visit方法的参数定义哪些对象是是可以被访问的。
 *  ConcreteVisitor(具体访问者)  
    它影响访问者访问到一个对象以后该干什么，要做什么事情。
 *  Elemet(抽象元素)  
    接口或抽象类，声明接受那一类访问者访问，程序上是通过accept方法参数来定义的。  
    \-ConcreteElement(具体元素)  
    实现accept方法，通常是visitor.visit(this),基本上都形成了一种模式。  
    \-ObjectStruture(结构对象)  
    元素产生者，一般容纳多个不同类、不同接口的容器，如List、Set、Map等，在项目中很少出现抽象出这角色。

2.3 抽象元素  
抽象元素有两类方法：一是本身的业务逻辑，也就是元素作为一个业务处理单元必须完成的职责；另外一个是允许哪个访问者来访问。

package com.design.visitor.pattern;
    
    /**
     * @description 抽象元素
     * @date: 2019/9/14 23:07
     * @version: v 0.1
     */
    public abstract class Element {
        //定义业务逻辑
        public abstract void doSomething();
    
        //允许谁来访问
        public abstract void accept(IVisitor visitor);
    }

2.4 具体元素

package com.design.visitor.pattern;
    
    /**
     * @description 具体元素
     * @date: 2019/9/14 23:13
     * @version: v 0.1
     */
    public class ConcreteElement1 extends Element {
        //定义业务逻辑
        public void doSomething() {
            System.out.println(ConcreteElement1.class.getName() + ",TODO");
        }
    
        //允许谁来访问
        public void accept(IVisitor visitor) {
            visitor.visit(this);
        }
    }

package com.design.visitor.pattern;
    
    /**
     * @description 具体元素
     * @date: 2019/9/14 23:13
     * @version: v 0.1
     */
    public class ConcreteElement2 extends Element {
        //定义业务逻辑
        public void doSomething() {
            System.out.println(ConcreteElement2.class.getName() + ",TODO");
        }
    
        //允许谁来访问
        public void accept(IVisitor visitor) {
            visitor.visit(this);
        }
    }

2.5 抽象访问者  
抽象访问者一般有几个具体元素就有几个访问方法。

package com.design.visitor.pattern;
    
    /**
     * @description 抽象访问者
     * @date: 2019/9/14 23:09
     * @version: v 0.1
     */
    public interface IVisitor {
        //可以访问哪些对象
        public void  visit (ConcreteElement1 element1);
        public void  visit (ConcreteElement2 element2);
    }

2.6 具体访问者

package com.design.visitor.pattern;
    
    /**
     * @description 具体访问者
     * @date: 2019/9/14 23:18
     * @version: v 0.1
     */
    public class Visitor implements IVisitor {
        //访问元素element1
        public void visit(ConcreteElement1 element1) {
            element1.doSomething();
        }
        //访问元素element2
        public void visit(ConcreteElement2 element2) {
            element2.doSomething();
        }
    }

2.7 结构对象  
结构对象是产生出不同的元素对象，我们用工厂方法模式来模拟。

package com.design.visitor.pattern;
    
    import java.util.Random;
    
    /**
     * @description 机构对象
     * @date: 2019/9/14 23:33
     * @version: v 0.1
     */
    public class ObjectStruture {
        //对象生成器，这里通过一个工厂方法模拟
        public static Element createElement(){
            Random rand = new Random();
            if (rand.nextInt(100)<50){
                return new ConcreteElement1();
            }else {
                return new ConcreteElement2();
            }
        }
    }

2.8 场景类  
进入访问者角色后，我们对所有元素的访问就非常简单了。

/**
     * @description 场景类
     * @date: 2019/9/14 23:39
     * @version: v 0.1
     */
    public class Client {
        public static void main(String args[]) {
            for (int i = 0; i < 10; i++) {
                Element el = ObjectStruture.createElement();
                el.accept(new Visitor());
            }
        }
    }

2.9 演示结果  
通过增加访问者，只要是具体元素就非常容易访问，对元素的遍历就更加容易了，不用管他是什么对象，只要它在一个容器中，都可以通过访问者来访问，任务集中化。

com.design.visitor.pattern.ConcreteElement1,TODO
    com.design.visitor.pattern.ConcreteElement2,TODO
    com.design.visitor.pattern.ConcreteElement2,TODO
    com.design.visitor.pattern.ConcreteElement2,TODO
    com.design.visitor.pattern.ConcreteElement2,TODO
    com.design.visitor.pattern.ConcreteElement2,TODO
    com.design.visitor.pattern.ConcreteElement1,TODO
    com.design.visitor.pattern.ConcreteElement2,TODO
    com.design.visitor.pattern.ConcreteElement1,TODO
    com.design.visitor.pattern.ConcreteElement1,TODO

## 三、优点 ##

*  符合单一职责原则  
    具体元素角色也就是Element抽象类的两个子类负责数据的加载，而Visitor类负责报表的展示，两个不同的职责非常明确的分离开，各自演绎变化。
 *  优秀的扩展性  
    由于职责分明，继续增加数据操作非常快捷，如现在增加一份大老板的报表，这份报表的格式不一样，直接在Visitor中增加一个方法，传递数据后进行打印。
 *  灵活性非常高  
    例如，数据汇总， 我们现在要统计所有员工的工资， 用for循环比例一遍 ？然后用instanceof判断是员工还是经理 ？可以解决但不是好方法， 我们可以直接通过访问者模式实现，把数据给访问者， 让他帮这来统计。

## 四、缺点 ##

*  具体元素对访问者公布细节  
    访问者要访问一个类就必然要求这个类公布一些方法和数据，也就是说访问者关注了其它类的内部细节，这也是迪米特法则不建议的。
 *  具体元素变更困难  
    具体元素的增加、删除、修改比较困难，就上面的例子，你要是增加一个成员变量age，Visitor就需要修改，如果Visitor是多个就比较麻烦了。
 *  违背了依赖倒置原则  
    访问者，依赖具体的元素，而不是抽象元素，这破坏了依赖倒置的原则，特别是在面向对象编程中，抛弃了对象接口的依赖，而直接依赖了实现类，扩展比较困难。

## 五、应用场景 ##

*  一个对象结构包括多个类对象，它们有不同的接口，而你想依赖接口下具体实现类的操作，也就是迭代器模式无法胜任的场景。
 *  需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免这些操作问“污染”这些类。
 *  这种场景一定要考虑一下访问者模式：业务规则要求遍历多个不同的对象，这本身就是访问者模式的出发点，迭代器模式只能访问同类或同接口的数据，而访问者模式是迭代器模式的补充，可以遍历不同的对象，然后执行不同的操作。
 *  访问者模式还有一个用途，就是充当拦截器（Interceptor）角色。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/72753868fb4542588576837da9d93b46.png