【Java设计模式】Java设计模式之（十四）访问者模式（Visitor Pattern）

布满荆棘的人生 2022-10-13 01:45 269阅读 0赞

**本文目录**

一、访问者模式介绍

1.1 模式意图

1.2 通用类图

二、模版方法模式的应用

2.1 应用实例

2.2 优缺点

2.4 代码实现

三、源码分析

--------------------

访问者模式属于行为型模式。

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

# 一、访问者模式介绍 #

## 1.1 模式意图 ##

用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

## 1.2 通用类图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70][]

看了这个通用类图，大家可能要犯迷糊了，这里怎么有一个 ObjectStruture 这个类呢？下面的例子是定义了一个 List ，这就是一个 ObjectStruture， 我们来看这几个角色的职责：  
**抽象访问者（Visitor）**：抽象类或者接口，声明访问者可以访问哪些元素，具体到程序中就是 visit  
方法的参数定义哪些对象是可以被访问的；  
**具体访问者（ConcreteVisitor）**：访问者访问到一个类后该怎么干(哎，这个别读歪了)，要做什么事情；  
**抽象元素（Element）**：接口或者抽象类，声明接受那一类型的访问者访问，程序上是通过 accept 方法中的参数来定义；  
**具体元素： （ConcreteElement）**：实现 accept 方法，通常是 visitor.visit(this)，基本上都形成了一个套路了；  
**结构对象（ObjectStruture）**：容纳多个不同类、不同接口的容器，比如 List、Set、Map 等，在项目中，一般很少抽象出来这个角色；  
大家可以这样理解访问者模式，我作为一个访客（Visitor）到朋友家（Visited Class）去拜访，朋  
友之间聊聊天，喝喝酒，再相互吹捧吹捧，炫耀炫耀，这都正常，聊天的时候，朋友告诉我，他今年加官进爵了，工资也涨了 30%，准备再买套房子，那我就在心里盘算（Visitor-self-method）“你个龟儿子，这么有钱，老子去年要借 10W 你都不借”，我根据被朋友的信息，执行了自己的一个方法。

# 二、模版方法模式的应用 #

