设计模式之访问者模式

定义

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

通用类图

具体实现

访问者模式主要是封装了对某种数据结构的操作，在不改变数据结构的前提下，通过不同的访问者来展示或设置数据结构中的元素。其主要有几个角色：抽象访问者（Visitor）、具体访问者（ConcreteVisitor）、抽象元素（Element）、具体元素（ConcreteElement）、结构对象（ObjectStruture）。下面就看看具体是怎样实现的。

抽象访问者主要是声明访问者可以访问哪些元素，也就是定义访问元素方法。

package com.yrs.visitor;

/**
 * @Author: yangrusheng
 * @Description: 抽象访问者
 * @Date: Created in 16:03 2020/7/5
 * @Modified By:
 */
public interface IVisitor {

    /**
     * 访问对象
     * @param elementA
     */
    public void visit(ConcreteElementA elementA);

    /**
     * 访问对象
     * @param elementB
     */
    public void visit(ConcreteElementB elementB);
}

具体访问者是访问元素的具体实现，主要是得到被访问元素后要进行什么操作。

package com.yrs.visitor;

/**
 * @Author: yangrusheng
 * @Description: 具体访问者实现类
 * @Date: Created in 16:30 2020/7/5
 * @Modified By:
 */
public class Visitor implements IVisitor {

    @Override
    public void visit(ConcreteElementA elementA) {
        elementA.doSomething();
        elementA.specialA();
    }

    @Override
    public void visit(ConcreteElementB elementB) {
        elementB.doSomething();
        elementB.specialB();
    }
}

抽象元素，主要定义了接收访问者方法：

package com.yrs.visitor;

/**
 * @Author: yangrusheng
 * @Description: 抽象元素
 * @Date: Created in 16:00 2020/7/5
 * @Modified By:
 */
public abstract class Element {

    /**
     * 定义业务逻辑
     */
    public abstract void doSomething();

    /**
     * 接受访问者访问
     * @param visitor
     */
    public abstract void accept(IVisitor visitor);

}

具体元素：

package com.yrs.visitor;

/**
 * @Author: yangrusheng
 * @Description: 具体元素实现类
 * @Date: Created in 16:05 2020/7/5
 * @Modified By:
 */
public class ConcreteElementA extends Element {

    /**
     * 具体元素特有的方法
     */
    public void specialA() {
        System.out.println("ConcreteElementA special method");
    }

    @Override
    public void doSomething() {
        // 具体元素的业务处理
        System.out.println("ConcreteElementA doSomeThing");
    }

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

构造对象主要是元素的生产者：

package com.yrs.visitor;

import java.util.Random;

/**
 * @Author: yangrusheng
 * @Description: 结构对象
 * @Date: Created in 16:41 2020/7/5
 * @Modified By:
 */
public class ObjectStructure {

    /**
     * 元素对象创建
     * @return
     */
    public static Element createElement() {
        Random random = new Random();
        if (random.nextInt(80) > 40) {
            return new ConcreteElementA();
        } else {
            return new ConcreteElementB();
        }
    }

}

场景类：

package com.yrs.visitor;

/**
 * @Author: yangrusheng
 * @Description: 场景类
 * @Date: Created in 16:51 2020/7/5
 * @Modified By:
 */
public class Client {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            // 获取元素
            Element element = ObjectStructure.createElement();
            // 接受访问者访问
            element.accept(new Visitor());
        }
    }
}

源代码地址：https://github.com/ByrsH/Design-Patterns/tree/master/Design%20Patterns/src/main/java/com/yrs/visitor

访问者模式应用

访问者模式优点

• 符合单一职责原则。元素角色的两个具体实现类负责数据的加载，而 Visitor 具体实现类负责报表的展现，职责明确划分，各自变化。
• 优秀的扩展性。
• 灵活性非常高。

访问者模式缺点

• 具体元素对访问者公布细节。也就是说访问者关注了其他类的内部细节，不符合迪米特法则。
• 具体元素角色变更比较困难。
• 违背了依赖倒置原则。访问者依赖的是具体元素，而不是抽象元素或接口，破坏了依赖倒置原则。

应用场景

• 一个对象结构包含很多类对象，它们有不同的接口，想要对这些对象实施一些依赖于其具体类的操作，也就是迭代器模式不能胜任的场景。
• 需要对一个对象结构中的对象进行很多不同且不相关的操作，又不想这些操作“污染”对象的类。

参考

• 《设计模式之禅-第2版》