訪問者模式是對象的行為模式。訪問者模式的目的是封裝一些施加於某種數據結構元素之上的操作。一旦這些操作需要修改的話，接受這個操作的數據結構則可以保持不變。
分派的概念
變量被聲明時的類型叫做變量的靜態類型(Static Type)，有些人又把靜態類型叫做明顯類型(Apparent Type)；而變量所引用的對象的真實類型又叫做變量的實際類型(Actual Type)。比如
[java]
List list = null;
list = new ArrayList();
List list = null;
list = new ArrayList();
聲明瞭一個變量list，它的靜態類型（也叫明顯類型）是List，而它的實際類型是ArrayList。
根據對象的類型而對方法進行的選擇，就是分派(Dispatch)，分派(Dispatch)又分為兩種，即靜態分派和動態分派。
靜態分派(Static Dispatch)發生在編譯時期，分派根據靜態類型信息發生。靜態分派對於我們來說並不陌生，方法重載就是靜態分派。
動態分派(Dynamic Dispatch)發生在運行時期，動態分派動態地置換掉某個方法。
靜態分派
Java通過方法重載支持靜態分派。用墨子騎馬的故事作為例子，墨子可以騎白馬或者黑馬。墨子與白馬、黑馬和馬的類圖如下所示：
在這個系統中，墨子由Mozi類代表
[java]
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:41:24
*
* @類說明 ：在這個系統中，墨子由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);
}
}
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:41:24
*
* @類說明 ：在這個系統中，墨子由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通過方法的重寫支持動態分派。用馬吃草的故事作為例子，代碼如下所示：
[java]
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:41:46
*
* @類說明 ：Java通過方法的重寫支持動態分派。用馬吃草的故事作為例子
*/
public class Horse {
public void eat() {
System.out.println("馬吃草");
}
}
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:41:46
*
* @類說明 ：Java通過方法的重寫支持動態分派。用馬吃草的故事作為例子
*/
public class Horse {
public void eat() {
System.out.println("馬吃草");
}
}
[java]
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:43:15
*
* @類說明 ：
*/
public class WhiteHorse extends Horse {
@Override
public void eat() {
System.out.println("白馬吃草");
}
}
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:43:15
*
* @類說明 ：
*/
public class WhiteHorse extends Horse {
@Override
public void eat() {
System.out.println("白馬吃草");
}
}
[java]
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:42:08
*
* @類說明 ：
*/
public class BlackHorse extends Horse {
@Override
public void eat() {
System.out.println("黑馬吃草");
}
}
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:42:08
*
* @類說明 ：
*/
public class BlackHorse extends Horse {
@Override
public void eat() {
System.out.println("黑馬吃草");
}
}
[java]
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:42:34
*
* @類說明 ：
*/
public class Client {
public static void main(String[] args) {
Horse h = new BlackHorse();
h.eat();
}
}
package com.bankht.Visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:42:34
*
* @類說明 ：
*/
public class Client {
public static void main(String[] args) {
Horse h = new BlackHorse();
h.eat();
}
}
運行一下：
[html]
黑馬吃草
黑馬吃草
變量h的靜態類型是Horse，而真實類型是BlackHorse。如果上面最後一行的eat()方法調用的是BlackHorse類的eat()方法，那麼上面打印的就是“黑馬吃草”；相反，如果上面的eat()方法調用的是Horse類的eat()方法，那麼打印的就是“馬吃草”。
所以，問題的核心就是Java編譯器在編譯時期並不總是知道哪些代碼會被執行，因為編譯器僅僅知道對象的靜態類型，而不知道對象的真實類型；而方法的調用則是根據對象的真實類型，而不是靜態類型。這樣一來，上面最後一行的eat()方法調用的是BlackHorse類的eat()方法，打印的是“黑馬吃草”。
分派的類型
一個方法所屬的對象叫做方法的接收者，方法的接收者與方法的參數統稱做方法的宗量。比如下面例子中的Test類
[java]
public class Test {
public void print(String str){
System.out.println(str);
}
}
public class Test {
public void print(String str){
System.out.println(str);
}
}
在上面的類中，print()方法屬於Test對象，所以它的接收者也就是Test對象瞭。print()方法有一個參數是str,它的類型是String。
根據分派可以基於多少種宗量，可以將面向對象的語言劃分為單分派語言(Uni-Dispatch)和多分派語言(Multi-Dispatch)。單分派語言根據一個宗量的類型進行對方法的選擇，多分派語言根據多於一個的宗量的類型對方法進行選擇。
C++和Java均是單分派語言，多分派語言的例子包括CLOS和Cecil。按照這樣的區分，Java就是動態的單分派語言，因為這種語言的動態分派僅僅會考慮到方法的接收者的類型，同時又是靜態的多分派語言，因為這種語言對重載方法的分派會考慮到方法的接收者的類型以及方法的所有參數的類型。
在一個支持動態單分派的語言裡面，有兩個條件決定瞭一個請求會調用哪一個操作：一是請求的名字，而是接收者的真實類型。單分派限制瞭方法的選擇過程，使得隻有一個宗量可以被考慮到，這個宗量通常就是方法的接收者。在Java語言裡面，如果一個操作是作用於某個類型不明的對象上面，那麼對這個對象的真實類型測試僅會發生一次，這就是動態的單分派的特征。
雙重分派
一個方法根據兩個宗量的類型來決定執行不同的代碼，這就是“雙重分派”。Java語言不支持動態的多分派，也就意味著Java不支持動態的雙分派。但是通過使用設計模式，也可以在Java語言裡實現動態的雙重分派。
在Java中可以通過兩次方法調用來達到兩次分派的目的。類圖如下所示：
在圖中有兩個對象，左邊的叫做West，右邊的叫做East。現在West對象首先調用East對象的goEast()方法，並將它自己傳入。在East對象被調用時，立即根據傳入的參數知道瞭調用者是誰，於是反過來調用“調用者”對象的goWest()方法。通過兩次調用將程序控制權輪番交給兩個對象，其時序圖如下所示：
這樣就出現瞭兩次方法調用，程序控制權被兩個對象像傳球一樣，首先由West對象傳給瞭East對象，然後又被返傳給瞭West對象。
但是僅僅返傳瞭一下球，並不能解決雙重分派的問題。關鍵是怎樣利用這兩次調用，以及Java語言的動態單分派功能，使得在這種傳球的過程中，能夠觸發兩次單分派。
動態單分派在Java語言中是在子類重寫父類的方法時發生的。換言之，West和East都必須分別置身於自己的類型等級結構中，如下圖所示：
源代碼
West類
[java]
public abstract class West {
public abstract void goWest1(SubEast1 east);
public abstract void goWest2(SubEast2 east);
}
public abstract class West {
public abstract void goWest1(SubEast1 east);
public abstract void goWest2(SubEast2 east);
}
SubWest1類
[java]
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 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());
}
}
SubWest2類
[java]
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 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());
}
}
East類
[java]
public abstract class East {
public abstract void goEast(West west);
}
public abstract class East {
public abstract void goEast(West west);
}
SubEast1類
[java]
public class SubEast1 extends East{
@Override
public void goEast(West west) {
west.goWest1(this);
}
public String myName1(){
return "SubEast1";
}
}
public class SubEast1 extends East{
@Override
public void goEast(West west) {
west.goWest1(this);
}
public String myName1(){
return "SubEast1";
}
}
SubEast2類
[java]
public class SubEast2 extends East{
@Override
public void goEast(West west) {
west.goWest2(this);
}
public String myName2(){
return "SubEast2";
}
}
public class SubEast2 extends East{
@Override
public void goEast(West west) {
west.goWest2(this);
}
public String myName2(){
return "SubEast2";
}
}
客戶端類
[java]
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);
}
}
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等級結構中，因此，它們的組合式是動態決定的。這就是動態雙重分派的實現機制。
訪問者模式的結構
訪問者模式適用於數據結構相對未定的系統，它把數據結構和作用於結構上的操作之間的耦合解脫開，使得操作集合可以相對自由地演化。訪問者模式的簡略圖如下所示：
數據結構的每一個節點都可以接受一個訪問者的調用，此節點向訪問者對象傳入節點對象，而訪問者對象則反過來執行節點對象的操作。這樣的過程叫做“雙重分派”。節點調用訪問者，將它自己傳入，訪問者則將某算法針對此節點執行。訪問者模式的示意性類圖如下所示：
訪問者模式涉及到的角色如下：
● 抽象訪問者(Visitor)角色：聲明瞭一個或者多個方法操作，形成所有的具體訪問者角色必須實現的接口。
● 具體訪問者(ConcreteVisitor)角色：實現抽象訪問者所聲明的接口，也就是抽象訪問者所聲明的各個訪問操作。
● 抽象節點(Node)角色：聲明一個接受操作，接受一個訪問者對象作為一個參數。
● 具體節點(ConcreteNode)角色：實現瞭抽象節點所規定的接受操作。
● 結構對象(ObjectStructure)角色：有如下的責任，可以遍歷結構中的所有元素；如果需要，提供一個高層次的接口讓訪問者對象可以訪問每一個元素；如果需要，可以設計成一個復合對象或者一個聚集，如List或Set。
源代碼
可以看到，抽象訪問者角色為每一個具體節點都準備瞭一個訪問操作。由於有兩個節點，因此，對應就有兩個訪問操作。
[java]
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:50:06
*
* @類說明 ：可以看到，抽象訪問者角色為每一個具體節點都準備瞭一個訪問操作。由於有兩個節點，因此，對應就有兩個訪問操作。
*/
public interface Visitor {
/**
* 對應於NodeA的訪問操作
*/
public void visit(NodeA node);
/**
* 對應於NodeB的訪問操作
*/
public void visit(NodeB node);
}
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:50:06
*
* @類說明 ：可以看到，抽象訪問者角色為每一個具體節點都準備瞭一個訪問操作。由於有兩個節點，因此，對應就有兩個訪問操作。
*/
public interface Visitor {
/**
* 對應於NodeA的訪問操作
*/
public void visit(NodeA node);
/**
* 對應於NodeB的訪問操作
*/
public void visit(NodeB node);
}
具體訪問者VisitorA類
[java]
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:58:04
*
* @類說明 ：
*/
public class VisitorA implements Visitor {
/**
* 對應於NodeA的訪問操作
*/
@Override
public void visit(NodeA node) {
System.out.println("VisitorA：" + node.operationA());
}
/**
* 對應於NodeB的訪問操作
*/
@Override
public void visit(NodeB node) {
System.out.println("VisitorA：" + node.operationB());
}
}
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:58:04
*
* @類說明 ：
*/
public class VisitorA implements Visitor {
/**
* 對應於NodeA的訪問操作
*/
@Override
public void visit(NodeA node) {
System.out.println("VisitorA：" + node.operationA());
}
/**
* 對應於NodeB的訪問操作
*/
@Override
public void visit(NodeB node) {
System.out.println("VisitorA：" + node.operationB());
}
}
具體訪問者VisitorB類
[java]
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:58:21
*
* @類說明 ：
*/
public class VisitorB implements Visitor {
/**
* 對應於NodeA的訪問操作
*/
@Override
public void visit(NodeA node) {
System.out.println("VisitorB：" + node.operationA());
}
/**
* 對應於NodeB的訪問操作
*/
@Override
public void visit(NodeB node) {
System.out.println("VisitorB：" + node.operationB());
}
}
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:58:21
*
* @類說明 ：
*/
public class VisitorB implements Visitor {
/**
* 對應於NodeA的訪問操作
*/
@Override
public void visit(NodeA node) {
System.out.println("VisitorB：" + node.operationA());
}
/**
* 對應於NodeB的訪問操作
*/
@Override
public void visit(NodeB node) {
System.out.println("VisitorB：" + node.operationB());
}
}
抽象節點類
[java]
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:58:57
*
* @類說明 ：
*/
public abstract class Node {
/**
* 接受操作
*/
public abstract void accept(Visitor visitor);
}
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:58:57
*
* @類說明 ：
*/
public abstract class Node {
/**
* 接受操作
*/
public abstract void accept(Visitor visitor);
}
具體節點類NodeA
[java]
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:59:45
*
* @類說明 ：
*/
public class NodeA extends Node {
/**
* 接受操作
*/
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
/**
* NodeA特有的方法
*/
public String operationA() {
return "NodeA";
}
}
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:59:45
*
* @類說明 ：
*/
public class NodeA extends Node {
/**
* 接受操作
*/
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
/**
* NodeA特有的方法
*/
public String operationA() {
return "NodeA";
}
}
具體節點類NodeB
[java]
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:59:59
*
* @類說明 ：
*/
public class NodeB extends Node {
/**
* 接受方法
*/
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
/**
* NodeB特有的方法
*/
public String operationB() {
return "NodeB";
}
}
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午10:59:59
*
* @類說明 ：
*/
public class NodeB extends Node {
/**
* 接受方法
*/
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
/**
* NodeB特有的方法
*/
public String operationB() {
return "NodeB";
}
}
結構對象角色類，這個結構對象角色持有一個聚集，並向外界提供add()方法作為對聚集的管理操作。通過調用這個方法，可以動態地增加一個新的節點。
[java]
package com.bankht.Visitor.visitor;
import java.util.ArrayList;
import java.util.List;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午11:00:15
*
* @類說明 ：
*/
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);
}
}
package com.bankht.Visitor.visitor;
import java.util.ArrayList;
import java.util.List;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午11:00:15
*
* @類說明 ：
*/
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);
}
}
客戶端類
[java]
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午11:00:29
*
* @類說明 ：
*/
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);
}
}
package com.bankht.Visitor.visitor;
/**
* @author: 特種兵—AK47
* @創建時間：2012-7-3 上午11:00:29
*
* @類說明 ：
*/
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對象傳入。
其次，客戶端創建瞭一個VisitorA對象，並將此對象傳給結構對象。
然後，客戶端調用結構對象聚集管理方法，將NodeA和NodeB節點加入到結構對象中去。
最後，客戶端調用結構對象的行動方法action()，啟動訪問過程。
訪問過程時序圖
結構對象會遍歷它自己所保存的聚集中的所有節點，在本系統中就是節點NodeA和NodeB。首先NodeA會被訪問到，這個訪問是由以下的操作組成的：
（1）NodeA對象的接受方法accept()被調用，並將VisitorA對象本身傳入；
（2）NodeA對象反過來調用VisitorA對象的訪問方法，並將NodeA對象本身傳入；
（3）VisitorA對象調用NodeA對象的特有方法operationA()。
從而就完成瞭雙重分派過程，接著，NodeB會被訪問，這個訪問的過程和NodeA被訪問的過程是一樣的，這裡不再敘述。
訪問者模式的優點
● 好的擴展性
能夠在不修改對象結構中的元素的情況下，為對象結構中的元素添加新的功能。
● 好的復用性
可以通過訪問者來定義整個對象結構通用的功能，從而提高復用程度。
● 分離無關行為
可以通過訪問者來分離無關的行為，把相關的行為封裝在一起，構成一個訪問者，這樣每一個訪問者的功能都比較單一。
訪問者模式的缺點
● 對象結構變化很困難
不適用於對象結構中的類經常變化的情況，因為對象結構發生瞭改變，訪問者的接口和訪問者的實現都要發生相應的改變，代價太高。
● 破壞封裝
訪問者模式通常需要對象結構開放內部數據給訪問者和ObjectStructrue，這破壞瞭對象的封裝性。
作者：m13666368773