设计模式很难应用：设计模式系列外观模式
设计模式很难应用：设计模式系列外观模式方法组A()---- 子系统方法一 子系统方法二 子系统方法四 方法组B()---- 子系统方法二 子系统方法三 ----over---- 优点减少系统的相互依赖；外观模式通过封装子系统，向上层模块提供统一的接口，从而降低的上层模块与子系统的过度耦合；提高了灵活性；提高安全性。缺点不符合开闭原则：在不对外观类进行抽象的时候，如果需要添加新的子系统，就需要对Facade类进行修改。/** *外观/门面模式 */ publicclassFacadePattern{ publicstaticvoidmain(String[]args){ Facadefacade=newFacade(); facade.MethodA(); facade.MethodB(); System.out.println("----over----"); } } 输出如下：步骤1：定义subsystem
作者公众号：一角钱技术（org_yijiaoqian）
前言- 23种设计模式速记
- 单例（singleton）模式
- 工厂方法（factory method）模式
- 抽象工厂（abstract factory）模式
- 建造者/构建器（builder）模式
- 原型（prototype）模式
- 享元（flyweight）模式
- 持续更新中......
23种设计模式快速记忆的请看上面第一篇，本篇和大家一起来学习外观(门面)模式相关内容，外观模式一定是我们平常使用最多的一种。
为子系统中的一组接口提供一个一致的接口，Facade 模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
通过创建一个统一的外观类，用来包装子系统中一个 / 多个复杂的类，客户端可通过调用外观类的方法来调用内部子系统中所有方法。
- 避免了系统与系统之间的高耦合度
- 使得复杂的子系统用法变得简单
步骤1：定义subsystem角色
classSubSystemOne{
publicvoidmethodOne(){
System.out.println("子系统方法一");
}
}
classSubSystemTwo{
publicvoidmethodTwo(){
System.out.println("子系统方法二");
}
}
classSubSystemthree{
publicvoidmethodThree(){
System.out.println("子系统方法三");
}
}
classSubSystemfour{
publicvoidmethodFour(){
System.out.println("子系统方法四");
}
}
步骤2：定义Facade角色
classFacade{
SubSystemOneone;
SubSystemTwotwo;
SubSystemThreethree;
SubSystemFourfour;
publicFacade(){
this.one=newSubSystemOne();
this.two=newSubSystemTwo();
this.three=newSubSystemThree();
this.four=newSubSystemFour();
}
publicvoidMethodA(){
System.out.println("方法组A()----");
one.methodOne();
two.methodTwo();
four.methodFour();
}
publicvoidMethodB(){
System.out.println("方法组B()----");
two.methodTwo();
three.methodThree();
}
}
步骤3：验证输出结果
/**
*外观/门面模式
*/
publicclassFacadePattern{
publicstaticvoidmain(String[]args){
Facadefacade=newFacade();
facade.MethodA();
facade.MethodB();
System.out.println("----over----");
}
}
输出如下：
方法组A()----
子系统方法一
子系统方法二
子系统方法四
方法组B()----
子系统方法二
子系统方法三
----over----
优点
- 减少系统的相互依赖；
- 外观模式通过封装子系统，向上层模块提供统一的接口，从而降低的上层模块与子系统的过度耦合；
- 提高了灵活性；
- 提高安全性。
不符合开闭原则：在不对外观类进行抽象的时候，如果需要添加新的子系统，就需要对Facade类进行修改。
应用场景- 要为一个复杂的子系统对外提供一个简单的接口
- 提供子系统的独立性
- 客户程序与多个子系统之间存在很大的依赖性
引入外观类将子系统与客户以及其他子系统解耦，可以提高子系统的独立性和可移植性。
- 在层次化结构中，可以使用外观模式定义系统中每一层的入口
层与层之间不直接产生联系，而通过外观类建立联系，降低层之间的耦合度。
与适配器模式的区别外观模式的实现核心主要是：由外观类去保存各个子系统的引用，实现由一个统一的外观类去包装多个子系统类，然而客户端只需要引用这个外观类，然后由外观类来调用各个子系统中的方法。
这样的实现方式非常类似适配器模式，然而外观模式与适配器模式不同的是：适配器模式是将一个对象包装起来以改变其接口，而外观是将一群对象 ”包装“起来以简化其接口。它们的意图是不一样的，适配器是将接口转换为不同接口，而外观模式是提供一个统一的接口来简化接口。
源码中的应用#tomcat
org.apache.catalina.connector.requestFacade
org.apache.catalina.connector.ResponseFacade
#mybatis
Configuration
......
RequestFacade源码分析
Tomcat中门面模式使用的很多，因为Tomcat中有很多不同组件，每个组件要相互通信，但是又不能将自己的内部数据过多的暴露给其他组件。用门面模式隔离数据是很好的方法。
Tomcat 中 Request 除了实现了 servletRequest 接口外，还会有额外的一些函数，而这些函数需要被其他类调用，但这些方法不应该暴露给上层，因为上层应该专注于 ServletRequest 的实现。于是在 Tomcat 中会使用 Facade 模式了。
未使用 Facade 模式前如下：
未使用 Facade 模式前的 process 处理请求是这样的
publicclassServletProcess{
publicvoidprocess(Requestrequest Responseresponse){
//....
servlet=(Servlet)myClass.newInstance();
servlet.service((ServletRequest)request (ServletResponse)response);
}
}
而使用 Facade 模式之后如下：
而使用 Facade 后的 process 处理请求是这样的
publicclassServletProcess{
publicvoidprocess(Requestrequest Responseresponse){
//....
RequestFacaderequestFacade=newRequestFacade(request);
ResponseFacaderesponseFacade=newResponseFacade(response);
servlet=(Servlet)myClass.newInstance();
servlet.service((ServletRequest)requestFacade (ServletResponse)responseFacade);
}
}
为了达到这种效果，RequestFacade 使用了类似代理模式的实现方式。
publicclassRequestFacadeimplementsHttpServletRequest{
privateServletRequestrequest;
publicRequestFacade(ServletRequestrequest){
this.request=request;
}
@Override
publicStringgetAuthType(){
returnrequest.getAuthType();
}
}
对象里有个 ServletRequest 对象，而 RequestFacade 的所有方法都会委托给 ServletRequest 调用。
Configuration源码分析
由上面的类图可以看出，client只需要调用Configuration的newMetaObject(Object object)方法就可以得到一个MetaObject对象，而具体的对象是怎么生成与client无关，下面我们可以看一下Configuration的部分源码分析。
Configuration部分源码//Configuration类：
publicclassConfiguration{
protectedReflectorFactoryreflectorFactory=newDefaultReflectorFactory();
protectedObjectFactoryobjectFactory=newDefaultObjectFactory();
protectedObjectWrapperFactoryobjectWrapperFactory=newDefaultObjectWrapperFactory();
publicMetaObjectnewMetaObject(Objectobject){
returnMetaObject.forObject(object objectFactory objectWrapperFactory reflectorFactory);
}
}
//MetaObject类
publicclassMetaObject{
privateObjectoriginalObject;
privateObjectWrapperobjectWrapper;
privateObjectFactoryobjectFactory;
privateObjectWrapperFactoryobjectWrapperFactory;
privateReflectorFactoryreflectorFactory;
publicstaticMetaObjectforObject(Objectobject ObjectFactoryobjectFactory ObjectWrapperFactoryobjectWrapperFactory ReflectorFactoryreflectorFactory){
if(object==null){
returnSystemMetaObject.NULL_META_OBJECT;
}else{
returnnewMetaObject(object objectFactory objectWrapperFactory reflectorFactory);
}
}
privateMetaObject(Objectobject ObjectFactoryobjectFactory ObjectWrapperFactoryobjectWrapperFactory ReflectorFactoryreflectorFactory){
this.originalObject=object;
this.objectFactory=objectFactory;
this.objectWrapperFactory=objectWrapperFactory;
this.reflectorFactory=reflectorFactory;
if(objectinstanceofObjectWrapper){
this.objectWrapper=(ObjectWrapper)object;
}elseif(objectWrapperFactory.hasWrapperFor(object)){
this.objectWrapper=objectWrapperFactory.getWrapperFor(this object);
}elseif(objectinstanceofMap){
this.objectWrapper=newMapWrapper(this (Map)object);
}elseif(objectinstanceofCollection){
this.objectWrapper=newCollectionWrapper(this (Collection)object);
}else{
this.objectWrapper=newBeanWrapper(this object);
}
}
}
由上面的部分源码可以看出，客户端只需要调用Configuration的newMetaObject(Object object)方法，并传递一个Object参数，就可以获取对应的MetaObject，至于具体的产生什么样的MetaObject，则有MetaObject的类的forObject(object objectFactory objectWrapperFactory reflectorFactory)方法实现。
PS：以上代码提交在 Github ：
https://github.com/Niuh-Study/niuh-designpatterns.git
文章持续更新，可以公众号搜一搜「 一角钱技术 」第一时间阅读， 本文 GitHub org_hejianhui/JavaStudy 已经收录，欢迎 Star。
