【JAVA设计模式】外观模式（Facade Pattern）

本文链接：https://blog.csdn.net/C_son/article/details/51121432

一定义

为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层的接口，这个接口使得这一子系统更加容易使用。

二案例

一个子系统中拥有3个模块，每个模块中都有3个方法，其中一个为客户端调用方法，其他两个则为各子模块间互相调用方法。此时有如下需求，客户端为完成功能，需要组合3个模块中的方法才能实现功能。

三未使用模式情况

/**
 * @Description A模块
 * @author jerry 
 * @date 2016年4月11日下午2:16:04
 */
public interface AModuleApi {
	public void a1();	//此方法主要用于外部调用
	public void a2();	//以下两方法主要用于子系统内部间调用
	public void a3();
}

/**
 * @Description A模块实现
 * @author jerry 
 * @date 2016年4月11日下午2:17:10
 */
public class AModuleImpl implements AModuleApi {

	@Override
	public void a1() {
		System.out.println("调用了A模块");
	}

	@Override
	public void a2() {
		//TODO 主要用于子模块间互相调用
	}

	@Override
	public void a3() {
		//TODO 主要用于子模块间互相调用
	}
}

/**
 * @Description B模块
 * @author jerry 
 * @date 2016年4月11日下午2:16:12
 */
public interface BModuleApi {
	public void b1();	//此方法主要用于外部调用
	public void b2();	//以下两方法主要用于子系统内部间调用
	public void b3();
}

/**
 * @Description B模块实现
 * @author jerry 
 * @date 2016年4月11日下午2:17:10
 */
public class BModuleImpl implements BModuleApi {

	@Override
	public void b1() {
		System.out.println("调用了B模块");
	}

	@Override
	public void b2() {
		//TODO 主要用于子模块间互相调用
	}

	@Override
	public void b3() {
		//TODO 主要用于子模块间互相调用
	}
}

同理，C模块也是如此，篇幅原因，这里不贴代码了，需要代码可以从我github下clone，文末会给出地址。

客户端调用如下：

public class Client {

	public static void main(String[] args) {
		AModuleApi a = new AModuleImpl();
		a.a1();
		BModuleApi b = new BModuleImpl();
		b.b1();
		CModuleApi c = new CModuleImpl();
		c.c1();
	}
}

相信很容易可以写出这样的代码。仔细想想可以发现，如果这样写，会存在如下问题：

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

四使用模式的情况

我们可以在 系统这端（即外观模式属于系统这端，若属于客户这端，仍然需要客户去了解每个模块每个方法意义，这样无任何意义。）添加一个外观类，由外观类重组需要调用的方法，如下所示：

/**
 * @Description 外观类,通常设计成单例
 * @author jerry 
 * @date 2016年4月11日下午2:43:26
 */
public class Facade {
	private Facade(){}
	
	public static void test(){
		AModuleApi a = new AModuleImpl();
		a.a1();
		BModuleApi b = new BModuleImpl();
		b.b1();
		CModuleApi c = new CModuleImpl();
		c.c1();
	}
}

public class Client {

	public static void main(String[] args) {
//		AModuleApi a = new AModuleImpl();
//		a.a1();
//		BModuleApi b = new BModuleImpl();
//		b.b1();
//		CModuleApi c = new CModuleImpl();
//		c.c1();
		
		Facade.test();
	}
}

这样一来，客户端只要与外观类打交道即可，从而更好地实现了客户端和子系统各模块的耦合性。

使用外观的目的： 不是给子系统添加新的功能接口，而是让外部减少对子系统内部多个模块的直接交互，松散耦合，从而能够让外部更简单地使用子系统。

当然有时你会有这样的需求，客户端可能只需要调用两个模块即可，那么现有的外观模式就无法使用了，只好绕开外观类，直接找各模块进行调用。此外，你是否发现，我的ABC模块里面除了有供外部调用的方法外，还有各模块间互相调用的方法，这些方法本不需要客户端了解，暴露了过多内部细节，会让客户端产生疑惑，这就是“ 接口污染” ，要解决这个问题，我们可以将Facade类定义为接口，并对其实现，使用 工厂模式对其创建实例，如下所示：

public interface FacadeApi {
	public void a1();
	public void b1();
	public void c1();
	
	/**
	 * @Description 原有方法，将各模块方法组合调用
	 * @return void
	 * @throws 
	 */
	public void test();
}

/**
 * @Description 外观接口实现
 * @author jerry 
 * @date 2016年4月11日下午3:19:25
 */
public class FacadeImpl implements FacadeApi {

	@Override
	public void a1() {
		new AModuleImpl().a1();
	}

	@Override
	public void b1() {
		new BModuleImpl().b1();
	}

	@Override
	public void c1() {
		new CModuleImpl().c1();
	}

	@Override
	public void test() {
		a1();
		b1();
		c1();
	}
}

/**
 * @Description 外观接口实现
 * @author jerry 
 * @date 2016年4月11日下午3:19:25
 */
public class FacadeImpl implements FacadeApi {

	@Override
	public void a1() {
		new AModuleImpl().a1();
	}

	@Override
	public void b1() {
		new BModuleImpl().b1();
	}

	@Override
	public void c1() {
		new CModuleImpl().c1();
	}

	@Override
	public void test() {
		a1();
		b1();
		c1();
	}
}

public class Client {

	public static void main(String[] args) {
//		AModuleApi a = new AModuleImpl();
//		a.a1();
//		BModuleApi b = new BModuleImpl();
//		b.b1();
//		CModuleApi c = new CModuleImpl();
//		c.c1();
		
//		Facade.test();
		
		FacadeApi api = Factory.createFacade();
		api.test();
	}
}

这样以后，就对客户端减少了模块内部方法的暴露。