FacadePattern（23种设计模式之一）

---

设计模式六大原则（1）：单一职责原则
设计模式六大原则（2）：里氏替换原则
设计模式六大原则（3）：依赖倒置原则
设计模式六大原则（4）：接口隔离原则
设计模式六大原则（5）：迪米特法则
设计模式六大原则（6）：开闭原则

---

若有理解不到位，欢迎留言讨论！

---

外观设计模式典型实例：显示生活中有一个种电视万能遥控器，只要和电视配对好了以后，就可以正常使用，不同型号的电视，只要一旦适配，所有的操作模式一模一样。这就是一种外观适配模式。表面上都是同一个遥控器，实际上不同型号的电视，不同的操作，发出的型号可能各不相同。但是对于用户来说，没有任何差别。定义，要求一个子系统的外部和其内部的通信必须通过一个统一的对象进行。门面模式提供一个高层次的接口，使得子系统更易使用。

FacadePattern，UML抽象图百度找，代码实现如下

使用外观设计模式设计一个子系统拥有三个模块，每个模块都有三个方法，其中一个为客户端调用方法，其它两个为各个子模块间互相调用方法。此时客户端需要组合三个模块中的方法才能完成功能。

子系统抽象类

package FacadePattern;
public interface AModuleApi {
	//此方法用于外部调用
	public void a1();
	//以下两个方法主要用于子系统内部间系统调用
	public void a2();
	public void a3();
}

package FacadePattern;
public interface BModuleApi {
	//此方法用于外部调用
	public void b1();
	//以下两个方法主要用于子系统内部间系统调用
	public void b2();
	public void b3();
}

package FacadePattern;
public interface CModuleApi {
	//此方法用于外部调用
	public void c1();
	//以下两个方法主要用于子系统内部间系统调用
	public void c2();
	public void c3();
}

子系统实现类

package FacadePattern.ModuleImpl;
import FacadePattern.AModuleApi;
public class AModuleImpl implements AModuleApi {
	public void a1() {
		System.out.println("调用了A模块");
	}
	public void a2() {
		// 主要用于子模块之间的相互调用
	}
	public void a3() {
		// 主要用于子模块之间的相互调用
	}
}

package FacadePattern.ModuleImpl;
import FacadePattern.BModuleApi;
public class BModuleImpl implements BModuleApi {
	public void b1() {
		System.out.println("调用了B模块");
	}
	public void b2() {
		// 主要用于子模块之间的相互调用
	}
	public void b3() {
		// 主要用于子模块之间的相互调用
	}
}

package FacadePattern.ModuleImpl;
import FacadePattern.CModuleApi;
public class CModuleImpl implements CModuleApi {
	public void c1() {
		System.out.println("调用了C模块");
	}
	public void c2() {
		// 主要用于子模块之间的相互调用
	}
	public void c3() {
		// 主要用于子模块之间的相互调用
	}
}

非外观设计模式客户端

package FacadePattern.Test;
import FacadePattern.AModuleApi;
import FacadePattern.BModuleApi;
import FacadePattern.CModuleApi;
import FacadePattern.ModuleImpl.AModuleImpl;
import FacadePattern.ModuleImpl.BModuleImpl;
import FacadePattern.ModuleImpl.CModuleImpl;
public class NoFacadeClient {
	public static void main(String[] args) {
		AModuleApi aModule = new AModuleImpl();
		aModule.a1();	//启动子系统一
		BModuleApi bModule = new BModuleImpl();
		bModule.b1();   //启动子系统二
		CModuleApi cModule = new CModuleImpl();
		cModule.c1();	//启动子系统三
	}
}

上面的代码我们会经常写，自习详细，会存在如下问题：

• 代码耦合度太高，客户端与子系统中各模块都有关联。一旦子系统有什么更改，会涉及到客户端的修改。
• 客户端想要知道每个模块中各个方法的含义才能进行调用。

现在采用了外观设计模式，添加一个外观类，由外观重组需要调用的方法

外观抽象类

package FacadePattern;
public interface FacadeApi {
	public void a1();
	public void b1();
	public void c1();
	public void test();
}

外观实现类

package FacadePattern.ModuleImpl;
import FacadePattern.FacadeApi;
public class FacadeImpl implements FacadeApi {
	public void a1() {
		new AModuleImpl().a1();
	}
	public void b1() {
		new BModuleImpl().b1();
	}
	public void c1() {
		new CModuleImpl().c1();
	}
	public void test() {
		a1();
		b1();
		c1();
	}
}

采用了外观设计模式的客户端

package FacadePattern.Test;
import FacadePattern.FacadeApi;
import FacadePattern.ModuleImpl.FacadeImpl;
public class FacadeClient {
	public static void main(String[] args) {
		FacadeApi facade = new FacadeImpl();
		facade.test();
	}
}

在test方法中，调用了三个模块中的方法。外观类是在服务端的，不是这客户端。客户端不需要知道具体的内部实现是什么样的。

客户端只需要调用外观模式中的代码即可，不需要关注具体实现细节。

---

别嫌弃我没写注释，这个代码很简单，注释省略，嘿嘿。