JAVA设计模式(21) —<行为型>访问者模式(Visitor)

最新推荐文章于 2021-02-12 10:16:50 发布

luckykapok918

最新推荐文章于 2021-02-12 10:16:50 发布

阅读量770

点赞数

分类专栏： java设计模式

本文链接：https://blog.csdn.net/luckykapok918/article/details/49836035

版权

java设计模式专栏收录该内容

37 篇文章 0 订阅

订阅专栏

1 定义：

访问者模式(Visitor)

Represent an operation to be performed on the elements of an object structure. Vistor lets you define a new operation without changing the classes of the elements on which it operates.(封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。)

访问者模式的目的是封装一些施加于某种数据结构元素之上的操作，一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。为不同类型的元素提供多种访问操作方式，且可以在不修改原有系统的情况下增加新的操作方式，这就是访问者模式的模式动机。

1.1 通用类图：

在访问者模式结构图中包含如下几个角色：

●抽象访问者(Vistor)：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作。

●具体访问者(ConcreteVisitor)：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。

●抽象元素(Element)：抽象元素一般是抽象类或者接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。

●具体元素(ConcreteElement)：具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。

● 对象结构(ObjectStructure)：对象结构是一个元素的集合，它用于存放元素对象，并且提供了遍历其内部元素的方法。它可以结合组合模式来实现，也可以是一个简单的集合对象，如一个List对象或一个Set对象。

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

在访问者模式中，抽象访问者定义了访问元素对象的方法，通常为每一种类型的元素对象都提供一个访问方法，而具体访问者可以实现这些访问方法。这些访问方法的命名一般有两种方式：一种是直接在方法名中标明待访问元素对象的具体类型，如visitElementA(ElementA elementA)，还有一种是统一取名为visit()，通过参数类型的不同来定义一系列重载的visit()方法。

在访问者模式用到了一种双分派的技术，所谓双分派技术就是在选择一个方法的时候，不仅仅要根据消息接收者（receiver）的运行时区别（Run time type），还要根据参数的运行时区别。在访问者模式中，客户端将具体状态当做参数传递给具体访问者，这里完成第一次分派，然后具体访问者作为参数的“具体状态”中的方法，同时也将自己this作为参数传递进去，这里就完成了第二次分派。双分派意味着得到的执行操作决定于请求的种类和接受者的类型。

1.2 通用代码：

注意Vistor.visit(elem)方法，此方法更多的时候是取出elem中成员，按所需处理显示。

[java]view plaincopy 
   
 public abstract class Element {  
     // 定义业务逻辑  
     public abstract void doSomething();  
   
     // 允许谁来访问  
     public abstract void accept(IVisitor visitor);  
 }  
   
 public class ConcreteElement1 extends Element {  
     // 完善业务逻辑  
     public void doSomething() {  
         // 业务处理  
     }  
   
     // 允许那个访问者访问  
     public void accept(IVisitor visitor) {  
         visitor.visit(this);  
     }  
 }  
   
 public class ConcreteElement2 extends Element {  
     // 完善业务逻辑  
     public void doSomething() {  
         // 业务处理  
     }  
   
     // 允许那个访问者访问  
     public void accept(IVisitor visitor) {  
         visitor.visit(this);  
     }  
 }  
   
 public interface IVisitor {  
     // 可以访问哪些对象  
     public void visit(ConcreteElement1 el1);  
   
     public void visit(ConcreteElement2 el2);  
 }  
   
 public class Visitor implements IVisitor {  
     // 访问el1元素  
     public void visit(ConcreteElement1 el1) {  
         el1.doSomething();  
     }  
   
     // 访问el2元素  
     public void visit(ConcreteElement2 el2) {  
         el2.doSomething();  
     }  
 }  
   
 public class ObjectStruture {  
     // 对象生成器，这里通过一个工厂方法模式模拟  
     public static Element createElement() {  
         Random rand = new Random();  
         if (rand.nextInt(100) > 50) {  
             return new ConcreteElement1();  
         } else {  
             return new ConcreteElement2();  
         }  
     }  
 }  
   
 public class Client {  
     public static void main(String[] args) {  
         for (int i = 0; i < 10; i++) {  
             // 获得元素对象  
             Element el = ObjectStruture.createElement();  
             // 接受访问者访问  
             el.accept(new Visitor());  
         }  
     }  
 }  

