門面模式是對象的結構模式，外部與一個子系統的通信必須通過一個統一的門面對象進行。門面模式提供一個高層次的接口，使得子系統更易於使用。
________________________________________
醫院的例子
現代的軟件系統都是比較復雜的，設計師處理復雜系統的一個常見方法便是將其“分而治之”，把一個系統劃分為幾個較小的子系統。如果把醫院作為一個子系統，按照部門職能，這個系統可以劃分為掛號、門診、劃價、化驗、收費、取藥等。看病的病人要與這些部門打交道，就如同一個子系統的客戶端與一個子系統的各個類打交道一樣，不是一件容易的事情。
首先病人必須先掛號，然後門診。如果醫生要求化驗，病人必須首先劃價，然後繳費，才可以到化驗部門做化驗。化驗後再回到門診室。
上圖描述的是病人在醫院裡的體驗，圖中的方框代表醫院。
解決這種不便的方法便是引進門面模式，醫院可以設置一個接待員的位置，由接待員負責代為掛號、劃價、繳費、取藥等。這個接待員就是門面模式的體現，病人隻接觸接待員，由接待員與各個部門打交道。
門面模式的結構
門面模式沒有一個一般化的類圖描述，最好的描述方法實際上就是以一個例子說明。
由於門面模式的結構圖過於抽象，因此把它稍稍具體點。假設子系統內有三個模塊，分別是ModuleA、ModuleB和ModuleC，它們分別有一個示例方法，那麼此時示例的整體結構圖如下：
在這個對象圖中，出現瞭兩個角色：
● 門面(Facade)角色 ：客戶端可以調用這個角色的方法。此角色知曉相關的（一個或者多個）子系統的功能和責任。在正常情況下，本角色會將所有從客戶端發來的請求委派到相應的子系統去。
● 子系統(SubSystem)角色 ：可以同時有一個或者多個子系統。每個子系統都不是一個單獨的類，而是一個類的集合（如上面的子系統就是由ModuleA、ModuleB、ModuleC三個類組合而成）。每個子系統都可以被客戶端直接調用，或者被門面角色調用。子系統並不知道門面的存在，對於子系統而言，門面僅僅是另外一個客戶端而已。
源代碼
子系統角色中的類：
[java]
1. package com.bankht.Facade;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:16:52
6. *
7. * @類說明 ： 子系統角色中的類：
8. */
9. public class ModuleA {
10. // 示意方法
11. public void testA() {
12. System.out.println("調用ModuleA中的testA方法");
13. }
14. }
[java]
1. package com.bankht.Facade;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:17:23
6. *
7. * @類說明 ：
8. */
9. public class ModuleB {
10. // 示意方法
11. public void testB() {
12. System.out.println("調用ModuleB中的testB方法");
13. }
14. }
[java]
1. package com.bankht.Facade;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:17:42
6. *
7. * @類說明 ：
8. */
9. public class ModuleC {
10. // 示意方法
11. public void testC() {
12. System.out.println("調用ModuleC中的testC方法");
13. }
14. }
門面角色類：
[java]
1. package com.bankht.Facade;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:17:55
6. *
7. * @類說明 ：門面角色類：
8. */
9. public class Facade {
10. // 示意方法，滿足客戶端需要的功能
11. public void test() {
12. ModuleA a = new ModuleA();
13. a.testA();
14. ModuleB b = new ModuleB();
15. b.testB();
16. ModuleC c = new ModuleC();
17. c.testC();
18. }
19. }
客戶端角色類：
[java]
1. package com.bankht.Facade;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:18:17
6. *
7. * @類說明 ：客戶端角色類：
8. */
9. public class Client {
10.
11. public static void main(String[] args) {
12.
13. Facade facade = new Facade();
14. facade.test();
15. }
16.
17. }
Facade類其實相當於A、B、C模塊的外觀界面，有瞭這個Facade類，那麼客戶端就不需要親自調用子系統中的A、B、C模塊瞭，也不需要知道系統內部的實現細節，甚至都不需要知道A、B、C模塊的存在，客戶端隻需要跟Facade類交互就好瞭，從而更好地實現瞭客戶端和子系統中A、B、C模塊的解耦，讓客戶端更容易地使用系統。
________________________________________
門面模式的實現
使用門面模式還有一個附帶的好處，就是能夠有選擇性地暴露方法。一個模塊中定義的方法可以分成兩部分，一部分是給子系統外部使用的，一部分是子系統內部模塊之間相互調用時使用的。有瞭Facade類，那麼用於子系統內部模塊之間相互調用的方法就不用暴露給子系統外部瞭。
比如，定義如下A、B、C模塊。
[java]
1. package com.bankht.Facade.SelectiveExposure;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:20:48
6. *
7. * @類說明 ：
8. */
9. public class ModuleA {
10. /**
11. * 提供給子系統外部使用的方法
12. */
13. public void a1() {
14. System.out.println("ModuleA.a1()");
15. };
16.
17. /**
18. * 子系統內部模塊之間相互調用時使用的方法
19. */
20. public void a2() {
21. };
22.
23. public void a3() {
24. };
25. }
[java]
1. package com.bankht.Facade.SelectiveExposure;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:21:04
6. *
7. * @類說明 ：
8. */
9. public class ModuleB {
10. /**
11. * 提供給子系統外部使用的方法
12. */
13. public void b1() {
14. System.out.println("ModuleB.b1()");
15. };
16.
17. /**
18. * 子系統內部模塊之間相互調用時使用的方法
19. */
20. public void b2() {
21. };
22.
23. public void b3() {
24. };
25. }
[java]
1. package com.bankht.Facade.SelectiveExposure;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:21:20
6. *
7. * @類說明 ：
8. */
9. public class ModuleC {
10. /**
11. * 提供給子系統外部使用的方法
12. */
13. public void c1() {
14. System.out.println("ModuleC.c1()");
15. };
16.
17. /**
18. * 子系統內部模塊之間相互調用時使用的方法
19. */
20. public void c2() {
21. };
22.
23. public void c3() {
24. };
25. }
[java]
1. package com.bankht.Facade.SelectiveExposure;
2.
3. /**
4. * @author: 特種兵—AK47
5. * @創建時間：2012-6-26 下午04:21:35
6. *
7. * @類說明 ：
8. */
9. public class ModuleFacade {
10.
11. private ModuleA a = new ModuleA();
12. private ModuleB b = new ModuleB();
13. private ModuleC c = new ModuleC();
14.
15. /**
16. * 下面這些是A、B、C模塊對子系統外部提供的方法
17. */
18. public void a1() {
19. a.a1();
20. }
21.
22. public void b1() {
23. b.b1();
24. }
25.
26. public void c1() {
27. c.c1();
28. }
29. }
客戶端類：
[java]
1. package com.bankht.Facade.SelectiveExposure;
2. /**
3. * @author: 特種兵—AK47
4. * @創建時間：2012-6-26 下午04:24:12
5. *
6. * @類說明 ：
7. */
8. public class Client {
9.
10. public static void main(String[] args) {
11. ModuleFacade facade = new ModuleFacade();
12. facade.a1();
13. facade.b1();
14. facade.c1();
15. }
16. }
這樣定義一個ModuleFacade類可以有效地屏蔽內部的細節，免得客戶端去調用Module類時，發現一些不需要它知道的方法。比如a2()和a3()方法就不需要讓客戶端知道，否則既暴露瞭內部的細節，又讓客戶端迷惑。對客戶端來說，他可能還要去思考a2()、a3()方法用來幹什麼呢？其實a2()和a3()方法是內部模塊之間交互的，原本就不是對子系統外部的，所以幹脆就不要讓客戶端知道。
一個系統可以有幾個門面類
在門面模式中，通常隻需要一個門面類，並且此門面類隻有一個實例，換言之它是一個單例類。當然這並不意味著在整個系統裡隻有一個門面類，而僅僅是說對每一個子系統隻有一個門面類。或者說，如果一個系統有好幾個子系統的話，每一個子系統都有一個門面類，整個系統可以有數個門面類。
為子系統增加新行為
初學者往往以為通過繼承一個門面類便可在子系統中加入新的行為，這是錯誤的。門面模式的用意是為子系統提供一個集中化和簡化的溝通管道，而不能向子系統加入新的行為。比如醫院中的接待員並不是醫護人員，接待員並不能為病人提供醫療服務。
門面模式的優點
門面模式的優點：
● 松散耦合
門面模式松散瞭客戶端與子系統的耦合關系，讓子系統內部的模塊能更容易擴展和維護。
● 簡單易用
門面模式讓子系統更加易用，客戶端不再需要瞭解子系統內部的實現，也不需要跟眾多子系統內部的模塊進行交互，隻需要跟門面類交互就可以瞭。
● 更好的劃分訪問層次
通過合理使用Facade，可以幫助我們更好地劃分訪問的層次。有些方法是對系統外的，有些方法是系統內部使用的。把需要暴露給外部的功能集中到門面中，這樣既方便客戶端使用，也很好地隱藏瞭內部的細節。
________________________________________
門面模式在Tomcat中的使用
Tomcat中門面模式使用的很多，因為Tomcat中有很多不同組件，每個組件要相互通信，但是又不能將自己內部數據過多的暴露給其他組件。用門面模式隔離數據是個很好的方法。
下面是Request上使用的門面模式：
使用過Servlet的人都清楚，除瞭要在web.xml做相應的配置外，還需繼承一個叫HttpServlet的抽象類，並且重寫doGet與doPost方法（當然隻重寫service方法也是可以的）。
[java]
1. public class TestServlet extends HttpServlet {
2.
3. public void doGet(HttpServletRequest request, HttpServletResponse response)
4. throws ServletException, IOException {
5.
6. this.doPost(request, response);
7.
8. }
9.
10. public void doPost(HttpServletRequest request, HttpServletResponse response)
11. throws ServletException, IOException {
12.
13.
14. }
15.
16. }
可以看出doGet與doPost方法有兩個參數，參數類型是接口HttpServletRequest與接口HttpServletResponse，那麼從Tomcat中傳遞過來的真實類型到底是什麼呢？通過debug會發現，在真正調用TestServlet類之前，會經過很多Tomcat中的方法。如下圖所示
註意紅色方框圈中的類，StandardWrapperValue類中的invoke方法225行代碼如下：
[java]
1. filterChain.doFilter
2. (request.getRequest(), response.getResponse());
在StandardWrapperValue類中並沒有直接將Request對象與Response對象傳遞給ApplicationFilterChain類的doFilter方法，傳遞的是RequestFacade與ResponseFacade對象，為什麼這麼說呢，看一下request.getRequest()與response.getResponse()方法就真相大白瞭。
Request類
[java]
1. public HttpServletRequest getRequest() {
2. if (facade == null) {
3. facade = new RequestFacade(this);
4. }
5. return facade;
6. }
Response類
[java]
1. public HttpServletResponse getResponse() {
2. if (facade == null) {
3. facade = new ResponseFacade(this);
4. }
5. return (facade);
6. }
可以看到它們返回都是各自的一個門面類，那麼這樣做有什麼好處呢？
Request對象中的很多方法都是內部組件之間相互交互時使用的，比如setComet、setRequestedSessionId等方法（這裡就不一一列舉瞭）。這些方法並不對外部公開，但是又必須設置為public，因為還需要跟內部組件之間交互使用。最好的解決方法就是通過使用一個Facade類，將與內部組件之間交互使用的方法屏蔽掉，隻提供給外部程序感興趣的方法。
如果不使用Facade類，直接傳遞的是Request對象和Response對象，那麼熟悉容器內部運作的程序員可以分別把ServletRequest和ServletResponse對象向下轉換為Request和Response，並調用它們的公共方法。比如擁有Request對象，就可以調用setComet、setRequestedSessionId等方法，這會危害安全性。
作者：m13666368773