访问者模式

访问者模式

在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

访问者模式是一种将数据操作和数据结构分离的设计模式。

介绍 

意图：主要将数据结构与数据操作分离。

主要解决：稳定的数据结构和易变的操作耦合问题。

何时使用：需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。

如何解决：在被访问的类里面加一个对外提供接待访问者的接口。

关键代码：在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。

应用实例：您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。

优点： 

1. 扩展性好。能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。
2. 复用性好。可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度。
3. 灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构。
4. 符合单一职责原则。访问者模式把相关的行为封装在一起，构成一个访问者，使每一个访问者的功能都比较单一。

缺点： 1、具体元素对访问者公布细节，违反了迪米特原则。 2、具体元素变更比较困难。 3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。

使用场景： 1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。 2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。

注意事项：访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。

模式的结构

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

1. 抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。
2. 具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
3. 抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。
4. 具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作。
5. 对象结构（ObjectStructure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现。

实现

步骤 1

/*
抽象访问者
 */
public interface Visitor {
    void visits(ConcreteElementA element);
    void visits(ConcreteElementC element);
}

步骤 2

 

/*
抽象元素
 */
public interface Element {
    void accept(Visitor visitor);
}

步骤 3

 

/*
具体元素 A
 */
public class ConcreteElementA implements Element {
    public void accept(Visitor visitor)
    {

        visitor.visits(this);
    }
    public String OperationA()
    {

        return "具体元素A的操作";
    }
}

步骤 4

 

/*
具体元素 C
 */

public class ConcreteElementC  implements Element{
    public void accept(Visitor visitor)
    {

        visitor.visits(this);
    }
    public String OperationC()
    {

        return "具体元素C的操作";
    }
}

步骤5

 

/*
具体访问者A类
 */
public class ConcreteVisitorA implements Visitor {
    @Override
    public void visits(ConcreteElementA element) {
        System.out.println("具体访问者A访问-->"+element.OperationA());
    }

    @Override
    public void visits(ConcreteElementC element) {
        System.out.println("具体访问者A访问-->"+element.OperationC());
    }
}

步骤 6

 

/*
具体访问者C类
 */
public class ContcreteVisitorC implements Visitor {
    @Override
    public void visits(ConcreteElementA element) {
        System.out.println("访问者C访问-->"+element.OperationA());
    }

    @Override
    public void visits(ConcreteElementC element) {
        System.out.println("访问者C访问-->"+element.OperationC());
    }
}

步骤 7

 

import java.util.*;
/*
 结构对象
 */
public class ObjectStructure {
    private List<Element> list=new ArrayList<Element>();
    public void accept(Visitor visitor)
    {
        Iterator<Element> i=list.iterator();
        for(Element element:list)
        {
            element.accept(visitor);
        }
    }
    public void add(Element element)
    {
        list.add(element);
    }
    public void remove(Element element)
    {
        list.remove(element);
    }
}

步骤 8

 

/*
访问者模式（Visitor Pattern）
 */
public class VisitorPatternDescription {

    public static void main(String[] args)
    {
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.add(new ConcreteElementA());
        objectStructure.add(new ConcreteElementC());
        Visitor visitor=new ConcreteVisitorA();
        Visitor visitor2=new ContcreteVisitorC();
        objectStructure.accept(visitor);
        objectStructure.accept(visitor2);
    }
}

结果：

具体访问者A访问-->具体元素A的操作
具体访问者A访问-->具体元素C的操作
具体访问者C访问-->具体元素A的操作
具体访问者C访问-->具体元素C的操作