2 优点

2.1 符合单一职责原则：具体元素角色负责数据的加载，而Visitor类则负责报表的展现，两个不同的职责非常明确地分离开来，各自演绎变化；

2.2 优秀的扩展性：数据不同的展示，直接在Vistor中增加方法实现；

2.3 灵活性高：对于不同的数据实体，不需要instanceof判断。

3 缺点

3.1 具体元素对访问者公布细节：违背了LOW原则；

3.2 具体元素变更比较困难：增、删、改都会导致Visitor的修改。

3.3 违背了依赖倒置原则：访问者依赖的是具体元素，而不是抽象元素，扩展比较困难。

4 应用场景

4.1 一个对象结构包含很多类对象，他们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作，也就是迭代器模式已经不能胜任的情况。

4.2 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免这些操作“污染”这些对象的类。

总结：业务规则要求遍历多个不同的对象，这本身是访问者模式的出发点，迭代器模式只能访问同类或接口的数据（当然了，如果你使用instanceof，那么能访问所有的数据），而访问者是对迭代器模式的扩充，可以遍历不同的对象，然后针对不同的对象，执行不同的操作。

5 注意事项

暂无

6 扩展

6.1 访问者模式与组合模式联用

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

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

6.2 双重分派

（Java是一个单分派语言：重载时，方法的实参类型源于定义，而方法的所属对象则是动态绑定。）：使用多态+访问者模式，可以看出java是一个支持双分派的单分派语言。

源码一：测试单分派：

[java]view plaincopy 
   
 public interface Role {  
     // 演员要扮演的角色  
 }  
   
 public class IdiotRole implements Role {  
     // 一个弱智角色  
 }  
   
 public class KungFuRole implements Role {  
     // 武功天子第一的角色  
 }  
   
 public abstract class AbsActor {  
     // 演员都能够演一个角色  
     public void act(Role role) {  
         System.out.println("演员可以扮演任何角色");  
     }  
   
     // 可以演功夫戏  
     public void act(KungFuRole role) {  
         System.out.println("演员都可以演功夫角色");  
     }  
 }  
   
 public class YoungActor extends AbsActor {  
     // 年轻演员最喜欢演功夫戏  
     public void act(KungFuRole role) {  
         System.out.println("最喜欢演功夫角色");  
     }  
 }  
   
 public class OldActor extends AbsActor {  
     // 不演功夫角色  
     public void act(KungFuRole role) {  
         System.out.println("年龄大了，不能演功夫角色");  
     }  
 }  
   
 public class Client {  
     public static void main(String[] args) {  
         // 定义一个演员  
         AbsActor actor = new OldActor();  
         // 定义一个角色  
         Role role = new KungFuRole();  
         // 开始演戏  
         actor.act(role);  
         actor.act(new KungFuRole());  
     }  
 }  

源码二：实现双分派：（更改下列代码）

[java]view plaincopy 
   
 public interface Role {  
     // 演员要扮演的角色  
     public void accept(AbsActor actor);  
 }  
   
 public class KungFuRole implements Role {  
     // 武功天子第一的角色  
     public void accept(AbsActor actor) {  
         actor.act(this);  
     }  
 }  
   
 public class IdiotRole implements Role {  
     // 一个弱智角色,然谁来扮演  
     public void accept(AbsActor actor) {  
         actor.act(this);  
     }  
 }  
   
 public class Client {  
     public static void main(String[] args) {  
         // 定义一个演员  
         AbsActor actor = new OldActor();  
         // 定义一个角色  
         Role role = new KungFuRole();  
         // 开始演戏  
         role.accept(actor);  
     }  
 }  

双重分配

典型代码如下所示：

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

