前言
- 23种设计模式速记
- 单例(singleton)模式
- 工厂方法(factory method)模式
- 抽象工厂(abstract factory)模式
- 建造者/构建器(builder)模式
- 原型(prototype)模式
- 享元(flyweight)模式
- 持续更新中......
23种设计模式快速记忆的请看上面第一篇,本篇和大家一起来学习外观(门面)模式相关内容,外观模式一定是我们平常使用最多的一种。
总体概览
模式定义
为子系统中的一组接口提供一个一致的接口,Facade 模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
通过创建一个统一的外观类,用来包装子系统中一个 / 多个复杂的类,客户端可通过调用外观类的方法来调用内部子系统中所有方法。
解决的问题
- 避免了系统与系统之间的高耦合度
- 使得复杂的子系统用法变得简单
实例说明
步骤1:定义subsystem角色
class SubSystemOne { public void methodOne() { System.out.println("子系统方法一"); }}class SubSystemTwo { public void methodTwo() { System.out.println("子系统方法二"); }}class SubSystemThree { public void methodThree() { System.out.println("子系统方法三"); }}class SubSystemFour { public void methodFour() { System.out.println("子系统方法四"); }}
步骤2:定义Facade角色
class Facade { SubSystemOne one; SubSystemTwo two; SubSystemThree three; SubSystemFour four; public Facade() { this.one = new SubSystemOne(); this.two = new SubSystemTwo(); this.three = new SubSystemThree(); this.four = new SubSystemFour(); } public void MethodA() { System.out.println("方法组A()----"); one.methodOne(); two.methodTwo(); four.methodFour(); } public void MethodB() { System.out.println("方法组B()----"); two.methodTwo(); three.methodThree(); }}
步骤3:验证输出结果
/** * 外观/门面模式 */public class FacadePattern { public static void main(String[] args) { Facade facade = new Facade(); facade.MethodA(); facade.MethodB(); System.out.println("----over----"); }}
输出如下:
方法组A()----子系统方法一子系统方法二子系统方法四方法组B()----子系统方法二子系统方法三----over----
优点
- 减少系统的相互依赖;
- 外观模式通过封装子系统,向上层模块提供统一的接口,从而降低的上层模块与子系统的过度耦合;
- 提高了灵活性;
- 提高安全性。
缺点
不符合开闭原则:在不对外观类进行抽象的时候,如果需要添加新的子系统,就需要对Facade类进行修改。
应用场景
- 要为一个复杂的子系统对外提供一个简单的接口
- 提供子系统的独立性
- 客户程序与多个子系统之间存在很大的依赖性
引入外观类将子系统与客户以及其他子系统解耦,可以提高子系统的独立性和可移植性。
- 在层次化结构中,可以使用外观模式定义系统中每一层的入口
层与层之间不直接产生联系,而通过外观类建立联系,降低层之间的耦合度。
与适配器模式的区别
外观模式的实现核心主要是:由外观类去保存各个子系统的引用,实现由一个统一的外观类去包装多个子系统类,然而客户端只需要引用这个外观类,然后由外观类来调用各个子系统中的方法。
这样的实现方式非常类似适配器模式,然而外观模式与适配器模式不同的是:适配器模式是将一个对象包装起来以改变其接口,而外观是将一群对象 ”包装“起来以简化其接口。它们的意图是不一样的,适配器是将接口转换为不同接口,而外观模式是提供一个统一的接口来简化接口。
源码中的应用
#tomcatorg.apache.catalina.connector.RequestFacadeorg.apache.catalina.connector.ResponseFacade#mybatisConfiguration......
RequestFacade源码分析
Tomcat中门面模式使用的很多,因为Tomcat中有很多不同组件,每个组件要相互通信,但是又不能将自己的内部数据过多的暴露给其他组件。用门面模式隔离数据是很好的方法。
Tomcat 中 Request 除了实现了 ServletRequest 接口外,还会有额外的一些函数,而这些函数需要被其他类调用,但这些方法不应该暴露给上层,因为上层应该专注于 ServletRequest 的实现。于是在 Tomcat 中会使用 Facade 模式了。
未使用 Facade 模式前如下:
未使用 Facade 模式前的 process 处理请求是这样的
public class ServletProcess { public void process(Request request, Response response){ //.... servlet = (Servlet) myClass.newInstance(); servlet.service((ServletRequest) request, (ServletResponse) response); }}
而使用 Facade 模式之后如下:
而使用 Facade 后的 process 处理请求是这样的
public class ServletProcess { public void process(Request request, Response response){ //.... RequestFacade requestFacade = new RequestFacade(request); ResponseFacade responseFacade = new ResponseFacade(response); servlet = (Servlet) myClass.newInstance(); servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade); }}
为了达到这种效果,RequestFacade 使用了类似代理模式的实现方式。
public class RequestFacade implements HttpServletRequest { private ServletRequest request; public RequestFacade(ServletRequest request) { this.request = request; } @Override public String getAuthType() { return request.getAuthType(); }}
对象里有个 ServletRequest 对象,而 RequestFacade 的所有方法都会委托给 ServletRequest 调用。
Configuration源码分析
由上面的类图可以看出,client只需要调用Configuration的newMetaObject(Object object)方法就可以得到一个MetaObject对象,而具体的对象是怎么生成与client无关,下面我们可以看一下Configuration的部分源码分析。
Configuration部分源码
//Configuration 类:public class Configuration { protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory(); protected ObjectFactory objectFactory = new DefaultObjectFactory(); protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory(); public MetaObject newMetaObject(Object object) { return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory); }}//MetaObject类public class MetaObject { private Object originalObject; private ObjectWrapper objectWrapper; private ObjectFactory objectFactory; private ObjectWrapperFactory objectWrapperFactory; private ReflectorFactory reflectorFactory; public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) { if (object == null) { return SystemMetaObject.NULL_META_OBJECT; } else { return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory); } } private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) { this.originalObject = object; this.objectFactory = objectFactory; this.objectWrapperFactory = objectWrapperFactory; this.reflectorFactory = reflectorFactory; if (object instanceof ObjectWrapper) { this.objectWrapper = (ObjectWrapper) object; } else if (objectWrapperFactory.hasWrapperFor(object)) { this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object); } else if (object instanceof Map) { this.objectWrapper = new MapWrapper(this, (Map) object); } else if (object instanceof Collection) { this.objectWrapper = new CollectionWrapper(this, (Collection) object); } else { this.objectWrapper = new BeanWrapper(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。