设计模式学习之Facade(外观模式)

 GOF《设计模式》一书对Facade模式是这样描述的:
    为子系统中的一组接口提供一个统一接口。Facade模式定义了一个更高层的接口，使子系统更加容易使用。

    大致意思是说：使用一种比原有方式更简单的办法与系统交互。例如，我们把一个很文件的文件，放在了第二抽屉里，而第二个抽屉的钥匙放在了第一个抽屉里，我们要想取出这个文件，第一步肯定要拿到第一个抽屉的钥匙，然后打开它再拿出第二个抽屉的钥匙，最后打开第二个抽屉取出文件。

    我就上面说的那个情形写一下实现代码，首先我们要实现二个子系统,呵呵，把抽屉比喻成系统，有点夸张了（DrawerOne、DrawerTwo）：

Java代码

1. public class DrawerOne {   
2.   
3.     public void open() {   
4.         System.out.println("第一个抽屉被打开了");   
5.         getKey();   
6.     }   
7.   
8.     public void getKey() {   
9.         System.out.println("得到第二个抽屉的钥匙");   
10.     }   
11.   
12. }  

public class DrawerOne {

	public void open() {
		System.out.println("第一个抽屉被打开了");
		getKey();
	}

	public void getKey() {
		System.out.println("得到第二个抽屉的钥匙");
	}

}

Java代码

1. public class DrawerTwo {   
2.        
3.     public void open() {   
4.         System.out.println("第二个抽屉被打开了");   
5.         getFile();   
6.     }   
7.   
8.     public void getFile() {   
9.         System.out.println("得到这个重要文件");   
10.     }      
11.   
12. }  

public class DrawerTwo {
	
	public void open() {
		System.out.println("第二个抽屉被打开了");
		getFile();
	}

	public void getFile() {
		System.out.println("得到这个重要文件");
	}   

}

Java代码

1. public class Client{      
2.          
3.     public static void main(String []args){      
4.        DrawerOne darwerOne=new DrawerOne();      
5.        DrawerTwo darwerTwo=new DrawerTwo();      
6.     
7.        darwerOne.open();      
8.        darwerTwo.open();     
9.     }      
10.      
11. }    

public class Client{   
	  
    public static void main(String []args){   
       DrawerOne darwerOne=new DrawerOne();   
       DrawerTwo darwerTwo=new DrawerTwo();   
 
       darwerOne.open();   
       darwerTwo.open();  
    }   
  
}  

由于没有使用Façade模式，可以看到要想得到这个文件要首先打开第一个抽屉，然后再打开第二个抽屉，在我们实际所开发的系统中，有时候客户要实现某一操作，并不需要知道实现这一操作的详细步骤，而是简单地点击某一个按钮就可以得到自己想要的结果。下面对上面的代码使用Façade模式进行改进，建立一个FacadeDrawer类：

Java代码

1. public class DrawerFacade {   
2.     DrawerOne darwerOne;   
3.     DrawerTwo darwerTwo;   
4.        
5.     public DrawerFacade() {   
6.         darwerOne = new DrawerOne();      
7.         darwerTwo = new DrawerTwo();      
8.     }   
9.        
10.     public void open() {   
11.         darwerOne.open();      
12.         darwerTwo.open();   
13.     }   
14.   
15. }  

public class DrawerFacade {
	DrawerOne darwerOne;
	DrawerTwo darwerTwo;
	
	public DrawerFacade() {
		darwerOne = new DrawerOne();   
		darwerTwo = new DrawerTwo();   
	}
	
	public void open() {
	    darwerOne.open();   
	    darwerTwo.open();
	}

}

修改Client类：

Java代码

1. public class Client{      
2.          
3.     public static void main(String []args){      
4.        DrawerFacade drawer = new DrawerFacade();   
5.        drawer.open();   
6.     }      
7.      
8. }    

public class Client{   
	  
    public static void main(String []args){   
       DrawerFacade drawer = new DrawerFacade();
       drawer.open();
    }   
  
}  

输出结果如下：
第一个抽屉被打开了
得到第二个抽屉的钥匙
第二个抽屉被打开了
得到这个重要文件

正如上面所说，客户端client，它并不需要关心子系统，而是关心DrawerFacade所留下来的和外部交互的接口，而子系统在DrawerFacade的聚合。

以上只是个人拙见，哪里有不正确的地方，希望大家多多批评指正。^_^

    Facade模式主要适用于以下几种情况:

1)    不需要使用一个复杂系统的所有功能，而且可以创建一个新的类，包含访问系统的所有规则。如果只需要使用系统的部分功能，那么你为新类所创建的API将比原系统的API简单的多。

2)    希望封装或者隐藏系统原系统。

3)    希望使用原系统的功能，而且还希望增加一些新的功能。

4)    编写新类的成本小于所有人学会使用或者未来维护原系统上所需的成本。