设计模式入门之外观者模式Facade

外观者模式在生活中的示例很多，比如组装电脑。

组装电脑有两种方式：

第一种方式是用户自己去各个零件商买零件，最终把这些零件拼在一起组成电脑；

第二种方式是找一家专门组装电脑的公司，告诉他们你的具体需求，让他们去帮你完成组装电脑的工作。

可见，第一种方式对用户的要求是很高的，需要用户了解各个组件并且需要考虑这些零件的兼容性；而第二种方式中，用户只需要告诉组装公司自己需要干什么，让组装公司去帮助自己完成就好了。第二种方式更加常见一些，原因是这种方式很简单，而且可行。

这这个例子中组装电脑的公司就相当于今天要讨论的外观者

外观者模式的作用可以总结成一句话：为外部系统提供一个界面

外观者模式：为系统外部提供一个界面。外观者让外部系统在不需要了解内部逻辑和组成的情况下实现功能。实现了外部系统与内部系统的封装隔离，松散了系统间的耦合。

案例：代码生成

public class ModelConfig {
	private boolean needGenPresentation = true;
	private boolean needGenBusiness = true;
	private boolean needGenDAO = true;

	public boolean isNeedGenPresentation() {
		return needGenPresentation;
	}

	public void setNeedGenPresentation(boolean needGenPresentation) {
		this.needGenPresentation = needGenPresentation;
	}

	public boolean isNeedGenBusiness() {
		return needGenBusiness;
	}

	public void setNeedGenBusiness(boolean needGenBusiness) {
		this.needNeedGenBusiness = needGenBusiness;
	}

	public boolean isNeedGenDAO() {
		return needGenDAO;
	}

	public void setNeedGenDAO() {
		this.needGenDAO = needGenDAO;
	}
}

public class ConfigManager {
	private static ConfigManager manager = null;
	private static ConfigModel cm = null;

	private ConfigManager() {
		
	}

	public static ConfigManager getInstance() {
		if(manager == null) {
			manager = new ConfigManager();
			cm = new ConfigModel();
		}
		return manager;
	}

	public ConfigModel getConfigData() {
		return cm;
	}
}

public class Presentation {
	public void generate() {
		ConfigModel cm = ConfigManager.getInstance().getConfigData();
		if(cm.isNeedGenPresentation()) {
			System.out.println("正在生成表现成代码");
		}
	}
}

public class Business {
	public void generate() {
		ConfigModel cm = ConfigManager.getInstance().getConfigData();
		if(cm.isNeedGenBusiness()) {
			System.out.println("正在生成业务层代码");
		}
	}
}

public class DAO {
	public void generate() {
		ConfigModel cm = ConfigManager.getInstance().getConfigData();
		if(cm.isNeedGenDAO()) {
			System.out.println("正在生成数据层代码");
		}
	}
}

public class Client {
	public static void main(String[] args) {
		new Presentation().generate();
		new Business().generate();
		new DAO().generate();
	}
}

从客户端的代码看出，客户端需要直接调用各个模块，这样的缺点是，并没有隐藏各个模块的具体实现，而且一旦各个模块有所改变，那客户端的逻辑可能也要收到影响，接下来引入外观者模式。

public class Facade {
	public void function generate() {
		new Presentation().generate();
		new Business().generate();
		new DAO().generate();
	}
}

public class Client {
	public static void main(String[] args) {
		new Facade().generate();
	}
}

这样的话，客户端就只需要直接调用Facade进行操作就可以了，而不需要担心各个模块内部的具体实现。

但是，如果客户端除了要调用组合方法外，有时需要直接调用某个模块该怎么办呢，以下还有更好的方式：

public interface AModuleApi {
	public void a1();//给外部系统调用
	public void a2();//给内部调用
	public void a3();//给内部调用
}

public interface BModuleApi {
	public void b1();//给外部系统调用
	public void b2();//给内部调用
	public void b3();//给内部调用
}

public interface CModuleApi {
	public void c1();//给外部系统调用
	public void c2();//给内部调用
	public void c3();//给内部调用
}

public interface FacadeApi {
	public void a1();//这是各个模块提供给客户端调用的接口
	public void b1();//这是各个模块提供给客户端调用的接口
	public void c1();//这是各个模块提供给客户端调用的接口

	public void test();//这是对外提供的组合接口
}

public class Client {
	public static void main(String[] args) {
		FacadeApi facade = new FacadeImpl();
		facade.a1();
		facade.b1();
		facade.c1();
		facade.test();
	}
}

这样使得系统更加灵活，不光可以让客户端简单的调用组合方法，同时可以满足客户端对内部模块的特殊调用需求。各个模块给出接口，也隐藏了各个模块的具体实现。

外观模式优缺点：

优点：松散耦合，简单易用，更好地划分访问的层次

缺点：容易让人疑惑，到底是调用Facade好呢还是直接调用模块好呢，就好比一个人组装好电脑后，想要扩充内存，到底是找中间公司呢还是自己去买个内存条加上呢。。。