23种设计模式-9.外观模式(Facade Pattern)

动机(Motivate):
    在软件开发系统中,客户程序经常会与复杂系统的内部子系统之间产生耦合,而导致客户程序随着子系统的变化而变化。那么如何简化客户程序与子系统之间的交互接口?如何将复杂系统的内部子系统与客户程序之间的依赖解耦?
意图(Intent):
    为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
                                                                         --------《设计模式》GOF
结构图(Struct):
                
                
            
适用性:

    1.为一个复杂子系统提供一个简单接口。

    2.提高子系统的独立性。

    3.在层次化结构中,可以使用Facade模式定义系统中每一层的入口。
生活中的例子:
                
代码实现:
    我们平时的开发中其实已经不知不觉的在用Façade模式,现在来考虑这样一个抵押系统,当有一个客户来时,有如下几件事情需要确认:到银行子系统查询他是否有足够多的存款,到信用子系统查询他是否有良好的信用,到贷款子系统查询他有无贷款劣迹。只有这三个子系统都通过时才可进行抵押。我们先不考虑Façade模式,那么客户程序就要直接访问这些子系统,分别进行判断。类结构图下: 
                 
    
在这个程序中,我们首先要有一个顾客类,它是一个纯数据类,并无任何操作,示意代码:

 1 //顾客类
 2 public class Customer
 3 {
 4     private string _name;
 5 
 6     public Customer(string name)
 7     {
 8         this._name = name;
 9     }
10 
11     public string Name
12     {
13         get { return _name; }
14     }
15 }


下面这三个类均是子系统类,示意代码:

 1 //银行子系统
 2 public class Bank
 3 {
 4     public bool HasSufficientSavings(Customer c, int amount)
 5     {
 6         Console.WriteLine("Check bank for " + c.Name);
 7         return true;
 8     }
 9 }
10 
11 //信用子系统
12 public class Credit
13 {
14     public bool HasGoodCredit(Customer c)
15     {
16         Console.WriteLine("Check credit for " + c.Name);
17         return true;
18     }
19 }
20 
21 //贷款子系统
22 public class Loan
23 {
24     public bool HasNoBadLoans(Customer c)
25     {
26         Console.WriteLine("Check loans for " + c.Name);
27         return true;
28     }
29 }


看客户程序的调用:

 1 //客户程序
 2 public class MainApp
 3 {
 4     private const int _amount = 12000;
 5 
 6     public static void Main()
 7     {
 8         Bank bank = new Bank();
 9         Loan loan = new Loan();
10         Credit credit = new Credit();
11 
12         Customer customer = new Customer("Ann McKinsey");
13 
14         bool eligible = true;
15 
16         if (!bank.HasSufficientSavings(customer, _amount))
17         {
18             eligible = false;
19         }
20         else if (!loan.HasNoBadLoans(customer))
21         {
22             eligible = false;
23         }
24         else if (!credit.HasGoodCredit(customer))
25         {
26             eligible = false;
27         }
28 
29         Console.WriteLine("\n" + customer.Name + " has been " + (eligible ? "Approved" : "Rejected"));
30         Console.ReadLine();
31     }
32 }


可以看到,在不用Façade模式的情况下,客户程序与三个子系统都发生了耦合,这种耦合使得客户程序依赖于子系统,当子系统化时,客户程序也将面临很多变化的挑战。一个合情合理的设计就是为这些子系统创建一个统一的接口,这个接口简化了客户程序的判断操作。看一下引入Façade模式后的类结构图:
           变

外观类Mortage的实现如下:

 1 /外观类
 2 public class Mortgage
 3 {
 4     private Bank bank = new Bank();
 5     private Loan loan = new Loan();
 6     private Credit credit = new Credit();
 7 
 8     public bool IsEligible(Customer cust, int amount)
 9     {
10         Console.WriteLine("{0} applies for {1:C} loan\n",
11           cust.Name, amount);
12 
13         bool eligible = true;
14 
15         if (!bank.HasSufficientSavings(cust, amount))
16         {
17             eligible = false;
18         }
19         else if (!loan.HasNoBadLoans(cust))
20         {
21             eligible = false;
22         }
23         else if (!credit.HasGoodCredit(cust))
24         {
25             eligible = false;
26         }
27 
28         return eligible;
29     }
30 }

顾客类和子系统类的实现仍然如下:

 1 //银行子系统
 2 public class Bank
 3 {
 4     public bool HasSufficientSavings(Customer c, int amount)
 5     {
 6         Console.WriteLine("Check bank for " + c.Name);
 7         return true;
 8     }
 9 }
10 
11 //信用证子系统
12 public class Credit
13 {
14     public bool HasGoodCredit(Customer c)
15     {
16         Console.WriteLine("Check credit for " + c.Name);
17         return true;
18     }
19 }
20 
21 //贷款子系统
22 public class Loan
23 {
24     public bool HasNoBadLoans(Customer c)
25     {
26         Console.WriteLine("Check loans for " + c.Name);
27         return true;
28     }
29 }
30 
31 //顾客类
32 public class Customer
33 {
34     private string name;
35 
36     public Customer(string name)
37     {
38         this.name = name;
39     }
40 
41     public string Name
42     {
43         get { return name; }
44     }
45 }

而此时客户程序的实现:

 1 //客户程序类
 2 public class MainApp
 3 {
 4     public static void Main()
 5     {
 6         //外观
 7         Mortgage mortgage = new Mortgage();
 8 
 9         Customer customer = new Customer("Ann McKinsey");
10         bool eligable = mortgage.IsEligible(customer, 125000);
11 
12         Console.WriteLine("\n" + customer.Name +
13             " has been " + (eligable ? "Approved" : "Rejected")); 
14         Console.ReadLine();
15     }
16 }

可以看到引入Façade模式后,客户程序只与Mortgage发生依赖,也就是Mortgage屏蔽了子系统之间的复杂的操作,达到了解耦内部子系统与客户程序之间的依赖。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值