前言
- 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("子系统方法四");
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
步骤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();
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
步骤3:验证输出结果
/**
* 外观/门面模式
*/
public class FacadePattern {
public static void main(String[] args) {
Facade facade = new Facade();
facade.MethodA();
facade.MethodB();
System.out.println("----over----");
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
输出如下:
方法组A()----
子系统方法一
子系统方法二
子系统方法四
方法组B()----
子系统方法二
子系统方法三
----over----
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
优点
- 减少系统的相互依赖;
- 外观模式通过封装子系统,向上层模块提供统一的接口,从而降低的上层模块与子系统的过度耦合;
- 提高了灵活性;
- 提高安全性。
缺点
不符合开闭原则:在不对外观类进行抽象的时候,如果需要添加新的子系统,就需要对Facade类进行修改。
应用场景
- 要为一个复杂的子系统对外提供一个简单的接口
- 提供子系统的独立性
- 客户程序与多个子系统之间存在很大的依赖性
引入外观类将子系统与客户以及其他子系统解耦,可以提高子系统的独立性和可移植性。
- 在层次化结构中,可以使用外观模式定义系统中每一层的入口
层与层之间不直接产生联系,而通过外观类建立联系,降低层之间的耦合度。
与适配器模式的区别
外观模式的实现核心主要是:由外观类去保存各个子系统的引用,实现由一个统一的外观类去包装多个子系统类,然而客户端只需要引用这个外观类,然后由外观类来调用各个子系统中的方法。
这样的实现方式非常类似适配器模式,然而外观模式与适配器模式不同的是:适配器模式是将一个对象包装起来以改变其接口,而外观是将一群对象 ”包装“起来以简化其接口。它们的意图是不一样的,适配器是将接口转换为不同接口,而外观模式是提供一个统一的接口来简化接口。
源码中的应用
#tomcat
org.apache.catalina.connector.RequestFacade
org.apache.catalina.connector.ResponseFacade
#mybatis
Configuration
......
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
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);
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
而使用 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);
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
为了达到这种效果,RequestFacade 使用了类似代理模式的实现方式。
public class RequestFacade implements HttpServletRequest {
private ServletRequest request;
public RequestFacade(ServletRequest request) {
this.request = request;
}
@Override
public String getAuthType() {
return request.getAuthType();
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
对象里有个 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);
}
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
由上面的部分源码可以看出,客户端只需要调用Configuration的newMetaObject(Object object)方法,并传递一个Object参数,就可以获取对应的MetaObject,至于具体的产生什么样的MetaObject,则有MetaObject的类的forObject(object, objectFactory, objectWrapperFactory, reflectorFactory)方法实现。
PS:以上代码提交在 Github :
https://github.com/Niuh-Study/niuh-designpatterns.git