一起学设计模式 - 享元模式

文章目录
  1. 1. 概述
  2. 2. 案例
    1. 2.1. JDK中使用
  3. 3. 总结
  4. 4. - 说点什么

享元模式(Flyweight Pattern)属于结构型模式的一种,又称轻量级模式,通过共享技术有效地实现了大量细粒度对象的复用…

概述

两种结构状态

  • 内部状态:享元对象内部不随外界环境改变而改变的共享部分。
  • 外部状态:享元对象内部环境的改变而改变,不能够共享的状态就是外部状态。

结构图

经典结构图

存在的角色

  • Flyweight(抽象享元类):通常是一个接口或抽象类,向外界提供享元对象的内部数据(内部状态)或外部数据(外部状态)。
  • ConcreteFlyweight(具体享元类):实现了Flyweight(抽象享元类)也称为享元对象,指定内部状态,为内部状态增加存储空间。通常我们可以结合单例模式来设计具体享元类,为每一个具体享元类提供唯一的享元对象。
  • UnsharedConcreteFlyweight(非共享具体享元类):指不需要共享的Flyweight子类。
  • FlyweightFactory(享元工厂类):用于创建并管理享元对象,针对抽象享元类编程,将各种类型的具体享元对象存储在一个享元池中,享元池一般设计为键值对的集合(也可以是其他类型的集合),同时可以结合工厂模式进行设计。

享元模式的核心在于享元工厂类,享元工厂类的作用在于提供一个用于存储享元对象的享元池,用户需要对象时,首先从享元池中获取,如果享元池中不存在,则创建一个新的享元对象返回给用户,并在享元池中保存该新增对象。

案例

案例UML图如下:

UML图

1.创建Flyweight接口/抽象类

1
2
3
4
5
interface Flyweight {
void operation(String name);

String getType();
}

2.创建ConcreteFlyweight(享元对象),实现了Flyweight接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class ConcreteFlyweight implements Flyweight {
private String type;

public ConcreteFlyweight(String type) {
this.type = type;
}

@Override
public void operation(String name) {
System.out.printf("[类型(内在状态)] - [%s] - [名字(外在状态)] - [%s]\n", type, name);
}

@Override
public String getType() {
return type;
}
}

3.创建FlyweightFactory(享元工厂类),用来维护享元池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class FlyweightFactory {
private static final Map<String, Flyweight> FLYWEIGHT_MAP = new HashMap<>();

public static Flyweight getFlyweight(String type) {
if (FLYWEIGHT_MAP.containsKey(type)) {
return FLYWEIGHT_MAP.get(type);
} else {
ConcreteFlyweight flyweight = new ConcreteFlyweight(type);
FLYWEIGHT_MAP.put(type, flyweight);
return flyweight;
}
}

public static int total() {
return FLYWEIGHT_MAP.size();
}
}

4.创建Client(测试类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Client {

public static void main(String[] args) {
Flyweight fw0 = FlyweightFactory.getFlyweight("战士");
Flyweight fw1 = FlyweightFactory.getFlyweight("战士");
Flyweight fw2 = FlyweightFactory.getFlyweight("法师");
Flyweight fw3 = FlyweightFactory.getFlyweight("坦克");
fw1.operation("瑞文");
fw1.operation("鳄鱼");
fw2.operation("光辉");
fw3.operation("泰坦");
fw3.operation("盖伦");
System.out.printf("[结果(对象对比)] - [%s]\n", fw0 == fw1);
System.out.printf("[结果(内在状态)] - [%s]\n", fw1.getType());
System.out.printf("一共召唤 %s 种类型英雄\n", FlyweightFactory.total());
}
}

5.运行结果,从结果中可以发现,只生成了3个不同的类

1
2
3
4
5
6
7
8
[类型(内在状态)] - [战士] - [名字(外在状态)] - [瑞文]
[类型(内在状态)] - [战士] - [名字(外在状态)] - [鳄鱼]
[类型(内在状态)] - [法师] - [名字(外在状态)] - [光辉]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [泰坦]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [盖伦]
[结果(对象对比)] - [true]
[结果(内在状态)] - [战士]
一共召唤 3 种类型英雄

JDK中使用

在JAVA语言中,String类型就是使用了享元模式。String对象是final类型,对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的,JAVA会确保一个字符串常量在常量池中只有一个拷贝。

1
2
3
4
5
6
7
public class Client {
public static void main(String[] args) {
String a = "盖伦";
String b = "盖伦";
System.out.println(a==b);// 返回 true
}
}

上面的例子中结果为:true,这就说明a和b两个引用都指向了常量池中的同一个字符串常量。这样设计的目的就是:为了避免在创建多相同对象时,所产生的不必要的资源消耗。

总结

如果程序里使用大量相同或者相似的对象,造成内存的大量耗费,且大多都是外部状态,这时候就应该考虑使用享元模式了,比如围棋、五子棋等小游戏

优点

  • 能够极大的减少系统中对象的个数。
  • 外部状态相对独立,不会影响到内部状态,能够使享元对象在不同的环境被共享。

缺点

  • 由于享元模式需要区分外部状态和内部状态,使得程序在某种程度上来说更加复杂化了。
  • 为了使对象可以共享,享元模式需要将享元对象的状态外部化,而读取外部状态使得运行时间变长。

- 说点什么

全文代码:https://gitee.com/battcn/design-pattern/tree/master/Chapter9/battcn-flyweight

  • 个人QQ:1837307557
  • battcn开源群(适合新手):391619659

微信公众号:battcn(欢迎调戏)