设计模式学习笔记 - 外观模式

 

一、影院管理问题

 
组建一个家庭影院：DVD 播放器、投影仪、自动屏幕、环绕立体声、爆米花机。要求完成使用家庭影院的功能，其过程为直接用遥控器统筹各设备开关：

1.打开爆米花机
2.放下屏幕
3.打开投影仪
4.打开音响
5.打开DVD，选dvd
6.去拿爆米花
7.调暗灯光
8.播放dvd
9.观影结束后，关闭各种设备

 

二、传统方式解决影院管理问题

 

• 类图：
  

• 传统方式解决影院管理问题分析：
  （1）在 Client的main方法中，创建各个子系统的对象，并直接去调用子系统（对象）相关方法，会造成调用过程混乱，没有清晰的过程。在Client中不利于去维护对子系统的操作。
  （2）解决思路：定义一个高层接口，给子系统中的一组接口提供一个一致的界面（比如在高层接口中提供四个方法on、play、pause、off），用来访问子系统中的一群接口。也就是说，通过定义一个一致的接口（界面类），用以屏蔽内部子系统的细节，使得调用端只需跟这个一致的接口发生调用，而无需关心这个子系统的内部细节。这就是使用了外观模式。
   

三、外观模式介绍

 

1、基本介绍

 
外观模式（Facade Pattern），也叫“过程模式”。外观模式为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

外观模式通过定义一个一致的接口，用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节。

外观模式可以理解为转换一群接口，客户只要调用一个接口，而不用调用多个接口才能达到目的。

外观模式就是解决多个复杂接口带来的使用困难，起到简化用户操作的作用。

 

2、原理类图

 

说明：

• 外观类（Facade）：为调用端提供统一的调用接口，外观类知道哪些子系统负责处理请求，从而将调用端的请求代理给适当子系统对象。
• 子系统的集合：指模块或者子系统，处理Facade对象指派的任务，是功能实际提供者。
• 调用者（Client）：外观接口的调用者。
   

四、外观模式解决影院管理问题

 

• 类图：
  

• 实现代码：

package com.etc.design.facade;

public class Client {
	public static void main(String[] args) {
		// 使用外观类实现过程
		HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
		// 开启所有设备
		homeTheaterFacade.ready();
		// DVD播放
		homeTheaterFacade.play();
		// DVD暂停
		homeTheaterFacade.pause();
		// 关闭所有设备
		homeTheaterFacade.end();
	}
}

package com.etc.design.facade;

/**
 * 外观类
 */
public class HomeTheaterFacade {
	//定义各个子系统对象
	private TheaterLight theaterLight;
	private Popcorn popcorn;
	private Stereo stereo;
	private Projector projector;
	private Screen screen;
	private DVDPlayer dVDPlayer;

	//构造器
	public HomeTheaterFacade() {
		super();
		this.theaterLight = TheaterLight.getInstance();
		this.popcorn = Popcorn.getInstance();
		this.stereo = Stereo.getInstance();
		this.projector = Projector.getInstance();
		this.screen = Screen.getInstance();
		this.dVDPlayer = DVDPlayer.getInstanc();
	}

	// 操作分成4步
	public void ready() {
		System.out.println("-----开启所有设备-----");
		popcorn.on();
		popcorn.pop();
		screen.down();
		projector.on();
		stereo.on();
		dVDPlayer.on();
		theaterLight.dim();
	}

	public void play() {
		System.out.println("-----播放DVD-----");
		dVDPlayer.play();
	}

	public void pause() {
		System.out.println("-----暂停DVD-----");
		dVDPlayer.pause();
	}

	public void end() {
		System.out.println("-----关闭所有设备-----");
		popcorn.off();
		theaterLight.bright();
		screen.up();
		projector.off();
		stereo.off();
		dVDPlayer.off();
	}
}

package com.etc.design.facade;

public class DVDPlayer {
	// 使用用饿汉单例模式
	private static DVDPlayer instance = new DVDPlayer();
	
	public static DVDPlayer getInstanc() {
		return instance;
	}
	
	public void on() {
		System.out.println(" DVD on ");
	}