> 所有设计模式的代码实现例子都可在码云上查看哦，感兴趣的可以查看哈，码云地址：[https://gitee.com/no8g/java-design-patterns][https_gitee.com_no8g_java-design-patterns]

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

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

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

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

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

## 2.1 应用实例 ##

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

## 2.2 优缺点 ##

**优点：** 1、符合单一职责原则。 2、优秀的扩展性。 3、灵活性。

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

2.3 使用场景

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

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

## 2.4 代码实现 ##

步骤一：定义一个访问者接口和该接口的实现类

package com.iot.practice.designpattern.visitor.pattern;
 
 /**
 * IVisitor 此接口用于：
 * @author：hujm
 * @date：2021年07月08日 19:32
 * @remark：访问者，我要去访问人家的数据了
 */
 public interface IVisitor {
 
 /**
 * 首先定义我可以访问普通员工
 *
 * @param commonEmployee 普通员工
 */
 void visit(CommonEmployee commonEmployee);
 
 /**
 * 其次定义，我还可以访问部门经理
 *
 * @param manager 部门经理
 */
 void visit(Manager manager);
 }

package com.iot.practice.designpattern.visitor.pattern;
 
 /**
 * Visitor 此类用于：如下是访问者的实现类
 * @author：hujm
 * @date：2021年07月08日 19:34
 * @remark：在具体的实现类中，定义了两个私有方法，作用就是产生需要打印的数据和格式，然后在访问者访问相关的对象是，产生这个报表。
 */
 public class Visitor implements IVisitor {
 
 /**
 * 访问普通员工，打印出报表
 *
 * @param commonEmployee 普通员工
 */
 @Override
 public void visit(CommonEmployee commonEmployee) {
 System.out.println(this.getCommonEmployee(commonEmployee));
 }
 
 /**
 * 访问部门经理，打印出报表
 *
 * @param manager 部门经理
 */
 @Override
 public void visit(Manager manager) {
 System.out.println(this.getManagerInfo(manager));
 }
 
 /**
 * 组装出基本信息
 *
 * @param employee 员工
 * @return 组装出基本信息
 */
 private String getBasicInfo(Employee employee) {
 String info = "姓名： " + employee.getName() + "\t";
 info = info + "性别： " + (employee.getSex() == Employee.FEMALE ? "女" : "男") + "\t";
 info = info + "薪水： " + employee.getSalary() + "\t";
 return info;
 }
 
 /**
 * 组装出部门经理的信息
 *
 * @param manager 部门经理
 * @return 组装出部门经理的信息
 */
 private String getManagerInfo(Manager manager) {
 String basicInfo = this.getBasicInfo(manager);
 String otherInfo = "业绩： " + manager.getPerformance() + "\t";
 return basicInfo + otherInfo;
 }
 
 /**
 * 组装出普通员工信息
 *
 * @param commonEmployee 普通员工
 * @return 组装出普通员工信息
 */
 private String getCommonEmployee(CommonEmployee commonEmployee) {
 String basicInfo = this.getBasicInfo(commonEmployee);
 String otherInfo = "工作： " + commonEmployee.getJob() + "\t";
 return basicInfo + otherInfo;
 }
 }

在具体的实现类中，定义了两个私有方法，作用就是产生需要打印的数据和格式，然后在访问者访问相关的对象是，产生这个报表。

步骤二：Employee 抽象类和其子类

package com.iot.practice.designpattern.visitor.pattern;
 
 /**
 * Employee 此类用于：
 * @author：hujm
 * @date：2021年07月08日 19:49
 * @remark：删除了 report 方法，增加了 accept 方法，需要实现类来实现。
 */
 public abstract class Employee {
 
 /**
 * 0代表是男性，1代表是女性
 */
 public final static int MALE = 0;
 public final static int FEMALE = 1;
 /**
 * 甭管是谁，都有工资
 */
 private String name;
 /**
 * 只要是员工那就有薪水
 */
 private int salary;
 /**
 * 性别很重要
 */
 private int sex;
 
 public String getName() {
 return name;
 }
 
 public void setName(String name) {
 this.name = name;
 }
 
 public int getSalary() {
 return salary;
 }
 
 public void setSalary(int salary) {
 this.salary = salary;
 }
 
 public int getSex() {
 return sex;
 }
 
 public void setSex(int sex) {
 this.sex = sex;
 }
 
 /**
 * 我允许一个访问者过来访问
 *
 * @param visitor 访问者
 */
 public abstract void accept(IVisitor visitor);
 }

package com.iot.practice.designpattern.visitor.pattern;
 
 /**
 * CommonEmployee 此类用于：
 * @author：hujm
 * @date：2021年07月08日 19:51
 * @remark：普通员工，也就是最小的小兵
 */
 public class CommonEmployee extends Employee {
 
 /**
 * 工作内容，这个非常重要，以后的职业规划就是靠这个了
 */
 private String job;
 
 public String getJob() {
 return job;
 }
 
 public void setJob(String job) {
 this.job = job;
 }
 
 /**
 * 我允许访问者过来访问
 *
 * @param visitor 访问者
 */
 @Override
 public void accept(IVisitor visitor) {
 visitor.visit(this);
 }
 }

package com.iot.practice.designpattern.visitor.pattern;
 
 /**
 * CommonEmployee 此类用于：
 * @author：hujm
 * @date：2021年07月08日 19:51
 * @remark：经理级人物
 */
 public class Manager extends Employee {
 
 /**
 * 这类人物的职责非常明确：业绩
 */
 private String performance;
 
 public String getPerformance() {
 return performance;
 }
 
 public void setPerformance(String performance) {
 this.performance = performance;
 }
 
 /**
 * 部门经理允许访问者访问
 *
 * @param visitor 访问者
 */
 @Override
 public void accept(IVisitor visitor) {
 visitor.visit(this);
 }
 }

步骤三：查看调用逻辑，模拟出公司的人员情况，我们可以想象这个数据室通过持久层传递过来的

package com.iot.practice.designpattern.visitor.pattern;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
 * Client 此类用于：
 * @author：hujm
 * @date：2021年07月09日 17:57
 * @remark：
 * 程序是怎么实现的：
 * 1 首先通过循环遍历所有元素；
 * 2 其次，每个员工对象都定义了一个访问者；
 * 3 再其次，员工对象把自己做为一个参数调用访问者 visit 方法；
 * 4 然后，访问者调用自己内部的计算逻辑，计算出相应的数据和表格元素；
 * 5 最后，访问者打印出报表和数据；事情的经过就是这个样子滴~ 
 */
 public class Client {
 
 public static void main(String[] args) {
 for(Employee emp:mockEmployee()){
 emp.accept(new Visitor());
 }
 }
 
 /**
 * 模拟出公司的人员情况，我们可以想象这个数据室通过持久层传递过来的
 *
 * @return List<Employee>
 */
 public static List<Employee> mockEmployee() {
 List<Employee> empList = new ArrayList<>();
 //产生张三这个员工
 CommonEmployee zhangSan = new CommonEmployee();
 zhangSan.setJob("编写Java程序，绝对的蓝领、苦工加搬运工");
 zhangSan.setName("张三");
 zhangSan.setSalary(1800);
 zhangSan.setSex(Employee.MALE);
 empList.add(zhangSan);
 //产生李四这个员工
 CommonEmployee liSi = new CommonEmployee();
 liSi.setJob("页面美工，审美素质太不流行了！ ");
 liSi.setName("李四");
 liSi.setSalary(1900);
 liSi.setSex(Employee.FEMALE);
 empList.add(liSi);
 //再产生一个经理
 Manager wangWu = new Manager();
 wangWu.setName("王五");
 wangWu.setPerformance("基本上是负值，但是我会拍马屁呀");
 wangWu.setSalary(18750);
 wangWu.setSex(Employee.MALE);
 empList.add(wangWu);
 return empList;
 }
 }

# 三、源码分析 #

完结！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70]: /images/20221005/947e6a67c0dc47019546c249e4387d9f.png
[https_gitee.com_no8g_java-design-patterns]: https://gitee.com/no8g/java-design-patterns