访问者模式

一、概述

访问者模式的动机时以不同方式操作复杂对象结构。该模式可以为不同类型的元素提供多种访问操作方式，而且可以在不修改原有系统的情况下增加新的操作方式。

在使用访问者模式时，被访问元素通常不是单独存在的，它们存储在一个集合中，这个集合被称为“对象结构”，访问者通过遍历对象结构实现对其中存储的元素的逐个操作。

访问者模式的定义为：提供一个作用于某对象结构中的各元素的操作表示，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。

访问者模式的结构图为：

二、示例代码

访问者模式主要包括抽象访问者类(Visitor)、具体访问者类(ConcreteVIsitor)、抽象元素类(Element)、具体元素类(ConcreteElement)以及对象结构类(ObjectStructure)。

抽象访问者类(Visitor)定义了访问元素对象的方法，其典型代码为：

public abstract class Visitor {
  public abstract void visit(ConcreteElementA elementA);
  public abstract void visit(ConcreteElementB elementB);
  public void visit(ConcreteElementC elementC) {
    //元素ConcreteElementC操作代码
  }
}

具体访问者类(ConcreteVisitor)实现抽象的访问方法，其典型代码为：

public class ConcreteVisitor extends Visitor {
  public void visit(ConcreteElementA elementA) {
    //元素ConcreteElementA操作代码
  }
  public void visit(ConcreteElementB elementB) {
    //元素ConcreteElementB操作代码
  }
}

对于元素类(Element)，其中定义一个accept()方法用于接受访问者的访问，其典型代码为：

public interface Element {
  void accept(Visitor visitor);
}

具体元素类(ConcreteElementA)典型代码为：

public class ConcreteElementA implements Element {
  public void accept(Visitor visitor) {
    visitor.visit(this);
  }
  public void operationA() {
    //业务方法
  }
}

对象结构类(ObjectStructure)是一个集合，用于存储元素对象并接受访问者的访问，典型代码为：

public class ObjectStructure {
  private ArrayList<Element> list = new ArrayList<>();
  
  public void accept(Visitor visitor) {
    Iterator i = list.iterator();
    while(i.hasNext()) {
      ((Element)i.next()).accept(visitor);
    }
  }
  
  public void addElement(Element element) {
    list.add(element);
  }
  
  public void removeElement(Element element) {
    list.remove(element);
  }
}

三、demo

在超市里有顾客和收银员，同时有书、苹果等商品。顾客可以选择买书或者买苹果，收银员在结账时，如果是书则直接计算价格，如果是苹果要先称重再计算价格。

抽象访问者类(Visitor)代码设计如下：

public abstract class Visitor {

    protected String name;

    public void setName(String name) {
        this.name = name;
    }

    public abstract void visit(Apple apple);

    public abstract void visit(Book book);

}

具体访问者类(ConcreteVisitor)代码设计如下：

public class Customer extends Visitor{
    @Override
    public void visit(Apple apple) {
        System.out.println("顾客" + name + "选苹果");
    }

    @Override
    public void visit(Book book) {
        System.out.println("顾客" + name + "选书");
    }
}

public class Saler extends Visitor{
    @Override
    public void visit(Apple apple) {
        System.out.println("收银员" + name + "给苹果过秤，然后计算价格");
    }

    @Override
    public void visit(Book book) {
        System.out.println("收银员" + name + "直接计算价格");
    }
}

元素类(Element)代码设计如下：

public interface Product {

    void accept(Visitor visitor);

}

具体元素类(ConcreteElement)代码设计如下：

public class Book implements Product{

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

public class Apple implements Product{
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

对象结构类(ObjectStructure)代码设计如下：

public class BuyBasket {

    private ArrayList<Product> list = new ArrayList<>();

    public void accept(Visitor visitor) {
        Iterator i = list.iterator();
        while (i.hasNext()) {
            ((Product)i.next()).accept(visitor);
        }
    }

    public void addProduct(Product product) {
        list.add(product);
    }

    public void removeProduct(Product product) {
        list.remove(product);
    }

}

客户端调用代码如下：

public static void main(String args[]) {
  Product p1 = new Book();
  Product p2 = new Book();
  Product p3 = new Apple();

  Visitor visitor1, visitor2;
  BuyBasket buyBasket = new BuyBasket();

  buyBasket.addProduct(p1);
  buyBasket.addProduct(p2);
  buyBasket.addProduct(p3);

  visitor1 = new Customer();
  visitor1.setName("张三");
  buyBasket.accept(visitor1);

  visitor2 = new Saler();
  visitor2.setName("李四");
  buyBasket.accept(visitor2);
}

代码运行结果如下：

四、总结

1. 优点

• 增加新的访问操作很方便。使用访问者模式，增加新的访问操作就意味着增加一个新的具体访问者类，实现简单，无须修改源代码，符合“开闭原则”。
• 将有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个的元素类中。类的职责更加清晰，有利于对象结构中元素对象的复用，相同的对象结构可以供多个不同的访问者访问。
• 让用户能够在不修改现有元素类层次结构的情况下，定义作用于该层次结构的操作。

2. 缺点

• 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”的要求。
• 破坏封装。访问者模式要求访问者对象访问并调用每一个元素对象的操作，这意味着元素对象有时候必须暴露一些自己的内部操作和内部状态，否则无法供访问者访问。

3. 适用场景

• 一个对象结构包含多个类型的对象，希望对这些对象实施一些依赖其具体类型的操作。在访问者中针对每一种具体的类型都提供了一个访问操作，不同类型的对象可以有不同的访问操作。
• 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。访问者模式使得我们可以将相关的访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的访问操作分离。
• 对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。

赏

谢谢你请我吃糖果

微信