	public void off() {
		System.out.println(" DVD off ");
	}
	
	public void play() {
		System.out.println(" DVD play ");
	}

	public void pause() {
		System.out.println(" DVD pause ");
	}
}

package com.etc.design.facade;

public class Popcorn {
	// 使用用饿汉单例模式
	private static Popcorn instance = new Popcorn();
	
	public static Popcorn getInstance() {
		return instance;
	}
	
	public void on() {
		System.out.println(" popcorn on ");
	}
	
	public void off() {
		System.out.println(" popcorn ff ");
	}
	
	public void pop() {
		System.out.println(" popcorn is poping  ");
	}
}

package com.etc.design.facade;

public class Projector {
	// 使用用饿汉单例模式
	private static Projector instance = new Projector();
	
	public static Projector getInstance() {
		return instance;
	}
	
	public void on() {
		System.out.println(" Projector on ");
	}
	
	public void off() {
		System.out.println(" Projector ff ");
	}
	
	public void focus() {
		System.out.println(" Projector is Projector  ");
	}
}

package com.etc.design.facade;

public class Screen {
	// 使用用饿汉单例模式
	private static Screen instance = new Screen();
	
	public static Screen getInstance() {
		return instance;
	}
	
	public void up() {
		System.out.println(" Screen up ");
	}
	
	public void down() {
		System.out.println(" Screen down ");
	}
}

package com.etc.design.facade;

public class Stereo {
	// 使用用饿汉单例模式
	private static Stereo instance = new Stereo();
	
	public static Stereo getInstance() {
		return instance;
	}
	
	public void on() {
		System.out.println(" Stereo on ");
	}
	
	public void off() {
		System.out.println(" Stereo off ");
	}
	
	public void up() {
		System.out.println(" Stereo up ");
	}

	public void down() {
		System.out.println(" Stereo down ");
	}
}

package com.etc.design.facade;

public class TheaterLight {
	// 使用用饿汉单例模式
	private static TheaterLight instance = new TheaterLight();

	public static TheaterLight getInstance() {
		return instance;
	}

	public void on() {
		System.out.println(" TheaterLight on ");
	}

	public void off() {
		System.out.println(" TheaterLight off ");
	}

	public void dim() {
		System.out.println(" TheaterLight dim ");
	}

	public void bright() {
		System.out.println(" TheaterLight bright ");
	}
}

 

五、外观模式在MyBatis框架应用的源码分析

 
MyBatis中的Configuration去创建MetaObject对象使用到外观模式。

• 类图：

• 源码：

package org.apache.ibatis.session;
......
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);
	}
    ......
}

package org.apache.ibatis.reflection;
......
public class MetaObject {
	private Object originalObject;
	private ObjectWrapper objectWrapper;
	private ObjectFactory objectFactory;
	private ObjectWrapperFactory objectWrapperFactory;
	private ReflectorFactory 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);
		}
	}
  	......
  	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);
    	}
  	}
  	......
}

package org.apache.ibatis.reflection.factory;

public interface ObjectFactory {
	......
}

package org.apache.ibatis.reflection.factory;

public class DefaultObjectFactory implements ObjectFactory, Serializable {
	......
}

package org.apache.ibatis.reflection.wrapper;

public interface ObjectWrapperFactory {
	......
}

package org.apache.ibatis.reflection.wrapper;

public class DefaultObjectWrapperFactory implements ObjectWrapperFactory {
	......
}

 

六、外观模式的注意事项和细节

 
（1）外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复杂性。
（2）外观模式对客户端与子系统的耦合关系进行解耦，让子系统内部的模块更易维护和扩展。
（3）通过合理的使用外观模式，可以更好的划分访问的层次。
（4）当系统需要进行分层设计时，可以考虑使用外观模式。
（5）在维护一个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时可以考虑为新系统开发一个Facade类，来提供遗留系统的比较清晰简单的接口，让新系统与Facade类交互，提高复用性。
（6）不能过多的或者不合理的使用外观模式。如果子系统模块过于复杂，可以使用外观模式进行分层。如果子系统模块比较简单，可以直接调用模块。要以让系统有层次，利于维护为目的。