外观模式
例子
影院管理项目
组建一个家庭影院：
DVD播放器、投影仪、自动屏幕、环绕立体声、爆米花机,要求完成使用家庭影院的
功能，其过程为：
• 直接用遥控器：统筹各设备开关
• 开爆米花机
• 放下屏幕
• 开投影仪
• 开音响
• 开DVD，选dvd
• 去拿爆米花
• 调暗灯光
• 播放
• 观影结束后，关闭各种设备
传统方式：ClientTest类直接使用各个子系统
传统解决的问题
传统方式解决影院管理问题分析
- 在ClientTest 的main方法中，创建各个子系统的对象，并直接去调用子系统(对象)
相关方法，会造成调用过程混乱，没有清晰的过程 - 不利于在ClientTest 中，去维护对子系统的操作
- 解决思路： 定义一个高层接口，
- 给子系统中的一组接口提供一个一致的界面(比
如在高层接口提供四个方法 ready, play, pause, end )， - 用来访问子系统中的一群接口
- 也就是说 就是通过定义一个一致的接口(界面类)， 用以屏蔽内部子系统的细节，
使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节 => 外观
模式
基本介绍
- 外观模式（Facade）， 也叫“过程模式：外观模式
-
为子系统中的一组接口提供
一个一致的界面， -
此模式定义了一个高层接口，这个接口使得这一子系统更加
容易使用
- 外观模式通过定义一个一致的接口，
- 用以屏蔽内部子系统的细节，
- 使得调用端只需跟这个接口发生调用，
- 而无需关心这个子系统的内部细节
组成
- 外观类(Facade): 为调用端提供统一的调用接口, 外观类知道哪些子系统负责处理请求,从而将调用端的请求代理给适当
子系统对象 - 调用者(Client): 外观接口的调用者
- 子系统的集合：指模块或者子系统，处理Facade 对象指派的任务，他是功能的实际提供者
理解
- 外观模式可以理解为转换一群接口，客户只
要调用一个接口，而不用调用多个接口才能
达到目的。 比如：在pc上安装软件的时候经
常有一键安装选项（省去选择安装目录、安
装的组件等等），还有就是手机的重启功能
（把关机和启动合为一个操作）。 - 外观模式就是解决多个复杂接口带来的使用
困难，起到简化用户操作的作用
外观类 和 使用
- 提供 几个整合的方法
public class HomeTheaterFacade {
//定义各个子系统对象
private Popcorn popcorn;
private DVDPlayer dVDPlayer;
//构造器
public HomeTheaterFacade() {
super();
this.popcorn = Popcorn.getInstance();
this.dVDPlayer = DVDPlayer.getInstanc();
}
//操作分成 4 步
public void ready() {
//打开，并制作爆米花
popcorn.on();
popcorn.pop();
//打开 DVD
dVDPlayer.on();
}
public void play() {
dVDPlayer.play();
}
public void pause() {
dVDPlayer.pause();
}
//关闭 爆米花 和 DVD
public void end() {
popcorn.off();
dVDPlayer.off();
}
}
HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
homeTheaterFacade.ready();
homeTheaterFacade.play();
homeTheaterFacade.end();
单例类 爆米花
- DVD
- 投影仪
- 屏幕 升降
- 立体声
- 灯管
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 ");
}
}
MyBatis
- Client用 直接用 Configuration
- 外观模式在MyBatis框架应用的源码分析
- MyBatis 中的Configuration 去创建MetaObject 对象使用到外观模式
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 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) {
//ObjectWrapper
this.objectWrapper = (ObjectWrapper) object;
} else if (objectWrapperFactory.hasWrapperFor(object)) {
//Wrapper
this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
} else if (object instanceof Map) {
//Map
this.objectWrapper = new MapWrapper(this, (Map) object);
} else if (object instanceof Collection) {
//Collection
this.objectWrapper = new CollectionWrapper(this, (Collection) object);
} else {
this.objectWrapper = new BeanWrapper(this, object);
}
}
注释事项
外观模式的注意事项和细节
- 外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复
杂性 - 外观模式对客户端与子系统的耦合关系，让子系统内部的模块更易维护和扩展
- 通过合理的使用外观模式，可以帮我们更好的划分访问的层次
- 当系统需要进行分层设计时， 可以考虑使用Facade模式
- 在维护一个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时
可以考虑为新系统开发一个Facade类，来提供遗留系统的比较清晰简单的接口，
让新系统与Facade类交互， 提高复用性 - 不能过多的或者不合理的使用外观模式，使用外观模式好， 还是直接调用模块好。
要以让系统有层次，利于维护为目的。
享元模式
- 共享
- 元：就是对象
提出问题
小型的外包项目，给客户A做一个产品展示网站， 客户A的朋友感觉效果不错，也希
望做这样的产品展示网站，但是要求都有些不同：
- 有客户要求以新闻的形式发布
- 有客户人要求以博客的形式发布
- 有客户希望以微信公众号的形式发布
传统方案解决网站展现项目
- 直接复制粘贴一份，然后根据客户不同要求，进行定制修改
- 给每个网站租用一个空间
传统方案解决网站展现项目-问题分析
- 需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来
处理，相当于一个相同网站的实例对象很多，造成服务器的资源浪费 - 解决思路：整合到一个网站中，共享其相关的代码和数据，对于硬盘、内存、 CPU、
数据库空间等服务器资源都可以达成共享，减少服务器资源 - 对于代码来说， 由于是一份实例，维护和扩展都更加容易
- 上面的解决思路就可以使用 享元模式 来解决
- String
- 数据库，连接池 技术
基本介绍
- 享元模式（Flyweight Pattern） 也叫 蝇量模式: 运
用共享技术有效地支持大量细粒度的对象 - 常用于系统底层开发，解决系统的性能问题。像
数据库连接池，里面都是创建好的连接对象，在
这些连接对象中有我们需要的则直接拿来用，避
免重新创建， 如果没有我们需要的，则创建一个 - 享元模式能够解决重复对象的内存浪费的问题，
当系统中有大量相似对象，需要缓冲池时。 不需
总是创建新对象，可以从缓冲池里拿。这样可以
降低系统内存，同时提高效率 - 享元模式经典的应用场景就是池技术了， String常
量池、数据库连接池、缓冲池等等都是享元模式
的应用，享元模式是池技术的重要实现方式
String s = “hello”;
String s2 = new String(“hello”);
- 有一个棋盘，其他人都要下棋，没必要没人都创建一个 棋盘，棋子对象。
- 棋子的位置：外部状态。
- 棋子的颜色：内部状态。
- FlyWeight 是抽象的享元角色, 他是产品的抽象类, 同时定义出对象的外部状态和内部状态(后面介绍) 的接口或实现
- ConcreteFlyWeight 是具体的享元角色，是具体的产品类，实现抽象角色定义相关业务
- UnShared ConcreteFlyWeight 是不可共享的角色 ,一般不会出现 在 享元工厂。
4）FlyWeight Factory 享元工厂类，用于构建 一个池容器（集合），同时提供从 池中 获取对象方法。
内外部状态
内部状态和外部状态
比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色多一
点，所以棋子颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，当我们落子后，
落子颜色是定的，但位置是变化的，所以棋子坐标就是棋子的外部状态
- 享元模式提出了两个要求：细粒度和共享对象。这里就涉及到内部状态和外部状态
了，即将对象的信息分为两个部分： 内部状态和外部状态 - 内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变
- 外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。
- 举个例子：围棋理论上有361个空位可以放棋子，每盘棋都有可能有两三百个棋子对
象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用
享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解
决了对象的开销问题
抽象方法 和 实现
public abstract class WebSite {
public abstract void use(User user);//抽象方法
}
//外部状态
public class User {
private String name;
}
public class ConcreteWebSite extends WebSite {
//共享的部分，内部状态
private String type = ""; //网站发布的形式(类型)
//构造器
public ConcreteWebSite(String type) {
this.type = type;
}
@Override
public void use(User user) {
System.out.println("网站的发布形式为:" + type + " 在使用中 .. 使用者是" + user.getName());
}
}
网站工厂类
// 网站工厂类，根据需要返回压一个网站
public class WebSiteFactory {
//集合， 充当池的作用
private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
//根据网站的类型，返回一个网站, 如果没有就创建一个网站，并放入到池中,并返回
public WebSite getWebSiteCategory(String type) {
if(!pool.containsKey(type)) {
//就创建一个网站，并放入到池中
pool.put(type, new ConcreteWebSite(type));
}
return (WebSite)pool.get(type);
}
//获取网站分类的总数 (池中有多少个网站类型)
public int getWebSiteCount() {
return pool.size();
}
}
测试
// 创建一个工厂类
WebSiteFactory factory = new WebSiteFactory();
// 客户要一个以新闻形式发布的网站
WebSite webSite1 = factory.getWebSiteCategory("新闻");
webSite1.use(new User("tom"));
//多个人使用，同一个模板，只有一份
Integer
- Integer.valueOf 使用了 享元模式
Integer x = Integer.valueOf(127);
Integer y = new Integer(127); //废弃
Integer z = Integer.valueOf(127);
Integer w = new Integer(127); //废弃
System.out.println(x.equals(y)); // ? 值比较为true
System.out.println(x == y ); // ? 对象比较为 false
System.out.println(x == z ); // ? 同样：Integer.valueOf 为true
System.out.println(w == x ); // ? 和 new相比，为false
System.out.println(w == y ); // ? new 的== 相比为 false
- range -128 to 127，从缓存中拿，执行速度更快。否则：就创建新对象。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer[] cache;
static Integer[] archivedCache;
static {
// high value may be configured by property
int h = 127;
high = h;
//127 - -128 + 1 为 256个数据。因为是索引，所以 257个
//IntegerCache.cache[i + (-IntegerCache.low)]
// i为 -5， -5 + 128，为123位置，索引的话，是122
int size = (high - low) + 1;
// Use the archived cache if it exists and is large enough
if (archivedCache == null || size > archivedCache.length) {
Integer[] c = new Integer[size];
int j = low;
for(int i = 0; i < c.length; i++) {
c[i] = new Integer(j++);
}
archivedCache = c;
}
cache = archivedCache;
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
注意事项
享元模式的注意事项和细节
- 在享元模式这样理解，“享”就表示共享，“元”表示对象
- 系统中有大量对象， 这些对象消耗大量内存， 并且对象的状态大部分可以外部化时，
我们就可以考虑选用享元模式 - 用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用
HashMap/HashTable存储 - 享元模式大大减少了对象的创建，降低了程序内存的占用，提高效率
- 享元模式提高了系统的复杂度。需要分离出内部状态和外部状态，而外部状态具有
固化特性，不应该随着内部状态的改变而改变，这是我们使用享元模式需要注意的
地方. - 使用享元模式时，注意划分内部状态和外部状态，并且需要有一个工厂类加以控制。
- 享元模式经典的应用场景是需要缓冲池的场景，比如 String常量池、 数据库连接池
外观模式
例子
影院管理项目
组建一个家庭影院：
DVD播放器、投影仪、自动屏幕、环绕立体声、爆米花机,要求完成使用家庭影院的
功能，其过程为：
• 直接用遥控器：统筹各设备开关
• 开爆米花机
• 放下屏幕
• 开投影仪
• 开音响
• 开DVD，选dvd
• 去拿爆米花
• 调暗灯光
• 播放
• 观影结束后，关闭各种设备
传统方式：ClientTest类直接使用各个子系统
传统解决的问题
传统方式解决影院管理问题分析
- 在ClientTest 的main方法中，创建各个子系统的对象，并直接去调用子系统(对象)
相关方法，会造成调用过程混乱，没有清晰的过程 - 不利于在ClientTest 中，去维护对子系统的操作
- 解决思路： 定义一个高层接口，
- 给子系统中的一组接口提供一个一致的界面(比
如在高层接口提供四个方法 ready, play, pause, end )， - 用来访问子系统中的一群接口
- 也就是说 就是通过定义一个一致的接口(界面类)， 用以屏蔽内部子系统的细节，
使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节 => 外观
模式
基本介绍
- 外观模式（Facade）， 也叫“过程模式：外观模式
-
为子系统中的一组接口提供
一个一致的界面， -
此模式定义了一个高层接口，这个接口使得这一子系统更加
容易使用
- 外观模式通过定义一个一致的接口，
- 用以屏蔽内部子系统的细节，
- 使得调用端只需跟这个接口发生调用，
- 而无需关心这个子系统的内部细节
组成
- 外观类(Facade): 为调用端提供统一的调用接口, 外观类知道哪些子系统负责处理请求,从而将调用端的请求代理给适当
子系统对象 - 调用者(Client): 外观接口的调用者
- 子系统的集合：指模块或者子系统，处理Facade 对象指派的任务，他是功能的实际提供者
理解
- 外观模式可以理解为转换一群接口，客户只
要调用一个接口，而不用调用多个接口才能
达到目的。 比如：在pc上安装软件的时候经
常有一键安装选项（省去选择安装目录、安
装的组件等等），还有就是手机的重启功能
（把关机和启动合为一个操作）。 - 外观模式就是解决多个复杂接口带来的使用
困难，起到简化用户操作的作用
外观类 和 使用
- 提供 几个整合的方法
public class HomeTheaterFacade {
//定义各个子系统对象
private Popcorn popcorn;
private DVDPlayer dVDPlayer;
//构造器
public HomeTheaterFacade() {
super();
this.popcorn = Popcorn.getInstance();
this.dVDPlayer = DVDPlayer.getInstanc();
}
//操作分成 4 步
public void ready() {
//打开，并制作爆米花
popcorn.on();
popcorn.pop();
//打开 DVD
dVDPlayer.on();
}
public void play() {
dVDPlayer.play();
}
public void pause() {
dVDPlayer.pause();
}
//关闭 爆米花 和 DVD
public void end() {
popcorn.off();
dVDPlayer.off();
}
}
HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
homeTheaterFacade.ready();
homeTheaterFacade.play();
homeTheaterFacade.end();
单例类 爆米花
- DVD
- 投影仪
- 屏幕 升降
- 立体声
- 灯管
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 ");
}
}
MyBatis
- Client用 直接用 Configuration
- 外观模式在MyBatis框架应用的源码分析
- MyBatis 中的Configuration 去创建MetaObject 对象使用到外观模式
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 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) {
//ObjectWrapper
this.objectWrapper = (ObjectWrapper) object;
} else if (objectWrapperFactory.hasWrapperFor(object)) {
//Wrapper
this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
} else if (object instanceof Map) {
//Map
this.objectWrapper = new MapWrapper(this, (Map) object);
} else if (object instanceof Collection) {
//Collection
this.objectWrapper = new CollectionWrapper(this, (Collection) object);
} else {
this.objectWrapper = new BeanWrapper(this, object);
}
}
注释事项
外观模式的注意事项和细节
- 外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复
杂性 - 外观模式对客户端与子系统的耦合关系，让子系统内部的模块更易维护和扩展
- 通过合理的使用外观模式，可以帮我们更好的划分访问的层次
- 当系统需要进行分层设计时， 可以考虑使用Facade模式
- 在维护一个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时
可以考虑为新系统开发一个Facade类，来提供遗留系统的比较清晰简单的接口，
让新系统与Facade类交互， 提高复用性 - 不能过多的或者不合理的使用外观模式，使用外观模式好， 还是直接调用模块好。
要以让系统有层次，利于维护为目的。
享元模式
- 共享
- 元：就是对象
提出问题
小型的外包项目，给客户A做一个产品展示网站， 客户A的朋友感觉效果不错，也希
望做这样的产品展示网站，但是要求都有些不同：
- 有客户要求以新闻的形式发布
- 有客户人要求以博客的形式发布
- 有客户希望以微信公众号的形式发布
传统方案解决网站展现项目
- 直接复制粘贴一份，然后根据客户不同要求，进行定制修改
- 给每个网站租用一个空间
传统方案解决网站展现项目-问题分析
- 需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来
处理，相当于一个相同网站的实例对象很多，造成服务器的资源浪费 - 解决思路：整合到一个网站中，共享其相关的代码和数据，对于硬盘、内存、 CPU、
数据库空间等服务器资源都可以达成共享，减少服务器资源 - 对于代码来说， 由于是一份实例，维护和扩展都更加容易
- 上面的解决思路就可以使用 享元模式 来解决
- String
- 数据库，连接池 技术
基本介绍
- 享元模式（Flyweight Pattern） 也叫 蝇量模式: 运
用共享技术有效地支持大量细粒度的对象 - 常用于系统底层开发，解决系统的性能问题。像
数据库连接池，里面都是创建好的连接对象，在
这些连接对象中有我们需要的则直接拿来用，避
免重新创建， 如果没有我们需要的，则创建一个 - 享元模式能够解决重复对象的内存浪费的问题，
当系统中有大量相似对象，需要缓冲池时。 不需
总是创建新对象，可以从缓冲池里拿。这样可以
降低系统内存，同时提高效率 - 享元模式经典的应用场景就是池技术了， String常
量池、数据库连接池、缓冲池等等都是享元模式
的应用，享元模式是池技术的重要实现方式
String s = “hello”;
String s2 = new String(“hello”);
- 有一个棋盘，其他人都要下棋，没必要没人都创建一个 棋盘，棋子对象。
- 棋子的位置：外部状态。
- 棋子的颜色：内部状态。
- FlyWeight 是抽象的享元角色, 他是产品的抽象类, 同时定义出对象的外部状态和内部状态(后面介绍) 的接口或实现
- ConcreteFlyWeight 是具体的享元角色，是具体的产品类，实现抽象角色定义相关业务
- UnShared ConcreteFlyWeight 是不可共享的角色 ,一般不会出现 在 享元工厂。
4）FlyWeight Factory 享元工厂类，用于构建 一个池容器（集合），同时提供从 池中 获取对象方法。
内外部状态
内部状态和外部状态
比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色多一
点，所以棋子颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，当我们落子后，
落子颜色是定的，但位置是变化的，所以棋子坐标就是棋子的外部状态
- 享元模式提出了两个要求：细粒度和共享对象。这里就涉及到内部状态和外部状态
了，即将对象的信息分为两个部分： 内部状态和外部状态 - 内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变
- 外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。
- 举个例子：围棋理论上有361个空位可以放棋子，每盘棋都有可能有两三百个棋子对
象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用
享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解
决了对象的开销问题
抽象方法 和 实现
public abstract class WebSite {
public abstract void use(User user);//抽象方法
}
//外部状态
public class User {
private String name;
}
public class ConcreteWebSite extends WebSite {
//共享的部分，内部状态
private String type = ""; //网站发布的形式(类型)
//构造器
public ConcreteWebSite(String type) {
this.type = type;
}
@Override
public void use(User user) {
System.out.println("网站的发布形式为:" + type + " 在使用中 .. 使用者是" + user.getName());
}
}
网站工厂类
// 网站工厂类，根据需要返回压一个网站
public class WebSiteFactory {
//集合， 充当池的作用
private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
//根据网站的类型，返回一个网站, 如果没有就创建一个网站，并放入到池中,并返回
public WebSite getWebSiteCategory(String type) {
if(!pool.containsKey(type)) {
//就创建一个网站，并放入到池中
pool.put(type, new ConcreteWebSite(type));
}
return (WebSite)pool.get(type);
}
//获取网站分类的总数 (池中有多少个网站类型)
public int getWebSiteCount() {
return pool.size();
}
}
测试
// 创建一个工厂类
WebSiteFactory factory = new WebSiteFactory();
// 客户要一个以新闻形式发布的网站
WebSite webSite1 = factory.getWebSiteCategory("新闻");
webSite1.use(new User("tom"));
//多个人使用，同一个模板，只有一份
Integer
- Integer.valueOf 使用了 享元模式
Integer x = Integer.valueOf(127);
Integer y = new Integer(127); //废弃
Integer z = Integer.valueOf(127);
Integer w = new Integer(127); //废弃
System.out.println(x.equals(y)); // ? 值比较为true
System.out.println(x == y ); // ? 对象比较为 false
System.out.println(x == z ); // ? 同样：Integer.valueOf 为true
System.out.println(w == x ); // ? 和 new相比，为false
System.out.println(w == y ); // ? new 的== 相比为 false
- range -128 to 127，从缓存中拿，执行速度更快。否则：就创建新对象。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer[] cache;
static Integer[] archivedCache;
static {
// high value may be configured by property
int h = 127;
high = h;
//127 - -128 + 1 为 256个数据。因为是索引，所以 257个
//IntegerCache.cache[i + (-IntegerCache.low)]
// i为 -5， -5 + 128，为123位置，索引的话，是122
int size = (high - low) + 1;
// Use the archived cache if it exists and is large enough
if (archivedCache == null || size > archivedCache.length) {
Integer[] c = new Integer[size];
int j = low;
for(int i = 0; i < c.length; i++) {
c[i] = new Integer(j++);
}
archivedCache = c;
}
cache = archivedCache;
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
注意事项
享元模式的注意事项和细节
- 在享元模式这样理解，“享”就表示共享，“元”表示对象
- 系统中有大量对象， 这些对象消耗大量内存， 并且对象的状态大部分可以外部化时，
我们就可以考虑选用享元模式 - 用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用
HashMap/HashTable存储 - 享元模式大大减少了对象的创建，降低了程序内存的占用，提高效率
- 享元模式提高了系统的复杂度。需要分离出内部状态和外部状态，而外部状态具有
固化特性，不应该随着内部状态的改变而改变，这是我们使用享元模式需要注意的
地方. - 使用享元模式时，注意划分内部状态和外部状态，并且需要有一个工厂类加以控制。
- 享元模式经典的应用场景是需要缓冲池的场景，比如 String常量池、 数据库连接池
扫一扫
343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