在这里使用了重载visit()方法的方式来定义多个方法用于操作不同类型的元素对象。在抽象访问者Visitor类的子类ConcreteVisitor中实现了抽象的访问方法，用于定义对不同类型元素对象的操作，具体访问者类典型代码如下所示：

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

对于元素类而言，在其中一般都定义了一个accept()方法，用于接受访问者的访问，典型的抽象元素类代码如下所示：

[java]view plaincopy 
   
 interface Element  
 {  
     public void accept(Visitor visitor);  
 }  

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

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

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

(1) 调用具体元素类的accept(Visitor visitor)方法，并将Visitor子类对象作为其参数；

(2) 在具体元素类accept(Visitor visitor)方法内部调用传入的Visitor对象的visit()方法，如visit(ConcreteElementA elementA)，将当前具体元素类对象(this)作为参数，如visitor.visit(this)；

(3) 执行Visitor对象的visit()方法，在其中还可以调用具体元素对象的业务方法。

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

7 范例

7.1 医院划价拿药

生老病死乃常态，是我们每个人都逃脱不了的，所以进医院就是一件再平常不过的事情了。在医院看病，你首先的挂号，然后找到主治医生，医生呢？先给你稍微检查下，然后就是各种处方单(什么验血、CD、B超等等，太坑了。。。。)，再然后就给你一个处方单要你去拿药。拿药我们可以分为两步走，第一步，我们要去交钱，划价人员会根据你的处方单上面的药进行划价，交钱。第二步，去药房拿药，药房工作者同样根据你的处方单给你相对应的药。

这里我们就划价和拿药两个步骤进行讨论。这里有三个类，处方单（药）、划价人员、药房工作者。同时划价人员和药房工作者都各自有一个动作：划价、拿药。这里进行最初步的设计如下：

划价人员

[java]view plaincopyprint? 
    
 public class Charge {  
     public void action(){  
         public void action(){  
             if("A药".equals(medicine)){  
                 //A的价格  
             }  
             if("B药".equals(medicine)){  
                 //B的价格  
             }  
             if("C药".equals(medicine)){  
                 //C的价格  
             }  
             if("D药".equals(medicine)){  
                 //D的价格  
             }  
             if("E药".equals(medicine)){  
                 //E的价格  
             }  
             ............  
         }  
     }  
 }  

药房工作者

[java]view plaincopyprint? 
    
 public class WorkerOfPharmacy {  
     public void action(){  
         if("A药".equals(medicine)){  
             //给你A药  
         }  
         if("B药".equals(medicine)){  
             //给你B药  
         }  
         if("C药".equals(medicine)){  
             //给你C药  
         }  
         if("D药".equals(medicine)){  
             //给你D药  
         }  
         if("E药".equals(medicine)){  
             //给你E药  
         }  
         ............  
     }  
 }  

看到这样的代码，我们第一个想法就是，这TMD太乱来了吧，这么多的if…else，谁看了不头晕，而且我们可以想象医院里面的药是那么多，而且随时都会增加的，增加了药就要改变划价人员和药房工作者的代码，这是我们最不希望改变的。那么有没有办法来解决呢？有，访问者模式提供一中比较好的解决方案。

在我们实际的软件开发过程中，有时候我们对同一个对象可能会有不同的处理，对相同元素对象也可能存在不同的操作方式，如处方单，划价人员要根据它来划价，药房工作者要根据它来给药。而且可能会随时增加新的操作，如医院增加新的药物。但是这里有两个元素是保持不变的，或者说很少变：划价人员和药房工作中，变的只不过是他们的操作。所以我们想如果能够将他们的操作抽象化就好了。这里访问者模式就是一个值得考虑的解决方案了。

在这个实例中划价员和药房工作者作为访问者，药品作为访问元素、处方单作为对象结构，所以整个UML结构图如下：

抽象访问者：Visitor.java

[java]view plaincopyprint? 
    
 public abstract class Visitor {  
     protected String name;  
   
     public void setName(String name) {  
         this.name = name;  
     }  
       
       
     public abstract void visitor(MedicineA a);  
       
     public abstract void visitor(MedicineB b);  
 }  

具体访问者：划价员、Charger.java

