前言
- 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类进行修改。
应用场景
- 要为一个复杂的子系统对外提供一个简单的接口
- 提供子系统的独立性
- 客户程序与多个子系统之间存在很大的依赖性
引入外观类将子系统与客户以及其他子系统解耦,可以提高子系统的独立性和可移植性。
- 在层次化结构中,可以使用外观模式定义系统中每一层的入口
层与层之间不直接产生联系,而通过外观类建立联系,降低层之间的耦合度。
与适配器模式的区别
外观模式的实现核心主要是:由外观类去保存各个子系统的引用,实现由一个统一的外观类去包装多个子系统类,然而客户端只需要引用这个外观类,然后由外观类来调用各个子系统中的方法。
这样的实现方式非常类似适配器模式,然而外观模式与适配器模式不同的是:适配器模式是将一个对象包装起来以改变其接口,而外观是将一群对象 ”包装“起来以简化其接口。它们的意图是不一样的,适配器是将接口转换为不同接口,而外观模式是提供一个统一的接口来简化接口。
源码中的应用
- #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 处理请求是这样的
- 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