## 引入 在閻宏博士的《JAVA與模式》一書中開頭是這樣描述訪問者（Visitor）模式的： > 訪問者模式是對象的行為模式。訪問者模式的目的是封裝一些施加于某種數據結構元素之上的操作。一旦這些操作需要修改的話，接受這個操作的數據結構則可以保持不變。 ## 定義 訪問者模式即表示一個作用于某對象結構中的各元素的操作，它使我們可以在不改變各元素的類的前提下定義作用于這些元素的新操作。 首先我們要明確一點就是訪問者模式適用于數據結構相對穩定的系統。它是將數據的操作與數據結構進行分離了，如果某個系統的數據結構相對穩定，但是操作算法易于變化的話，就比較適用適用訪問者模式，因為訪問者模式使得算法操作的增加變得比較簡單了。 ## 結構 訪問者模式適用于數據結構相對未定的系統，它把數據結構和作用于結構上的操作之間的耦合解脫開，使得操作集合可以相對自由地演化。訪問者模式的簡略圖如下所示：  數據結構的每一個節點都可以接受一個訪問者的調用，此節點向訪問者對象傳入節點對象，而訪問者對象則反過來執行節點對象的操作。這樣的過程叫做“雙重分派”。節點調用訪問者，將它自己傳入，訪問者則將某算法針對此節點執行。訪問者模式的示意性類圖如下所示：  訪問者模式涉及到的角色如下： * 抽象訪問者(Visitor)角色：聲明了一個或者多個方法操作，形成所有的具體訪問者角色必須實現的接口。 * 具體訪問者(ConcreteVisitor)角色：實現抽象訪問者所聲明的接口，也就是抽象訪問者所聲明的各個訪問操作。 * 抽象節點(Node)角色：聲明一個接受操作，接受一個訪問者對象作為一個參數。 * 具體節點(ConcreteNode)角色：實現了抽象節點所規定的接受操作。 * 結構對象(ObjectStructure)角色：有如下的責任，可以遍歷結構中的所有元素；如果需要，提供一個高層次的接口讓訪問者對象可以訪問每一個元素；如果需要，可以設計成一個復合對象或者一個聚集，如List或Set。 ## 分派的概念 變量被聲明時的類型叫做變量的靜態類型(Static Type)，有些人又把靜態類型叫做明顯類型(Apparent Type)；而變量所引用的對象的真實類型又叫做變量的實際類型(Actual Type)。比如： ``` List list = null; list = new ArrayList(); ``` 聲明了一個變量list，它的靜態類型（也叫明顯類型）是List，而它的實際類型是ArrayList。 根據對象的類型而對方法進行的選擇，就是分派(Dispatch)，分派(Dispatch)又分為兩種，即靜態分派和動態分派。 **靜態分派**(Static Dispatch)發生在編譯時期，分派根據靜態類型信息發生。靜態分派對于我們來說并不陌生，方法重載就是靜態分派。 **動態分派**(Dynamic Dispatch)發生在運行時期，動態分派動態地置換掉某個方法。 ### 靜態分派 Java通過方法重載支持靜態分派。用墨子騎馬的故事作為例子，墨子可以騎白馬或者黑馬。墨子與白馬、黑馬和馬的類圖如下所示：  在這個系統中，墨子由Mozi類代表 ``` public class Mozi { public void ride(Horse h){ System.out.println("騎馬"); } public void ride(WhiteHorse wh){ System.out.println("騎白馬"); } public void ride(BlackHorse bh){ System.out.println("騎黑馬"); } public static void main(String[] args) { Horse wh = new WhiteHorse(); Horse bh = new BlackHorse(); Mozi mozi = new Mozi(); mozi.ride(wh); mozi.ride(bh); } } ``` 顯然，Mozi類的ride()方法是由三個方法重載而成的。這三個方法分別接受馬(Horse)、白馬(WhiteHorse)、黑馬(BlackHorse)等類型的參數。 那么在運行時，程序會打印出什么結果呢？結果是程序會打印出相同的兩行“騎馬”。換言之，墨子發現他所騎的都是馬。 為什么呢？兩次對ride()方法的調用傳入的是不同的參數，也就是wh和bh。它們雖然具有不同的真實類型，但是它們的靜態類型都是一樣的，均是Horse類型。 重載方法的分派是根據靜態類型進行的，這個分派過程在編譯時期就完成了。 ### 動態分派 Java通過方法的重寫支持動態分派。用馬吃草的故事作為例子，代碼如下所示： ``` public class Horse { public void eat(){ System.out.println("馬吃草"); } } ``` ``` public class BlackHorse extends Horse { @Override public void eat() { System.out.println("黑馬吃草"); } } ``` ``` public class Client { public static void main(String[] args) { Horse h = new BlackHorse(); h.eat(); } } ``` 變量h的靜態類型是Horse，而真實類型是BlackHorse。如果上面最后一行的eat()方法調用的是BlackHorse類的eat()方法，那么上面打印的就是“黑馬吃草”；相反，如果上面的eat()方法調用的是Horse類的eat()方法，那么打印的就是“馬吃草”。 所以，問題的核心就是Java編譯器在編譯時期并不總是知道哪些代碼會被執行，因為編譯器僅僅知道對象的靜態類型，而不知道對象的真實類型；而方法的調用則是根據對象的真實類型，而不是靜態類型。這樣一來，上面最后一行的eat()方法調用的是BlackHorse類的eat()方法，打印的是“黑馬吃草”。 ### 雙重分派 一個方法根據兩個宗量的類型來決定執行不同的代碼，這就是“雙重分派”。Java語言不支持動態的多分派，也就意味著Java不支持動態的雙分派。但是通過使用設計模式，也可以在Java語言里實現動態的雙重分派。 在Java中可以通過兩次方法調用來達到兩次分派的目的。類圖如下所示：  在圖中有兩個對象，左邊的叫做West，右邊的叫做East。現在West對象首先調用East對象的goEast()方法，并將它自己傳入。在East對象被調用時，立即根據傳入的參數知道了調用者是誰，于是反過來調用“調用者”對象的goWest()方法。通過兩次調用將程序控制權輪番交給兩個對象，其時序圖如下所示：  這樣就出現了兩次方法調用，程序控制權被兩個對象像傳球一樣，首先由West對象傳給了East對象，然后又被返傳給了West對象。 但是僅僅返傳了一下球，并不能解決雙重分派的問題。關鍵是怎樣利用這兩次調用，以及Java語言的動態單分派功能，使得在這種傳球的過程中，能夠觸發兩次單分派。 動態單分派在Java語言中是在子類重寫父類的方法時發生的。換言之，West和East都必須分別置身于自己的類型等級結構中，如下圖所示：  ``` public abstract class West { public abstract void goWest1(SubEast1 east); public abstract void goWest2(SubEast2 east); } ``` ``` public class SubWest1 extends West{ @Override public void goWest1(SubEast1 east) { System.out.println("SubWest1 + " + east.myName1()); } @Override public void goWest2(SubEast2 east) { System.out.println("SubWest1 + " + east.myName2()); } } ``` ``` public class SubWest2 extends West{ @Override public void goWest1(SubEast1 east) { System.out.println("SubWest2 + " + east.myName1()); } @Override public void goWest2(SubEast2 east) { System.out.println("SubWest2 + " + east.myName2()); } } ``` ``` public abstract class East { public abstract void goEast(West west); } ``` ``` public class SubEast1 extends East{ @Override public void goEast(West west) { west.goWest1(this); } public String myName1(){ return "SubEast1"; } } ``` ``` public class SubEast2 extends East{ @Override public void goEast(West west) { west.goWest2(this); } public String myName2(){ return "SubEast2"; } } ``` ``` public class Client { public static void main(String[] args) { //組合1 East east = new SubEast1(); West west = new SubWest1(); east.goEast(west); //組合2 east = new SubEast1(); west = new SubWest2(); east.goEast(west); } } ``` 運行結果如下： ``` SubWest1 + SubEast1 SubWest2 + SubEast1 ``` 系統運行時，會首先創建SubWest1和SubEast1對象，然后客戶端調用SubEast1的goEast()方法，并將SubWest1對象傳入。由于SubEast1對象重寫了其超類East的goEast()方法，因此，這個時候就發生了一次動態的單分派。當SubEast1對象接到調用時，會從參數中得到SubWest1對象，所以它就立即調用這個對象的goWest1()方法，并將自己傳入。由于SubEast1對象有權選擇調用哪一個對象，因此，在此時又進行一次動態的方法分派。 這個時候SubWest1對象就得到了SubEast1對象。通過調用這個對象myName1()方法，就可以打印出自己的名字和SubEast對象的名字。 由于這兩個名字一個來自East等級結構，另一個來自West等級結構中，因此，它們的組合式是動態決定的。這就是動態雙重分派的實現機制。 雙分派技術就是在選擇一個方法的時候，不僅僅要根據消息接收者（receiver）的運行時區別（Run time type），還要根據參數的運行時區別。在訪問者模式中，客戶端將具體狀態當做參數傳遞給具體訪問者，這里完成第一次分派，然后具體訪問者作為參數的“具體狀態”中的方法，同時也將自己this作為參數傳遞進去，這里就完成了第二次分派。雙分派意味著得到的執行操作決定于請求的種類和接受者的類型。 ## 代碼實現 可以看到，抽象訪問者角色為每一個具體節點都準備了一個訪問操作。由于有兩個節點，因此，對應就有兩個訪問操作。 ``` public interface Visitor { /** * 對應于NodeA的訪問操作 */ public void visit(NodeA node); /** * 對應于NodeB的訪問操作 */ public void visit(NodeB node); } ``` 具體訪問者VisitorA類 ``` public class VisitorA implements Visitor { /** * 對應于NodeA的訪問操作 */ @Override public void visit(NodeA node) { System.out.println(node.operationA()); } /** * 對應于NodeB的訪問操作 */ @Override public void visit(NodeB node) { System.out.println(node.operationB()); } } ``` 具體訪問者VisitorB類 ``` public class VisitorB implements Visitor { /** * 對應于NodeA的訪問操作 */ @Override public void visit(NodeA node) { System.out.println(node.operationA()); } /** * 對應于NodeB的訪問操作 */ @Override public void visit(NodeB node) { System.out.println(node.operationB()); } } ``` 抽象節點類 ``` public abstract class Node { /** * 接受操作 */ public abstract void accept(Visitor visitor); } ``` 具體節點類NodeA ``` public class NodeA extends Node{ /** * 接受操作 */ @Override public void accept(Visitor visitor) { visitor.visit(this); } /** * NodeA特有的方法 */ public String operationA(){ return "NodeA"; } } ``` 具體節點類NodeB ``` public class NodeB extends Node{ /** * 接受方法 */ @Override public void accept(Visitor visitor) { visitor.visit(this); } /** * NodeB特有的方法 */ public String operationB(){ return "NodeB"; } } ``` 結構對象角色類，這個結構對象角色持有一個聚集，并向外界提供add()方法作為對聚集的管理操作。通過調用這個方法，可以動態地增加一個新的節點。 ``` public class ObjectStructure { private List<Node> nodes = new ArrayList<Node>(); /** * 執行方法操作 */ public void action(Visitor visitor){ for(Node node : nodes) { node.accept(visitor); } } /** * 添加一個新元素 */ public void add(Node node){ nodes.add(node); } } ``` 客戶端類 ``` public class Client { public static void main(String[] args) { //創建一個結構對象 ObjectStructure os = new ObjectStructure(); //給結構增加一個節點 os.add(new NodeA()); //給結構增加一個節點 os.add(new NodeB()); //創建一個訪問者 Visitor visitor = new VisitorA(); os.action(visitor); } } ``` 雖然在這個示意性的實現里并沒有出現一個復雜的具有多個樹枝節點的對象樹結構，但是，在實際系統中訪問者模式通常是用來處理復雜的對象樹結構的，而且訪問者模式可以用來處理跨越多個等級結構的樹結構問題。這正是訪問者模式的功能強大之處。 結構對象會遍歷它自己所保存的聚集中的所有節點，在本系統中就是節點NodeA和NodeB。首先NodeA會被訪問到，這個訪問是由以下的操作組成的： （1）NodeA對象的接受方法accept()被調用，并將VisitorA對象本身傳入； （2）NodeA對象反過來調用VisitorA對象的訪問方法，并將NodeA對象本身傳入； （3）VisitorA對象調用NodeA對象的特有方法operationA()。 從而就完成了雙重分派過程，接著，NodeB會被訪問，這個訪問的過程和NodeA被訪問的過程是一樣的，這里不再敘述。 ## 優點 * 好的擴展性 能夠在不修改對象結構中的元素的情況下，為對象結構中的元素添加新的功能。 * 好的復用性 可以通過訪問者來定義整個對象結構通用的功能，從而提高復用程度。 * 分離無關行為 可以通過訪問者來分離無關的行為，把相關的行為封裝在一起，構成一個訪問者，這樣每一個訪問者的功能都比較單一。 ## 缺點 * 1、增加新的元素類很困難。在訪問者模式中，每增加一個新的元素類都意味著要在抽象訪問者角色中增加一個新的抽象操作，并在每一個具體訪問者類中增加相應的具體操作，違背了“開閉原則”的要求。 * 2、破壞封裝。訪問者模式通常需要對象結構開放內部數據給訪問者和ObjectStructrue，就會打破組合類的封裝。 ## 適用場景 * 1、對象結構中對象對應的類很少改變，但經常需要在此對象結構上定義新的操作。 * 2、需要對一個對象結構中的對象進行很多不同的并且不相關的操作，而需要避免讓這些操作“污染”這些對象的類，也不希望在增加新操作時修改這些類。 ## 總結 * 1、訪問者模式封裝了對象結構元素之上的操作，使得新增元素的操作變得非常簡單。所以它比較適用于那么對象結構很少變化的類。 * 2、訪問者模式中對象結構存儲了不同類型的元素對象，以供不同訪問者訪問。