[java]view plaincopyprint? 
    
 public class Charger extends Visitor{  
   
     public void visitor(MedicineA a) {  
         System.out.println("划价员：" + name +"给药" + a.getName() +"划价:" + a.getPrice());  
     }  
   
     public void visitor(MedicineB b) {  
         System.out.println("划价员：" + name +"给药" + b.getName() +"划价:" + b.getPrice());  
     }  
       
 }  

具体访问者：药房工作者、WorkerOfPharmacy.java

[java]view plaincopyprint? 
    
 public class WorkerOfPharmacy extends Visitor{  
   
     public void visitor(MedicineA a) {  
         System.out.println("药房工作者：" + name + "拿药 ：" + a.getName());  
     }  
   
     public void visitor(MedicineB b) {  
         System.out.println("药房工作者：" + name + "拿药 ：" + b.getName());  
     }  
       
 }  

抽象元素：Medicine.java

[java]view plaincopyprint? 
    
 public abstract class Medicine {  
     protected String name;  
     protected double price;  
   
     public Medicine (String name,double price){  
         this.name = name;  
         this.price = price;  
     }  
       
     public String getName() {  
         return name;  
     }  
   
     public void setName(String name) {  
         this.name = name;  
     }  
   
     public double getPrice() {  
         return price;  
     }  
       
     public void setPrice(double price) {  
         this.price = price;  
     }  
       
     public abstract void accept(Visitor visitor);  
 }  

具体元素：MedicineA.java

[java]view plaincopyprint? 
    
 public class MedicineA extends Medicine{  
   
     public MedicineA(String name, double price) {  
         super(name, price);  
     }  
   
     public void accept(Visitor visitor) {  
         visitor.visitor(this);  
     }  
 }  

具体元素：MedicineB.java

[java]view plaincopyprint? 
    
 public class MedicineB extends Medicine{  
   
     public MedicineB(String name, double price) {  
         super(name, price);  
     }  
   
     public void accept(Visitor visitor) {  
         visitor.visitor(this);  
     }  
 }  

药单：Presciption.java

[java]view plaincopyprint? 
    
 public class Presciption {  
     List<Medicine> list = new ArrayList<Medicine>();  
       
     public void accept(Visitor visitor){  
         Iterator<Medicine> iterator = list.iterator();  
           
         while (iterator.hasNext()) {  
             iterator.next().accept(visitor);  
         }  
     }  
       
     public void addMedicine(Medicine medicine){  
         list.add(medicine);  
     }  
       
     public void removeMedicien(Medicine medicine){  
         list.remove(medicine);  
     }  
 }  

客户端：Client.java

[java]view plaincopyprint? 
    
 public class Client {  
     public static void main(String[] args) {  
         Medicine a = new MedicineA("板蓝根", 11.0);  
         Medicine b = new MedicineB("感康", 14.3);  
           
         Presciption presciption = new Presciption();  
         presciption.addMedicine(a);  
         presciption.addMedicine(b);  
           
         Visitor charger = new Charger();  
         charger.setName("张三");  
           
         Visitor workerOfPharmacy = new WorkerOfPharmacy();  
         workerOfPharmacy.setName("李四");  
           
         presciption.accept(charger);  
         System.out.println("-------------------------------------");  
         presciption.accept(workerOfPharmacy);  
     }  
   
 }  

运行结果

7.2 公司不同类型员工工时和工资统计

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

(1) 正式员工(Full time Employee)每周工作时间为40小时，不同级别、不同部门的员工每周基本工资不同；如果超过40小时，超出部分按照100元/小时作为加班费；如果少于40小时，所缺时间按照请假处理，请假所扣工资以80元/小时计算，直到基本工资扣除到零为止。除了记录实际工作时间外，人力资源部需记录加班时长或请假时长，作为员工平时表现的一项依据。

(2) 临时工(Part time Employee)每周工作时间不固定，基本工资按小时计算，不同岗位的临时工小时工资不同。人力资源部只需记录实际工作时间。

