23种设计模式第二部分结构模式（4）外观模式

怼烎@ 2022-09-25 10:29 133阅读 0赞

![57a92d42-4d84-3aa9-a8b9-63a0b02c2c36.jpg][]

<table style="font-size:14px; margin:1em 0px; border:1px solid rgb(170,170,170); border-collapse:collapse; color:rgb(0,0,0); font-family:sans-serif; line-height:22.4px; background-color:rgb(249,249,249)"> 
 <tbody> 
  <tr> 
   <th style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em; text-align:center; background-color:rgb(242,242,242)"> Pattern</th> 
   <th style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em; text-align:center; background-color:rgb(242,242,242)"> Intent</th> 
  </tr> 
  <tr> 
   <td style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em"><a href="https://en.wikipedia.org/wiki/Adapter_pattern" title="Adapter pattern" style="text-decoration:none; color:rgb(11,0,128); background:none" rel="nofollow">Adapter</a></td> 
   <td style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em">Converts one interface to another so that it matches what the client is expecting</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em"><a href="https://en.wikipedia.org/wiki/Decorator_pattern" title="Decorator pattern" style="text-decoration:none; color:rgb(11,0,128); background:none" rel="nofollow">Decorator</a></td> 
   <td style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em">Dynamically adds responsibility to the interface by wrapping the original code</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em">Facade</td> 
   <td style="border:1px solid rgb(170,170,170); padding:0.2em 0.4em">Provides a simplified interface</td> 
  </tr> 
 </tbody> 
</table>

## 理解 ##

其实，外观模式采用的是一种简化的思想。如上图看到，适配器是实现适配器的转换，装饰器是给原有接口增加新的功能，而外观模式提供了一个简化接口的方法。

我们通过外观的包装，使应用程序只能看到外观对象，而不会看到具体的细节对象，这样无疑会降低应用程序的复杂度，并且提高了程序的可维护性。  
例子1：一个电源总开关可以控制四盏灯、一个风扇、一台空调和一台电视机的启动和关闭。该电源总开关可以同时控制上述所有电器设备，电源总开关即为该系统的外观模式设计。

外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口，看下类图

![eebe2103-6ced-35f2-8664-3a2e8a557f81.jpg][]

## 实现 ##

首先写出3个类

public class CPU {
    	public void startup(){
    		System.out.println("CPU开始工作");
    	}
    	public void shutdown(){
    		System.out.println("CPU关闭");
    	}
    }

public class Memory {
    	public void startup(){
    		System.out.println("Memory开始工作");
    	}
    	public void shutdown(){
    		System.out.println("Memory关闭");
    	}
    }

public class Disk {
    	public void startup(){
    		System.out.println("Disk开始工作");
    	}
    	public void shutdown(){
    		System.out.println("Disk关闭");
    	}
    }

写出包含（关联）3个部件的Computer类

public class Computer {
    	private CPU cpu;
    	private Memory memory;
    	private Disk disk;
    	Computer(){
    		cpu = new CPU();
    		memory = new Memory();
    		disk = new Disk();
    	}
    		
    	public void startup(){
    		System.out.println("开启电脑");
    		cpu.startup();
    		memory.startup();
    		disk.startup();
    	}
    	
    	public void shutdown(){
    		System.out.println("关闭电脑");
    		cpu.shutdown();
    		memory.shutdown();
    		disk.shutdown();
    	}
    }

测试类：

public class User {
    	public static void main(String[] args){
    		Computer computer = new Computer();
    		computer.startup();
    		computer.shutdown();
    	}
    }

输出：

开启电脑
    CPU开始工作
    Memory开始工作
    Disk开始工作
    关闭电脑
    CPU关闭
    Memory关闭
    Disk关闭

有了Computer类，可以使原有的3个类解耦。如果没有Computer类，他们之间存在严重的依赖，修改其中1个可能对其他类有影响，这样不好。可见使用外观模式（facade，大家不要读错这个单词，如果你是理所当然的读，很有可能读错，需要查查记一下）的优点。

## 其他的解释和实现 ##

![Example_of_Facade_design_pattern_in_UML.png][]

C\#：

namespace Designpattern.Facade
    {
        class SubsystemA
        {
            public string OperationA1()
            {
                return "Subsystem A, Method A1\n";
            }
            public string OperationA2()
            {
                return "Subsystem A, Method A2\n";
            }
        }
    
        class SubsystemB
        {
            public string OperationB1()
            {
                return "Subsystem B, Method B1\n";
            }
    
            public string OperationB2()
            {
                return "Subsystem B, Method B2\n";
            }
        }
    
        class SubsystemC
        {
            public string OperationC1()
            {
                return "Subsystem C, Method C1\n";
            }
    
            public string OperationC2()
            {
                return "Subsystem C, Method C2\n";
            }
        }
    
        public class Facade
        {
            private readonly SubsystemA a = new SubsystemA();
            private readonly SubsystemB b = new SubsystemB();
            private readonly SubsystemC c = new SubsystemC();
            public void Operation1()
            {
                Console.WriteLine("Operation 1\n" +
                    a.OperationA1() +
                    a.OperationA2() +
                    b.OperationB1());
            }
            public void Operation2()
            {
                Console.WriteLine("Operation 2\n" +
                    b.OperationB2() +
                    c.OperationC1() +
                    c.OperationC2());
            }
        }
    }

Java:

/* Complex parts */
    
    class CPU {
        public void freeze() { ... }
        public void jump(long position) { ... }
        public void execute() { ... }
    }
    
    class Memory {
        public void load(long position, byte[] data) { ... }
    }
    
    class HardDrive {
        public byte[] read(long lba, int size) { ... }
    }
    
    /* Facade */
    
    class ComputerFacade {
        private CPU processor;
        private Memory ram;
        private HardDrive hd;
    
        public ComputerFacade() {
            this.processor = new CPU();
            this.ram = new Memory();
            this.hd = new HardDrive();
        }
    
        public void start() {
            processor.freeze();
            ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
            processor.jump(BOOT_ADDRESS);
            processor.execute();
        }
    }
    
    /* Client */
    
    class You {
        public static void main(String[] args) {
            ComputerFacade computer = new ComputerFacade();
            computer.start();
        }
    }

## 总结 ##

外观模式一般用在：

1、简化一个相对复杂的系统的接口。

2、分层设计，在每一层都需要一个入口点时。

3、系统存在多个子系统，需要尽量降低各个系统之间的通信和相互依赖程度。

优点：

（1）实现了子系统与客户端之间的松耦合关系。  
（2）客户端屏蔽了子系统组件，减少了客户端所需处理的对象数目，并使得子系统使用起来更加容易。

[57a92d42-4d84-3aa9-a8b9-63a0b02c2c36.jpg]: /images/20220718/69cc338f4c5b4e2f85eccace1d0a2020.png
[eebe2103-6ced-35f2-8664-3a2e8a557f81.jpg]: /images/20220718/9d6e5d58cc5d4df4a098105e691ebd89.png
[Example_of_Facade_design_pattern_in_UML.png]: https://upload.wikimedia.org/wikipedia/en/5/57/Example_of_Facade_design_pattern_in_UML.png