设计模式(二十四) 访问者模式

Visitor Pattern

1. 什么是访问者模式

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

如何为同一集合对象中的元素提供多种不同的操作方式？访问者模式就是一个值得考虑的解决方案，它可以在一定程度上解决上述问题（解决大部分问题）。访问者模式可以为为不同类型的元素提供多种访问操作方式，而且可以在不修改原有系统的情况下增加新的操作方式。

访问者模式包含访问者和被访问元素两个主要组成部分，这些被访问的元素通常具有不同的类型，且不同的访问者可以对它们进行不同的访问操作。访问者模式使得用户可以在不修改现有系统的情况下扩展系统的功能，为这些不同类型的元素增加新的操作。

当系统中存在一个较为复杂的对象结构，且不同访问者对其所采取的操作也不相同时，可以考虑使用访问者模式进行设计。

2. 访问者模式类角色解析

访问者模式结构图：

Vistor（抽象访问者）：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作。
ConcreteVisitor（具体访问者）：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。
Element（抽象元素）：抽象元素一般是抽象类或者接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。
ConcreteElement（具体元素）：具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。
ObjectStructure（对象结构）：对象结构是一个元素的集合，它用于存放元素对象，并且提供了遍历其内部元素的方法。它可以结合组合模式来实现，也可以是一个简单的集合对象，如一个List对象或一个Set对象。

访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。
访问者模式包括两个层次结构：

一个是访问者层次结构，提供了抽象访问者和具体访问者，
一个是元素层次结构，提供了抽象元素和具体元素。
相同的访问者可以以不同的方式访问不同的元素，相同的元素可以接受不同访问者以不同访问方式访问。
在访问者模式中，增加新的访问者无须修改原有系统，系统具有较好的可扩展性。

抽象访问者定义了访问元素对象的方法，通常为每一种类型的元素对象都提供一个访问方法，而具体访问者可以实现这些访问方法。
这些访问方法的命名一般有两种方式：一种是直接在方法名中标明待访问元素对象的具体类型，如visitElementA(ElementA elementA)，还有一种是统一取名为visit()，通过参数类型的不同来定义一系列重载的visit()方法。当然，如果所有的访问者对某一类型的元素的访问操作都相同，则可以将操作代码移到抽象访问者类中，其典型代码如下所示：

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

对于元素类而言，在其中一般都定义了一个accept()方法，用于接受访问者的访问

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

该方法传入了一个抽象访问者Visitor类型的参数，即针对抽象访问者进行编程，而不是具体访问者，在程序运行时再确定具体访问者的类型，并调用具体访问者对象的visit()方法实现对元素对象的操作。
在抽象元素类Element的子类中实现了accept()方法，用于接受访问者的访问，在具体元素类中还可以定义不同类型的元素所特有的业务方法，其典型代码如下所示：

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

对象结构是一个集合，它用于存储元素对象并接受访问者的访问，其典型代码如下所示：

class ObjectStructure{
    
    
	private ArrayList<Element> list = new ArrayList<Element>(); //定义一个集合用于存储元素对象
 
	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);
	}

3. 访问者模式优缺点

优点：

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

缺点：

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

适用场景：

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

4. 实操感想

访问者模式，拆分了两个层次去组织类，一个是访问者层次结构，一个是元素层次结构。
提供的操作就是：
相同的访问者可以访问不同的元素，所以就是说这些不同的元素肯定在一个集合里，该访问者去遍历访问，即是ObjectStructure类；
相同的元素可以被不同的访问者访问。实现中是元素方法参数中传入该访问者即可，即是Vistor类；

5. 代码示例

// 元素类
interface Employee {
    
    
    //接受一个抽象访问者访问
    void accept(Department handler); 
}

class FulltimeEmployee implements Employee {
    
    
    private String name;

    FulltimeEmployee(String name) {
    
    
        this.name = name;
    }

    @Override
    public void accept(Department handler) {
    
    
        //调用访问者的访问方法
        handler.visit(this);
    }
}

class ParttimeEmployee implements Employee {
    
    
    private String name;

    ParttimeEmployee(String name) {
    
    
        this.name = name;
    }

    @Override
    public void accept(Department handler) {
    
    
        //调用访问者的访问方法
        handler.visit(this);
    }
}

// 访问者类
abstract class Department {
    
    
    abstract void visit(FulltimeEmployee employee);
    abstract void visit(ParttimeEmployee employee);
}

// 财务部门访问者
class FADepartment extends Department {
    
    
    //实现财务部对全职员工的访问
    @Override
    public void visit(FulltimeEmployee employee) {
    
    
        System.out.println("财务部门访问全职员工的逻辑");
    }

    //实现财务部对兼职员工的访问
    @Override
    public void visit(ParttimeEmployee employee) {
    
    
        System.out.println("财务部门访问兼职员工的逻辑");
    }
}

// 元素集合类
class HRDepartment extends Department {
    
    
    //实现人力资源部对全职员工的访问
    @Override
    public void visit(FulltimeEmployee employee) {
    
    
        System.out.println("人力部门访问全职员工的逻辑");
    }

    //实现人力资源部对兼职员工的访问
    @Override
    public void visit(ParttimeEmployee employee) {
    
    
        System.out.println("人力部门访问兼职员工的逻辑");
    }
}

class EmployeeList {
    
    
    //定义一个集合用于存储员工对象
    private ArrayList<Employee> list = new ArrayList<Employee>();

    void addEmployee(Employee employee) {
    
    
        list.add(employee);
    }

    //访问者遍历访问元素
    void accept(Department handler) {
    
    
        for (Object obj : list) {
    
    
            ((Employee) obj).accept(handler);
        }
    }
}

    public static void main(String[] args) {
    
    
        EmployeeList list = new EmployeeList();
        Employee fte1, fte2, fte3, pte1, pte2;

        fte1 = new FulltimeEmployee("1");
        fte2 = new FulltimeEmployee("2");
        fte3 = new FulltimeEmployee("3");
        pte1 = new ParttimeEmployee("4");
        pte2 = new ParttimeEmployee("5");

        list.addEmployee(fte1);
        list.addEmployee(fte2);
        list.addEmployee(fte3);
        list.addEmployee(pte1);
        list.addEmployee(pte2);

        //  财务部门访问所有员工
        Department dep = new FADepartment();
        list.accept(dep);
    }