人力资源部和财务部工作人员可以根据各自的需要对员工数据进行汇总处理，人力资源部负责汇总每周员工工作时间，而财务部负责计算每周员工工资。

Sunny软件公司开发人员针对上述需求，提出了一个初始解决方案，其核心代码如下所示：

[java]view plaincopy 
    
 import java.util.*;  
   
 class EmployeeList  
 {  
     private ArrayList<Employee> list = new ArrayList<Employee>(); //员工集合  
   
     //增加员工  
     public void addEmployee(Employee employee)   
     {  
         list.add(employee);  
     }  
       
     //处理员工数据  
     public void handle(String departmentName)  
     {  
         if(departmentName.equalsIgnoreCase("财务部")) //财务部处理员工数据  
         {  
             for(Object obj : list)  
             {  
                 if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee"))  
                 {  
                     System.out.println("财务部处理全职员工数据！");           
                 }  
                 else   
                 {  
                     System.out.println("财务部处理兼职员工数据！");  
                 }  
             }  
         }  
         else if(departmentName.equalsIgnoreCase("人力资源部")) //人力资源部处理员工数据  
         {  
             for(Object obj : list)  
             {  
                 if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee"))  
                 {  
                     System.out.println("人力资源部处理全职员工数据！");                     
                 }  
                 else   
                 {  
                     System.out.println("人力资源部处理兼职员工数据！");  
                 }  
             }             
         }  
     }  
 }  

在EmployeeList类的handle()方法中，通过对部门名称和员工类型进行判断，不同部门对不同类型的员工进行了不同的处理，满足了员工数据汇总的要求。但是该解决方案存在如下几个问题：

(1) EmployeeList类非常庞大，它将各个部门处理各类员工数据的代码集中在一个类中，在具体实现时，代码将相当冗长，EmployeeList类承担了过多的职责，既不方便代码的复用，也不利于系统的扩展，违背了“单一职责原则”。

(2)在代码中包含大量的“if…else…”条件判断语句，既需要对不同部门进行判断，又需要对不同类型的员工进行判断，还将出现嵌套的条件判断语句，导致测试和维护难度增大。

(3)如果要增加一个新的部门来操作员工集合，不得不修改EmployeeList类的源代码，在handle()方法中增加一个新的条件判断语句和一些业务处理代码来实现新部门的访问操作。这违背了“开闭原则”，系统的灵活性和可扩展性有待提高。

(4)如果要增加一种新类型的员工，同样需要修改EmployeeList类的源代码，在不同部门的处理代码中增加对新类型员工的处理逻辑，这也违背了“开闭原则”。

如何解决上述问题？如何为同一集合对象中的元素提供多种不同的操作方式？访问者模式就是一个值得考虑的解决方案，它可以在一定程度上解决上述问题（解决大部分问题）。

完整解决方案

Sunny软件公司开发人员使用访问者模式对OA系统中员工数据汇总模块进行重构，使得系统可以很方便地增加新类型的访问者，更加符合“单一职责原则”和“开闭原则”，重构后的基本结构如图26-3所示：

在图26-3中，FADepartment表示财务部，HRDepartment表示人力资源部，它们充当具体访问者角色，其抽象父类Department充当抽象访问者角色；EmployeeList充当对象结构，用于存储员工列表；FulltimeEmployee表示正式员工，ParttimeEmployee表示临时工，它们充当具体元素角色，其父接口Employee充当抽象元素角色。完整代码如下所示：

