25.访问者模式(行为型)

作者: 哈哈大圣 | 来源:发表于2019-09-18 20:35 被阅读0次

访问者模式(行为型)

一、相关概述

访问者模式是一种较为复杂的行为型设计模式，它包含访问者和被访问元素两个主要组成部分，这些被访问的元素通常具有不同的类型，且不同的访问者可以对它们进行不同的访问操作。例如处方单中的各种药品信息就是被访问的元素，而划价人员和药房工作人员就是访问者。访问者模式使得用户可以在不修改现有系统的情况下扩展系统的功能，为这些不同类型的元素增加新的操作。

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

1). 定义

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

访问者模式结构图.png

2). 相关角色

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

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

增加新的访问者满足“开闭原则”，增加新的元素不符合“开闭原则”,需要修改各个访问者！

3). 典型代码

抽象访问者

/**
 * 抽象访问者
 */
public abstract class Visitor {
    public abstract void visit(ConcreteElementA elementA);
    public abstract void visit(ConcreteElementB elementB);
    public void visit(ConcreteElementC elementC) {
        // 元素ConcreteElementC操作代码，公共操作的抽离
    }
}

抽象访问者定义了访问元素对象的方法，通常为每一种类型的元素对象都提供一个访问方法，而具体访问者可以实现这些访问方法。

具体访问者

/**
 * 具体访问者
 */
public class ConcreteVisitor extends Visitor {
    public void visit(ConcreteElementA elementA) {
        //元素ConcreteElementA操作代码
    }

    public void visit(ConcreteElementB elementB) {
        //元素ConcreteElementB操作代码
    }
}

抽象元素类

/**
 * 抽象元素类
 */
public interface Element {
    // 用于接受访问者的访问
    public void accept(Visitor visitor);
}

具体元素类

/**
 * 具体元素类
 */
public class ConcreteElementA implements Element {

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

    public void operationA() {
        //业务方法
    }
}

/**
 * 具体元素类
 */
public class ConcreteElementB implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    public void operationB() {
        //业务方法
    }
}

/**
 * 具体元素类
 */
public class ConcreteElementC implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    public void operationC() {
        //业务方法
    }
}

在具体元素类ConcreteElementA的accept()方法中，通过调用Visitor类的visit()方法实现对元素的访问，并以当前对象作为visit()方法的参数。其具体执行过程如下：

a -> 调用具体元素类的accept(Visitor visitor)方法，并将Visitor子类对象作为其参数；
b -> 在具体元素类accept(Visitor visitor)方法内部调用传入的Visitor对象的visit()方法，如visit(ConcreteElementA elementA)，将当前具体元素类对象(this)作为参数，如visitor.visit(this)；
c -> 执行Visitor对象的visit()方法，在其中还可以调用具体元素对象的业务方法。

这种调用机制也称为双重分派，正因为使用了双重分派机制，使得增加新的访问者无须修改现有类库代码，只需将新的访问者对象作为参数传入具体元素对象的accept()方法，程序运行时将回调在新增Visitor类中定义的visit()方法，从而增加新的元素访问方式。

在进行元素迭代遍历时，通过元素注入访问者从而进行访问，对于编程人员十分友好！

对象结构

/**
 * 元素对象数据结构集合
 */
public class ObjectStructure {
    //定义一个集合用于存储元素对象
    private List<Element> list = new ArrayList<Element>();

    public void accept(Visitor visitor) {
        Iterator<Element> element = list.iterator();

        //遍历访问集合中的每一个元素
        while(element.hasNext()) {
            element.next().accept(visitor);
        }
    }
    public void addElement(Element element) {
        list.add(element);
    }

    public void removeElement(Element element) {
        list.remove(element);
    }
}

二、案例分析

1). 案例需求描述

Sunny软件公司欲为某银行开发一套OA系统，在该OA系统中包含一个员工信息管理子系统，该银行员工包括正式员工和临时工，每周人力资源部和财务部等部门需要对员工数据进行汇总，汇总数据包括员工工作时间、员工工资等。该公司基本制度如下：

正式员工(Full time Employee)每周工作时间为40小时，不同级别、不同部门的员工每周基本工资不同；如果超过40小时，超出部分按照100元/小时作为加班费；如果少于40小时，所缺时间按照请假处理，请假所扣工资以80元/小时计算，直到基本工资扣除到零为止。除了记录实际工作时间外，人力资源部需记录加班时长或请假时长，作为员工平时表现的一项依据。
临时工(Part time Employee)每周工作时间不固定，基本工资按小时计算，不同岗位的临时工小时工资不同。人力资源部只需记录实际工作时间。人力资源部和财务部工作人员可以根据各自的需要对员工数据进行汇总处理，人力资源部负责汇总每周员工工作时间，而财务部负责计算每周员工工资。

2). 类图设计

访问者模式案例.png

3). 完整代码

抽象元素类

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

具体元素类

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 具体元素类：全职员工类
 */
@Data // lombok 插件以及依赖支持
@AllArgsConstructor // lombok 插件以及依赖支持
public class FullTimeEmployee implements Employee {
    private String name;
    private double weeklyWage;
    private int workTime;

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


/**
 * 具体元素类：兼职员工类
 */
@Data // lombok 插件以及依赖支持
@AllArgsConstructor // lombok 插件以及依赖支持
public class PartTimeEmployee implements Employee {
    private String name;
    private double hourWage;
    private int workTime;

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

抽象访问者

/**
 * 抽象访问者类：部门类
 */
public interface Department {
    // 声明一组重载访问方法，用于访问不同类型的具体元素
    public abstract void visit(FullTimeEmployee employee);
    public abstract void visit(PartTimeEmployee employee);
}

具体访问者

/**
 * 具体访问者：财务部类
 */
public class FADepartment implements Department {

