簡說設計模式——訪問者模式

時間 2019-12-06

標籤設計模式訪問者简体版

原文原文鏈接

1、什麼是訪問者模式

　　訪問者模式是一個相對比較簡單，但結構又稍顯複雜的模式，它講的是表示一個做用於某對象結構中的各元素的操做，它使你能夠在不改變各元素的類的前提下定義做用於這些元素的新操做。例如，你在朋友家作客，你是訪問者，朋友接收你的訪問，你經過朋友的描述，而後對朋友的描述作出一個判斷，這就是訪問者模式。git

　　訪問者模式（Visitor），封裝一些做用於某種數據結構的各元素的操做，它能夠在不改變數據結構的前提下定義做用於這些元素的新的操做。UML結構圖以下：算法

　　其中，Visitor是抽象訪問者，爲該對象結構中ConcreteElement的每個類聲明一個Visit操做；ConcreteVisitor是具體訪問者，實現每一個由visitor聲明的操做，是每一個操做實現算法的一部分，而該算法片斷是對應於結構中對象的類；ObjectStructure爲能枚舉它的元素，能夠提供一個高層的接口以容許訪問者訪問它的元素；Element定義了一個Accept操做，它以一個訪問者爲參數；ConcreteElement爲具體元素，實現Accept操做。數據結構

　　1. 抽象訪問者

　　此處可爲抽象類或接口，用於聲明訪問者能夠訪問哪些元素，具體到程序中就是visit方法的參數定義哪些對象是能夠被訪問的。ide

1 public abstract class Visitor {
2     
3     public abstract void visitConcreteElementA(ConcreteElementA concreteElementA);
4     
5     public abstract void visitConcreteElementB(ConcreteElementB concreteElementB);
6 
7 }

　　2. 具體訪問者

　　影響訪問者訪問到一個類後該幹什麼、怎麼幹。這裏以ConcreteVisitor1爲例，ConcreteVisitor2就再也不贅述了。this

 1 public class ConcreteVisitor1 extends Visitor {
 2 
 3     @Override
 4     public void visitConcreteElementA(ConcreteElementA concreteElementA) {
 5         System.out.println(concreteElementA.getClass().getName() + " 被 " + this.getClass().getName() + " 訪問");
 6     }
 7 
 8     @Override
 9     public void visitConcreteElementB(ConcreteElementB concreteElementB) {
10         System.out.println(concreteElementB.getClass().getName() + " 被 " + this.getClass().getName() + " 訪問");
11     }
12 
13 }

　　3. 抽象元素

　　此處爲接口後抽象類，用於聲明接受哪一類訪問者訪問，程序上是經過accpet方法中的參數來定義的。spa

　　抽象元素有兩類方法，一是自己的業務邏輯，也就是元素做爲一個業務處理單元必須完成的職責；另一個是容許哪個訪問者來訪問。這裏只聲明的第二類即accept方法。code

1 public abstract class Element {
2     
3     public abstract void accept(Visitor visitor);
4 
5 }

　　4. 具體元素

　　實現accept方法，一般是visitor.visit(this)。這裏以ConcreteElementA爲例，ConcreteElementB就再也不贅述了。對象

 1 public class ConcreteElementA extends Element {
 2 
 3     @Override
 4     public void accept(Visitor visitor) {
 5         visitor.visitConcreteElementA(this);
 6     }
 7     
 8     //其它方法
 9     public void operationA() {
10         
11     }
12 
13 }

　　5. 結構對象

　　元素生產者，通常容納在多個不一樣類、不一樣接口的容器，如List、Set、Map等，在項目中，通常不多抽象出這個角色。blog

 1 public class ObjectStructure {
 2     
 3     private List<Element> elements = new LinkedList<>();
 4     
 5     public void attach(Element element) {
 6         elements.add(element);
 7     }
 8     
 9     public void detach(Element element) {
10         elements.remove(element);
11     }
12     
13     public void accept(Visitor visitor) {
14         for (Element element : elements) {
15             element.accept(visitor);
16         }
17     }
18 
19 }

　　6. Client客戶端

　　咱們經過如下場景模擬一下訪問者模式。接口

 1 public class Client {
 2     
 3     public static void main(String[] args) {
 4         ObjectStructure objectStructure = new ObjectStructure();
 5         
 6         objectStructure.attach(new ConcreteElementA());
 7         objectStructure.attach(new ConcreteElementB());
 8         
 9         ConcreteVisitor1 visitor1 = new ConcreteVisitor1();
10         ConcreteVisitor2 visitor2 = new ConcreteVisitor2();
11         
12         objectStructure.accept(visitor1);
13         objectStructure.accept(visitor2);
14     }
15     
16 }