[java]view plaincopy 
    
 import java.util.*;  
   
 //员工类：抽象元素类  
 interface Employee  
 {  
     public void accept(Department handler); //接受一个抽象访问者访问  
 }  
   
 //全职员工类：具体元素类  
 class FulltimeEmployee implements Employee  
 {  
     private String name;  
     private double weeklyWage;  
     private int workTime;  
   
     public FulltimeEmployee(String name,double weeklyWage,int workTime)  
     {  
         this.name = name;  
         this.weeklyWage = weeklyWage;  
         this.workTime = workTime;  
     }     
   
     public void setName(String name)   
     {  
         this.name = name;   
     }  
   
     public void setWeeklyWage(double weeklyWage)   
     {  
         this.weeklyWage = weeklyWage;   
     }  
   
     public void setWorkTime(int workTime)   
     {  
         this.workTime = workTime;   
     }  
   
     public String getName()   
     {  
         return (this.name);   
     }  
   
     public double getWeeklyWage()   
     {  
         return (this.weeklyWage);   
     }  
   
     public int getWorkTime()   
     {  
         return (this.workTime);   
     }  
   
     public void accept(Department handler)  
     {  
         handler.visit(this); //调用访问者的访问方法  
     }  
 }  
   
 //兼职员工类：具体元素类  
 class ParttimeEmployee implements Employee  
 {  
     private String name;  
     private double hourWage;  
     private int workTime;  
   
     public ParttimeEmployee(String name,double hourWage,int workTime)  
     {  
         this.name = name;  
         this.hourWage = hourWage;  
         this.workTime = workTime;  
     }     
   
     public void setName(String name)   
     {  
         this.name = name;   
     }  
   
     public void setHourWage(double hourWage)   
     {  
         this.hourWage = hourWage;   
     }  
   
     public void setWorkTime(int workTime)   
     {  
         this.workTime = workTime;   
     }  
   
     public String getName()   
     {  
         return (this.name);   
     }  
   
     public double getHourWage()   
     {  
         return (this.hourWage);   
     }  
   
     public int getWorkTime()   
     {  
         return (this.workTime);   
     }  
   
     public void accept(Department handler)  
     {  
         handler.visit(this); //调用访问者的访问方法  
     }  
 }  
   
 //部门类：抽象访问者类  
 abstract class Department  
 {  
     //声明一组重载的访问方法，用于访问不同类型的具体元素  
     public abstract void visit(FulltimeEmployee employee);  
     public abstract void visit(ParttimeEmployee employee);    
 }  
   
 //财务部类：具体访问者类  
 class FADepartment extends Department  
 {  
     //实现财务部对全职员工的访问  
     public void visit(FulltimeEmployee employee)  
     {  
         int workTime = employee.getWorkTime();  
         double weekWage = employee.getWeeklyWage();  
         if(workTime > 40)  
         {  
             weekWage = weekWage + (workTime - 40) * 100;  
         }  
         else if(workTime < 40)  
         {  
             weekWage = weekWage - (40 - workTime) * 80;  
             if(weekWage < 0)  
             {  
                 weekWage = 0;  
             }  
         }  
         System.out.println("正式员工" + employee.getName() + "实际工资为：" + weekWage + "元。");             
     }  
   
     //实现财务部对兼职员工的访问  
     public void visit(ParttimeEmployee employee)  
     {  
         int workTime = employee.getWorkTime();  
         double hourWage = employee.getHourWage();  
         System.out.println("临时工" + employee.getName() + "实际工资为：" + workTime * hourWage + "元。");       
     }         
 }  
   
 //人力资源部类：具体访问者类  
 class HRDepartment extends Department  
 {  
     //实现人力资源部对全职员工的访问  
     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) + "小时。");  
         }                         
     }  
   
     //实现人力资源部对兼职员工的访问  
     public void visit(ParttimeEmployee employee)  
     {  
         int workTime = employee.getWorkTime();  
         System.out.println("临时工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");  
     }         
 }  
   
 //员工列表类：对象结构  
 class EmployeeList  
 {  
     //定义一个集合用于存储员工对象  
     private ArrayList<Employee> list = new ArrayList<Employee>();  
   
     public void addEmployee(Employee employee)  
     {  
         list.add(employee);  
     }  
   
     //遍历访问员工集合中的每一个员工对象  
     public void accept(Department handler)  
     {  
         for(Object obj : list)  
         {  
             ((Employee)obj).accept(handler);  
         }  
     }  
 }  

为了提高系统的灵活性和可扩展性，我们将具体访问者类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：