    // 实现财务部对全职员工的访问
    @Override
    public void visit(FullTimeEmployee employee) {

        int workTime = employee.getWorkTime();
        double weekWage = employee.getWeeklyWage();

        if (workTime > 40) {
            weekWage = weekWage + (workTime - 40) * 100;
        } else if (workTime > 0) {
            weekWage = weekWage - (40 - workTime) * 80;
        } else {
            weekWage = 0;
        }

        System.out.println("正式员工" + employee.getName() + "实际工资为：" + weekWage);
    }

    // 实现财务部对兼职员工的访问
    @Override
    public void visit(PartTimeEmployee employee) {
        int workTime = employee.getWorkTime();
        double hourWage = employee.getHourWage();
        System.out.println("临时工" + employee.getName() + "实际工资为：" + (workTime * hourWage));
    }
}

/**
 * 具体访问者：人力资源部
 */
public class HRDepartment implements Department {

    // 实现财务部对全职员工的访问
    @Override
    public void visit(FullTimeEmployee employee) {
        int workTime = employee.getWorkTime();

        System.out.println("正式员工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");

        if(workTime > 40) {
            System.out.println("正式员工" + employee.getName() + "加班时间为：" + (workTime - 40) + "小时。");
        } else if(workTime < 40) {
            System.out.println("正式员工" + employee.getName() + "请假时间为：" + (40 - workTime) + "小时。");
        }
    }

    // 实现财务部对兼职员工的访问
    @Override
    public void visit(PartTimeEmployee employee) {
        int workTime = employee.getWorkTime();
        System.out.println("临时工" + employee.getName() + "实际工作时间为：" + workTime);
    }
}

对象结构

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 对象结构
 */
public class EmployeeList {
    // 存储员工对象的集合
    private List<Employee> employeeList = new ArrayList<>();

    public void addEmployee(Employee employee) {
        this.employeeList.add(employee);
    }

    // 遍历访问员工集合中的每一个员工
    public void accept(Department handler) {
        Iterator<Employee> iterator = employeeList.iterator();
        while (iterator.hasNext()) {
            iterator.next().accept(handler);
        }
    }

}

客户端测试


/**
 * @author Liucheng
 * @since 2019-09-16
 */
public class Client {

    public static void main(String[] args) {
        EmployeeList list = new EmployeeList();
        Employee fte1 = new FullTimeEmployee("张无忌",3200.00,45);
        Employee fte2 = new FullTimeEmployee("杨过",2000.00,40);
        Employee fte3 = new FullTimeEmployee("段誉",2400.00,38);
        Employee pte1 = new PartTimeEmployee("洪七公",80.00,20);
        Employee pte2 = new PartTimeEmployee("郭靖",60.00,18);

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

        Department fad = new FADepartment();
        HRDepartment hr = new HRDepartment();

        list.accept(fad);
        System.out.println("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
        list.accept(hr);
    }
}

三、访问者模式与组合模式联用

1). 联用结构分析

在访问者模式中，包含一个用于存储元素对象集合的对象结构，我们通常可以使用迭代器来遍历对象结构，同时具体元素之间可以存在整体与部分关系，有些元素作为容器对象，有些元素作为成员对象，可以使用组合模式来组织元素。

访问者模式和组合模式联用.png

需要注意的是，由于叶子元素的遍历操作已经在容器元素中完成，因此要防止单独将已增加到容器元素中的叶子元素再次加入对象结构中，对象结构中只保存容器元素和孤立的叶子元素。

2). 案例举例

以上述案例为背景进行改造，将员工分为几组

添加代码

/**
 * 组合模式：员工A组
 */
public class EmployeeGroupA implements Employee {

    private List<Employee> employees = new ArrayList<>();

    public void addMember(Employee employee) {
        this.employees.add(employee);
    }

    public void removeMember(Employee employee) {
        this.employees.remove(employee);
    }


    @Override
    public void accept(Department handler) {
        System.out.println("\n现在访问的是A组员工：~~~~~~~~~~~~~~~~~~~~~~");
        Iterator<Employee> employeeIterator = employees.iterator();
        while (employeeIterator.hasNext()) {
            employeeIterator.next().accept(handler);
        }
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
    }
}

测试程序

/**
 * @author Liucheng
 * @since 2019-09-16
 */
public class Client {

    public static void main(String[] args) {
        EmployeeList list = new EmployeeList();

        Employee fte1 = new FullTimeEmployee("张无忌",3200.00,45);
        Employee fte2 = new FullTimeEmployee("杨过",2000.00,40);
        Employee fte3 = new FullTimeEmployee("段誉",2400.00,38);

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

        EmployeeGroupA groupA = new EmployeeGroupA();
        Employee pte1 = new PartTimeEmployee("洪七公",80.00,20);
        Employee pte2 = new PartTimeEmployee("郭靖",60.00,18);
        groupA.addMember(pte1);
        groupA.addMember(pte2);

        list.addEmployee(groupA);

        Department fad = new FADepartment();
        HRDepartment hr = new HRDepartment();

        list.accept(fad);
        list.accept(hr);
    }
}

四、总结

由于访问者模式的使用条件较为苛刻，本身结构也较为复杂，因此在实际应用中使用频率不是特别高。当系统中存在一个较为复杂的对象结构，且不同访问者对其所采取的操作也不相同时，可以考虑使用访问者模式进行设计。在XML文档解析、编译器的设计、复杂集合对象的处理等领域访问者模式得到了一定的应用。

1). 优点

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

2). 缺点

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

3). 适用场景

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