橋梁模式是對象的結構模式。又稱為柄體(Handle and Body)模式或接口(Interface)模式。橋梁模式的用意是“將抽象化(Abstraction)與實現化(Implementation)脫耦，使得二者可以獨立地變化”。
________________________________________
橋梁模式的用意
橋梁模式雖然不是一個使用頻率很高的模式，但是熟悉這個模式對於理解面向對象的設計原則，包括“開-閉”原則以及組合/聚合復用原則都很有幫助。理解好這兩個原則，有助於形成正確的設計思想和培養良好的設計風格。
橋梁模式的用意是“將抽象化(Abstraction)與實現化(Implementation)脫耦，使得二者可以獨立地變化”。這句話很短，但是第一次讀到這句話的人很可能都會思考良久而不解其意。
這句話有三個關鍵詞，也就是抽象化、實現化和脫耦。理解這三個詞所代表的概念是理解橋梁模式用意的關鍵。
• 抽象化
從眾多的事物中抽取出共同的、本質性的特征，而舍棄其非本質的特征，就是抽象化。例如蘋果、香蕉、生梨、 桃子等，它們共同的特性就是水果。得出水果概念的過程，就是一個抽象化的過程。要抽象，就必須進行比較，沒有比較就無法找到在本質上共同的部分。共同特征是指那些能把一類事物與他類事物區分開來的特征，這些具有區分作用的特征又稱本質特征。因此抽取事物的共同特征就是抽取事物的本質特征，舍棄非本質的特征。 所以抽象化的過程也是一個裁剪的過程。在抽象時，同與不同，決定於從什麼角度上來抽象。抽象的角度取決於分析問題的目的。
通常情況下，一組對象如果具有相同的特征，那麼它們就可以通過一個共同的類來描述。如果一些類具有相同的特征，往往可以通過一個共同的抽象類來描述。
• 實現化
抽象化給出的具體實現，就是實現化。
一個類的實例就是這個類的實例化，一個具體子類是它的抽象超類的實例化。
• 脫耦
所謂耦合，就是兩個實體的行為的某種強關聯。而將它們的強關聯去掉，就是耦合的解脫，或稱脫耦。在這裡，脫耦是指將抽象化和實現化之間的耦合解脫開，或者說是將它們之間的強關聯改換成弱關聯。
所謂強關聯，就是在編譯時期已經確定的，無法在運行時期動態改變的關聯；所謂弱關聯，就是可以動態地確定並且可以在運行時期動態地改變的關聯。顯然，在Java語言中，繼承關系是強關聯，而聚合關系是弱關聯。
將兩個角色之間的繼承關系改為聚合關系，就是將它們之間的強關聯改換成為弱關聯。因此，橋梁模式中的所謂脫耦，就是指在一個軟件系統的抽象化和實現化之間使用聚合關系而不是繼承關系，從而使兩者可以相對獨立地變化。這就是橋梁模式的用意。
橋梁模式的結構
下圖所示就是一個實現瞭橋梁模式的示意性系統的結構圖：
可以看出，這個系統含有兩個等級結構：
一、由抽象化角色和修正抽象化角色組成的抽象化等級結構。
二、由實現化角色和兩個具體實現化角色所組成的實現化等級結構。
橋梁模式所涉及的角色有：
● 抽象化(Abstraction)角色：抽象化給出的定義，並保存一個對實現化對象的引用。
● 修正抽象化(RefinedAbstraction)角色：擴展抽象化角色，改變和修正父類對抽象化的定義。
● 實現化(Implementor)角色：這個角色給出實現化角色的接口，但不給出具體的實現。必須指出的是，這個接口不一定和抽象化角色的接口定義相同，實際上，這兩個接口可以非常不一樣。實現化角色應當隻給出底層操作，而抽象化角色應當隻給出基於底層操作的更高一層的操作。
● 具體實現化(ConcreteImplementor)角色：這個角色給出實現化角色接口的具體實現。
抽象化角色就像是一個水杯的手柄，而實現化角色和具體實現化角色就像是水杯的杯身。手柄控制杯身，這就是此模式別名“柄體”的來源。
對象是對行為的封裝，而行為是由方法實現的。在這個示意性系統裡，抽象化等級結構中的類封裝瞭operation()方法；而實現化等級結構中的類封裝的是operationImpl()方法。當然，在實際的系統中往往會有多於一個的方法。
抽象化等級結構中的方法通過向對應的實現化對象的委派實現自己的功能，這意味著抽象化角色可以通過向不同的實現化對象委派，來達到動態地轉換自己的功能的目的。
源代碼
抽象化角色類，它聲明瞭一個方法operation()，並給出瞭它的實現。這個實現是通過向實現化對象的委派(調用operationImpl()方法)實現的。
[java]
1. public abstract class Abstraction {
2.
3. protected Implementor impl;
4.
5. public Abstraction(Implementor impl){
6. this.impl = impl;
7. }
8. //示例方法
9. public void operation(){
10.
11. impl.operationImpl();
12. }
13. }
修正抽象化角色
[java]
1. public class RefinedAbstraction extends Abstraction {
2.
3. public RefinedAbstraction(Implementor impl) {
4. super(impl);
5. }
6. //其他的操作方法
7. public void otherOperation(){
8.
9. }
10. }
實現化角色
[java]
1. public abstract class Implementor {
2. /**
3. * 示例方法，實現抽象部分需要的某些具體功能
4. */
5. public abstract void operationImpl();
6. }
具體實現化角色
[java]
1. public class ConcreteImplementorA extends Implementor {
2.
3. @Override
4. public void operationImpl() {
5. //具體操作
6. }
7.
8. }
[java]
1. public class ConcreteImplementorB extends Implementor {
2.
3. @Override
4. public void operationImpl() {
5. //具體操作
6. }
7.
8. }
一般而言，實現化角色中的每個方法都應當有一個抽象化角色中的某一個方法與之對應，但是反過來則不一定。換言之，抽象化角色的接口比實現化角色的接口寬。抽象化角色除瞭提供與實現化角色相關的方法之外，還有可能提供其他的方法；而實現化角色則往往僅為實現抽象化角色的相關行為而存在。
________________________________________
使用場景
考慮這樣一個實際的業務功能：發送提示消息。基本上所有帶業務流程處理的系統都會有這樣的功能，比如OA上有尚未處理完畢的文件，需要發送一條消息提示他。
從業務上看，消息又分成普通消息、加急消息和特急消息多種，不同的消息類型，業務功能處理是不一樣的，比如加急消息是在消息上添加加急，而特急消息除瞭添加特急外，還會做一條催促的記錄，多久不完成會繼續催促；從發送消息的手段上看，又有系統內短消息、手機短信息、郵件等。
使用橋梁模式來解決問題
根據業務的功能要求，業務的變化具有兩個維度，一個維度是抽象的消息，包括普通消息、加急消息和特急消息，這幾個抽象的消息本身就具有一定的關系，加急消息和特急消息會擴展普通消息；另一個維度是在具體的消息發送方式上，包括系統內短消息、郵件和手機短消息，這幾個方式是平等的，可被切換的方式。
現在出現問題的根本原因，就在於消息的抽象和實現是混雜在一起的，這就導致瞭一個緯度的變化會引起另一個緯度進行相應的變化，從而使得程序擴展起來非常困難。
要想解決這個問題，就必須把這兩個緯度分開，也就是將抽象部分和實現部分分開，讓它們相互獨立，這樣就可以實現獨立的變化，使擴展變得簡單。抽象部分就是各個消息的類型所對應的功能，而實現部分就是各種發送消息的方式。按照橋梁模式的結構，給抽象部分和實現部分分別定義接口，然後分別實現它們就可以瞭。
源代碼
抽象消息類
[java]
1. package com.bankht.Bridge.bridgeMessage;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午05:26:06
6. *
7. * @類說明 ：抽象消息類
8. */
9. public abstract class AbstractMessage {
10. // 持有一個實現部分的對象
11. MessageImplementor impl;
12.
13. /**
14. * 構造方法，傳入實現部分的對象
15. *
16. * @param impl
17. * 實現部分的對象
18. */
19. public AbstractMessage(MessageImplementor impl) {
20. this.impl = impl;
21. }
22.
23. /**
24. * 發送消息，委派給實現部分的方法
25. *
26. * @param message
27. * 要發送消息的內容
28. * @param toUser
29. * 消息的接受者
30. */
31. public void sendMessage(String message, String toUser) {
32. this.impl.send(message, toUser);
33. }
34. }
普通消息類
[java]
1. package com.bankht.Bridge.bridgeMessage;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午05:27:22
6. *
7. * @類說明 ：普通消息類
8. */
9. public class CommonMessage extends AbstractMessage {
10.
11. public CommonMessage(MessageImplementor impl) {
12. super(impl);
13. }
14.
15. @Override
16. public void sendMessage(String message, String toUser) {
17. // 對於普通消息，直接調用父類方法，發送消息即可
18. super.sendMessage(message, toUser);
19. }
20. }
加急消息類
[java]
1. package com.bankht.Bridge.bridgeMessage;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午05:27:43
6. *
7. * @類說明 ：加急消息類
8. */
9. public class UrgencyMessage extends AbstractMessage {
10.
11. public UrgencyMessage(MessageImplementor impl) {
12. super(impl);
13. }
14.
15. @Override
16. public void sendMessage(String message, String toUser) {
17. message = "加急：" + message;
18. super.sendMessage(message, toUser);
19. }
20.
21. /**
22. * 擴展自己的新功能，監控某消息的處理狀態
23. *
24. * @param messageId
25. * 被監控的消息編號
26. * @return 監控到的消息的處理狀態
27. */
28. public Object watch(String messageId) {
29. // 根據消息id獲取消息的狀態，組織成監控的數據對象，然後返回
30. return null;
31. }
32. }
實現發送消息的統一接口
[java]
1. package com.bankht.Bridge.bridgeMessage;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午05:28:04
6. *
7. * @類說明 ：實現發送消息的統一接口
8. */
9. public interface MessageImplementor {
10. /**
11. * 發送消息
12. *
13. * @param message
14. * 要發送消息的內容
15. * @param toUser
16. * 消息的接受者
17. */
18. public void send(String message, String toUser);
19. }
系統內短消息的實現類
[java]
1. package com.bankht.Bridge.bridgeMessage;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午05:28:25
6. *
7. * @類說明 ：系統內短消息的實現類
8. */
9. public class MessageSMS implements MessageImplementor {
10.
11. @Override
12. public void send(String message, String toUser) {
13.
14. System.out.println("使用系統內短消息的方法，發送消息'" + message + "'給" + toUser);
15. }
16.
17. }
郵件短消息的實現類
[java]
1. package com.bankht.Bridge.bridgeMessage;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午05:28:44
6. *
7. * @類說明 ：郵件短消息的實現類
8. */
9. public class MessageEmail implements MessageImplementor {
10.
11. @Override
12. public void send(String message, String toUser) {
13. System.out.println("使用郵件短消息的方法，發送消息'" + message + "'給" + toUser);
14. }
15.
16. }
客戶端類
[java]
1. package com.bankht.Bridge.bridgeMessage;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午05:29:05
6. *
7. * @類說明 ：客戶端類
8. */
9. public class Client {
10.
11. public static void main(String[] args) {
12. // 創建具體的實現對象
13. MessageImplementor impl = new MessageSMS();
14. // 創建普通消息對象
15. AbstractMessage message = new CommonMessage(impl);
16. message.sendMessage("加班申請速批", "李總");
17.
18. // 將實現方式切換成郵件，再次發送
19. impl = new MessageEmail();
20. // 創建加急消息對象
21. message = new UrgencyMessage(impl);
22. message.sendMessage("加班申請速批", "李總");
23. }
24.
25. }
觀察上面的例子會發現，采用橋梁模式來實現，抽象部分和實現部分分離開瞭，可以相互獨立的變化，而不會相互影響。因此在抽象部分添加新的消息處理（特急消息），對發送消息的實現部分是沒有影響的；反過來增加發送消息的方式（手機短消息），對消息處理部分也是沒有影響的。
橋梁模式的優點
● 分離抽象和實現部分
橋梁模式分離瞭抽象部分和實現部分，從而極大地提供瞭系統的靈活性。讓抽象部分和實現部分獨立出來，分別定義接口，這有助於對系統進行分層，從而產生更好的結構化的系統。
● 更好的擴展性
橋梁模式使得抽象部分和實現部分可以分別獨立地擴展，而不會相互影響，從而大大提高瞭系統的可擴展性。
________________________________________
橋梁模式在Java中的使用
橋梁模式在Java應用中的一個非常典型的例子就是JDBC驅動器。JDBC為所有的關系型數據庫提供一個通用的界面。一個應用系統動態地選擇一個合適的驅動器，然後通過驅動器向數據庫引擎發出指令。這個過程就是將抽象角色的行為委派給實現角色的過程。
抽象角色可以針對任何數據庫引擎發出查詢指令，因為抽象角色並不直接與數據庫引擎打交道，JDBC驅動器負責這個底層的工作。由於JDBC驅動器的存在，應用系統可以不依賴於數據庫引擎的細節而獨立地演化；同時數據庫引擎也可以獨立於應用系統的細節而獨立的演化。兩個獨立的等級結構如下圖所示，左邊是JDBC API的等級結構，右邊是JDBC驅動器的等級結構。應用程序是建立在JDBC API的基礎之上的。
應用系統作為一個等級結構，與JDBC驅動器這個等級結構是相對獨立的，它們之間沒有靜態的強關聯。應用系統通過委派與JDBC驅動器相互作用，這是一個橋梁模式的例子。
JDBC的這種架構，把抽象部分和具體部分分離開來，從而使得抽象部分和具體部分都可以獨立地擴展。對於應用程序而言，隻要選用不同的驅動，就可以讓程序操作不同的數據庫，而無需更改應用程序，從而實現在不同的數據庫上移植；對於驅動程序而言，為數據庫實現不同的驅動程序，並不會影響應用程序。
作者：m13666368773