[java]view plaincopy 
    
 import javax.xml.parsers.*;  
 import org.w3c.dom.*;  
 import org.xml.sax.SAXException;  
 import java.io.*;  
 class XMLUtil  
 {  
     //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象  
     public static Object getBean()  
     {  
         try  
         {  
             //创建文档对象  
             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
             DocumentBuilder builder = dFactory.newDocumentBuilder();  
             Document doc;                             
             doc = builder.parse(new File("config.xml"));   
           
             //获取包含类名的文本节点  
             NodeList nl = doc.getElementsByTagName("className");  
             Node classNode=nl.item(0).getFirstChild();  
             String cName=classNode.getNodeValue();  
               
             //通过类名生成实例对象并将其返回  
             Class c=Class.forName(cName);  
             Object obj=c.newInstance();  
             return obj;  
         }     
         catch(Exception e)  
         {  
             e.printStackTrace();  
             return null;  
         }  
     }  
 }  

配置文件config.xml中存储了具体访问者类的类名，代码如下所示：

[html]view plaincopy 
    
 <?xml version="1.0"?>  
 <config>  
     <className>FADepartment</className>  
 </config>  

编写如下客户端测试代码：

[java]view plaincopy 
    
 class Client  
 {  
     public static void main(String args[])  
     {  
         EmployeeList list = new EmployeeList();  
         Employee fte1,fte2,fte3,pte1,pte2;  
   
         fte1 = new FulltimeEmployee("张无忌",3200.00,45);  
         fte2 = new FulltimeEmployee("杨过",2000.00,40);  
         fte3 = new FulltimeEmployee("段誉",2400.00,38);  
         pte1 = new ParttimeEmployee("洪七公",80.00,20);  
         pte2 = new ParttimeEmployee("郭靖",60.00,18);  
   
         list.addEmployee(fte1);  
         list.addEmployee(fte2);  
         list.addEmployee(fte3);  
         list.addEmployee(pte1);  
         list.addEmployee(pte2);  
   
         Department dep;  
         dep = (Department)XMLUtil.getBean();  
         list.accept(dep);  
     }  
 }  

编译并运行程序，输出结果如下：

正式员工张无忌实际工资为：3700.0元。

正式员工杨过实际工资为：2000.0元。

正式员工段誉实际工资为：2240.0元。

临时工洪七公实际工资为：1600.0元。

临时工郭靖实际工资为：1080.0元。

如果需要更换具体访问者类，无须修改源代码，只需修改配置文件，例如将访问者类由财务部改为人力资源部，只需将存储在配置文件中的具体访问者类FADepartment改为HRDepartment，如下代码所示：

[html]view plaincopy 
    
 <?xml version="1.0"?>  
 <config>  
     <className>HRDepartment</className>  
 </config>  

重新运行客户端程序，输出结果如下：

正式员工张无忌实际工作时间为：45小时。

正式员工张无忌加班时间为：5小时。

正式员工杨过实际工作时间为：40小时。

正式员工段誉实际工作时间为：38小时。

正式员工段誉请假时间为：2小时。

临时工洪七公实际工作时间为：20小时。

临时工郭靖实际工作时间为：18小时。

如果要在系统中增加一种新的访问者，无须修改源代码，只要增加一个新的具体访问者类即可，在该具体访问者中封装了新的操作元素对象的方法。从增加新的访问者的角度来看，访问者模式符合“开闭原则”。

如果要在系统中增加一种新的具体元素，例如增加一种新的员工类型为“退休人员”，由于原有系统并未提供相应的访问接口（在抽象访问者中没有声明任何访问“退休人员”的方法），因此必须对原有系统进行修改，在原有的抽象访问者类和具体访问者类中增加相应的访问方法。从增加新的元素的角度来看，访问者模式违背了“开闭原则”。

综上所述，访问者模式与抽象工厂模式类似，对“开闭原则”的支持具有倾斜性，可以很方便地添加新的访问者，但是添加新的元素较为麻烦。

luckykapok918

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA设计模式(21) —<行为型>访问者模式(Visitor)

1 定义：访问者模式(Visitor)Represent an operation to be performed on the elements of an object structure. Vistor lets you define a new operation without changing the classes of the elements on which i
复制链接

扫一扫

专栏目录