　　運行結果以下：

2、訪問者模式的應用

　　1. 什麼時候使用

須要對一個對象結構中的對象進行不少不一樣的而且不相關的操做，而須要避免讓這些操做「污染」這些對象的類時

　　2. 方法

在被訪問的類裏面添加一個對外提供接待訪問者的接口

　　3. 優勢

符合單一職責原則
優秀的擴展性
靈活性很是高

　　4. 缺點

具體元素對訪問者公佈細節，也就是說訪問者關注了其餘類的內部細節，這是迪米特法則所不建議的
具體元素變動比較困難
違背了依賴倒轉原則。訪問者依賴的是具體元素，而不是抽象元素

　　5. 使用場景

一個對象結構包含不少類對象，它們有不一樣的接口，而你想對這些對象實施一些依賴與其具體類的操做，也就是用迭代器模式已經不能勝任的情景
須要對一個對結構中的對象進行不少不一樣而且不相關的操做，而你想避免讓這些操做「污染」這些對象

　　6. 目的

把處理從數據結構分離出來

　　7. 應用實例

人類只分爲男人和女人，這個性別分類是穩定的，能夠在狀態類中，增長「男人反應」和「女人反應」兩個方法，方法個數是穩定的，不會很容易發生變化
你在朋友家作客，你是訪問者，朋友接受你的訪問，你經過朋友的描述，而後對朋友的描述作出一個判斷

　　8. 注意事項

訪問者能夠對功能進行統一，能夠作報表、UI、攔截器與過濾器
訪問者模式適用於數據結構相對穩定的系統

3、訪問者模式的實現

　　下面就以上述應用實例中的人類分爲男人和女人這個例子來實現訪問者模式。UML圖以下：

　　1. Action

　　抽象的狀態類，主要聲明如下兩個方法。

　　這裏的關鍵在於人只分男人和女人，這個性別的分類是穩定的，因此能夠在狀態類中，增長「男人反應」和「女人反應」兩個方法，方法個數是穩定的，不會容易發生變化。

1 public abstract class Action {
2     
3     //獲得男人的結論或反應
4     public abstract void getManConclusion(Man man);
5     
6     //獲得女人的結論或反應
7     public abstract void getWomanConclusion(Woman woman);
8 
9 }

　　2. Person

　　人的抽象類。只有一個「接受」的抽象方法，它是用來得到「狀態」對象的。

1 public abstract class Person {
2     
3     //接受
4     public abstract void accept(Action action);
5 
6 }

　　3. Action類的具體實現類

　　這裏以成功類（Success）爲例，失敗類（Fail）同理。

 1 public class Success extends Action {
 2 
 3     @Override
 4     public void getManConclusion(Man man) {
 5         System.out.println("男人成功...");
 6     }
 7 
 8     @Override
 9     public void getWomanConclusion(Woman woman) {
10         System.out.println("女人成功...");
11     }
12 
13 }

　　4. Person類的具體實現類

　　這裏以男人類（Man）爲例，女人類（Woman）同理。

　　這裏用到了雙分派，即首先在客戶程序中將具體狀態做爲參數傳遞給Man類完成了一次分派，而後Man類調用做爲參數的「具體方法」中的方法getManConclusion()，同時將本身（this）做爲參數傳遞進去，這便完成了第二次分派。accept方法就是一個雙分派操做，它獲得執行的操做不只決定於Action類的具體狀態，還決定於它訪問的Person的類別。

1 public class Man extends Person {
2 
3     @Override
4     public void accept(Action action) {
5         action.getManConclusion(this);
6     }
7 
8 }

　　5. 結構對象

 1 public class ObjectStructure {
 2     
 3     private List<Person> elements = new LinkedList<>();
 4     
 5     //增長
 6     public void attach(Person person) {
 7         elements.add(person);
 8     }
 9     
10     //移除
11     public void detach(Person person) {
12         elements.remove(person);
13     }
14     
15     //查看顯示
16     public void display(Action action) {
17         for (Person person : elements) {
18             person.accept(action);
19         }
20     }
21 
22 }

　　6. Client客戶端

 1 public class Client {
 2     
 3     public static void main(String[] args) {
 4         ObjectStructure objectStructure = new ObjectStructure();
 5         
 6         objectStructure.attach(new Man());
 7         objectStructure.attach(new Woman());
 8         
 9         //成功
10         Success success = new Success();
11         objectStructure.display(success);
12         
13         //失敗
14         Failing failing = new Failing();
15         objectStructure.display(failing);
16     }
17 
18 }