🙊 前言：本文章为瑞_系列专栏之《23种设计模式》的享元模式篇。本文中的部分图和概念等资料，来源于博主学习设计模式的相关网站《菜鸟教程 | 设计模式》和《黑马程序员Java设计模式详解》，特此注明。本文中涉及到的软件设计模式的概念、背景、优点、分类、以及UML图的基本知识和设计模式的6大法则等知识，建议阅读 《瑞_23种设计模式_概述》

本系列 - 设计模式 - 链接：《瑞_23种设计模式_概述》

⬇️本系列 - 创建型模式 - 链接🔗

  单例模式：《瑞_23种设计模式_单例模式》
  工厂模式：《瑞_23种设计模式_工厂模式》
  原型模式：《瑞_23种设计模式_原型模式》
抽象工厂模式：《瑞_23种设计模式_抽象工厂模式》
 建造者模式：《瑞_23种设计模式_建造者模式》

⬇️本系列 - 结构型模式 - 链接🔗

  代理模式：《瑞_23种设计模式_代理模式》
 适配器模式：《瑞_23种设计模式_适配器模式》
 装饰者模式：《瑞_23种设计模式_装饰者模式》
  桥接模式：《瑞_23种设计模式_桥接模式》
  外观模式：《瑞_23种设计模式_外观模式》
  组合模式：《瑞_23种设计模式_组合模式》
  享元模式：《后续更新》

⬇️本系列 - 行为型模式 - 链接🔗

模板方法模式：《后续更新》
  策略模式：《后续更新》
  命令模式：《后续更新》
 职责链模式：《后续更新》
  状态模式：《后续更新》
 观察者模式：《后续更新》
 中介者模式：《后续更新》
 迭代器模式：《后续更新》
 访问者模式：《后续更新》
 备忘录模式：《后续更新》
 解释器模式：《后续更新》

1 享元模式（Flyweight Pattern）

  享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

瑞：结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。

  享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。

1.1 介绍

• 意图：运用共享技术有效地支持大量细粒度的对象。

• 主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

• 何时使用：
    1️⃣ 系统中有大量对象。
    2️⃣ 这些对象消耗大量内存。
    3️⃣ 这些对象的状态大部分可以外部化。
    4️⃣ 这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替。
    5️⃣ 系统不依赖于这些对象身份，这些对象是不可分辨的。

• 如何解决：用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。

• 关键代码：用 HashMap 存储这些对象。

• 应用实例：
    1️⃣ JAVA 中的 String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面。
    2️⃣ 数据库的连接池。

• 优点：大大减少对象的创建，降低系统的内存，使效率提高。

• 缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

• 使用场景：
    1️⃣ 系统有大量相似对象。
    2️⃣ 需要缓冲池的场景。

• 注意事项：
    1️⃣ 注意划分外部状态和内部状态，否则可能会引起线程安全问题。
    2️⃣ 这些类必须有一个工厂对象加以控制。

1.2 概述

定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率。

• 享元（Flyweight ）模式中存在以下两种状态：
    1️⃣ 内部状态，即不会随着环境的改变而改变的可共享部分。
    2️⃣ 外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

1.3 享元模式的结构

• 享元模式的主要有以下角色：
    1️⃣ 抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
    2️⃣ 具体享元（Concrete Flyweight）角色 ：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
    3️⃣ 非享元（Unsharable Flyweight)角色 ：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
    4️⃣ 享元工厂（Flyweight Factory）角色 ：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

1.4 享元模式的优缺点

  优点：
  1️⃣ 极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
  2️⃣ 享元模式中的外部状态相对独立，且不影响内部状态

  缺点：
  1️⃣ 为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

1.5 享元模式的使用场景

• 一个系统有大量相同或者相似的对象，造成内存的大量耗费。
• 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
• 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

---

2 案例一

【案例】俄罗斯方块

2.1 需求

  下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。

  类图设计如下：

2.2 代码实现

俄罗斯方块有不同的形状，我们可以对这些形状向上抽取出AbstractBox，用来定义共性的属性和行为。

抽象享元角色（抽象类）

/*** 抽象享元角色** @author LiaoYuXing-Ray**/
public abstract class AbstractBox {// 获取图形的方法public abstract String getShape();// 显示图形及颜色public void display(String color) {System.out.println("方块形状：" + getShape() + ", 颜色：" + color);}
}

接下来就是定义不同的形状了，IBox类、LBox类、OBox类等。

I图形类(具体享元角色)（类）

/*** I图形类(具体享元角色)** @author LiaoYuXing-Ray**/
public class IBox extends AbstractBox {public String getShape() {return "I";}
}

L图形类(具体享元角色)（类）

/*** L图形类(具体享元角色)** @author LiaoYuXing-Ray**/
public class LBox extends AbstractBox {public String getShape() {return "L";}
}

O图形类(具体享元角色)（类）

/*** O图形类(具体享元角色)** @author LiaoYuXing-Ray**/
public class OBox extends AbstractBox {public String getShape() {return "O";}
}

提供了一个工厂类（BoxFactory），用来管理享元对象（也就是AbstractBox子类对象），该工厂类对象只需要一个，所以可以使用单例模式。并给工厂类提供一个获取形状的方法。

工厂类（类）

import java.util.HashMap;/*** 工厂类，将该类设计为单例** @author LiaoYuXing-Ray**/
public class BoxFactory {private final HashMap<String, AbstractBox> map;// 在构造方法中进行初始化操作private BoxFactory() {map = new HashMap<String, AbstractBox>();map.put("I",new IBox());map.put("L",new LBox());map.put("O",new OBox());}// 提供一个方法获取该工厂类对象public static BoxFactory getInstance() {return factory;}private static final BoxFactory factory = new BoxFactory();// 根据名称获取图形对象public AbstractBox getShape(String name) {return map.get(name);}
}

测试类

/*** 测试类** @author LiaoYuXing-Ray**/
public class Client {public static void main(String[] args) {// 获取I图形对象AbstractBox box1 = BoxFactory.getInstance().getShape("I");box1.display("灰色");// 获取L图形对象AbstractBox box2 = BoxFactory.getInstance().getShape("L");box2.display("绿色");// 获取O图形对象AbstractBox box3 = BoxFactory.getInstance().getShape("O");box3.display("灰色");// 获取O图形对象AbstractBox box4 = BoxFactory.getInstance().getShape("O");box4.display("红色");System.out.println("两次获取到的O图形对象是否是同一个对象：" + (box3 == box4));}
}

  代码运行结果如下：

	方块形状：I, 颜色：灰色方块形状：L, 颜色：绿色方块形状：O, 颜色：灰色方块形状：O, 颜色：红色两次获取到的O图形对象是否是同一个对象：true

---

3 案例二

本案例为菜鸟教程中的案例

3.1 需求

  我们将通过创建 5 个对象来画出 20 个分布于不同位置的圆来演示这种模式。由于只有 5 种可用的颜色，所以 color 属性被用来检查现有的 Circle 对象。

  我们将创建一个 Shape 接口和实现了 Shape 接口的实体类 Circle。下一步是定义工厂类 ShapeFactory。

  ShapeFactory 有一个 Circle 的 HashMap，其中键名为 Circle 对象的颜色。无论何时接收到请求，都会创建一个特定颜色的圆。ShapeFactory 检查它的 HashMap 中的 circle 对象，如果找到 Circle 对象，则返回该对象，否则将创建一个存储在 hashmap 中以备后续使用的新对象，并把该对象返回到客户端。

  FlyWeightPatternDemo 类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（red / green / blue/ black / white），以便获取它所需对象的颜色。

3.2 代码实现

步骤 1

  创建一个接口。

Shape.java

public interface Shape {void draw();
}

步骤 2

  创建实现接口的实体类。

Circle.java

public class Circle implements Shape {private String color;private int x;private int y;private int radius;public Circle(String color){this.color = color;     }public void setX(int x) {this.x = x;}public void setY(int y) {this.y = y;}public void setRadius(int radius) {this.radius = radius;}@Overridepublic void draw() {System.out.println("Circle: Draw() [Color : " + color +", x : " + x +", y :" + y +", radius :" + radius);}
}

步骤 3

  创建一个工厂，生成基于给定信息的实体类的对象。

ShapeFactory.java

import java.util.HashMap;public class ShapeFactory {private static final HashMap<String, Shape> circleMap = new HashMap<>();public static Shape getCircle(String color) {Circle circle = (Circle)circleMap.get(color);if(circle == null) {circle = new Circle(color);circleMap.put(color, circle);System.out.println("Creating circle of color : " + color);}return circle;}
}

步骤 4

  使用该工厂，通过传递颜色信息来获取实体类的对象。

FlyweightPatternDemo.java

public class FlyweightPatternDemo {private static final String colors[] = { "Red", "Green", "Blue", "White", "Black" };public static void main(String[] args) {for(int i=0; i < 20; ++i) {Circle circle = (Circle)ShapeFactory.getCircle(getRandomColor());circle.setX(getRandomX());circle.setY(getRandomY());circle.setRadius(100);circle.draw();}}private static String getRandomColor() {return colors[(int)(Math.random()*colors.length)];}private static int getRandomX() {return (int)(Math.random()*100 );}private static int getRandomY() {return (int)(Math.random()*100);}
}

步骤 5

  执行程序，输出结果：

	Creating circle of color : BlackCircle: Draw() [Color : Black, x : 36, y :71, radius :100Creating circle of color : GreenCircle: Draw() [Color : Green, x : 27, y :27, radius :100Creating circle of color : WhiteCircle: Draw() [Color : White, x : 64, y :10, radius :100Creating circle of color : RedCircle: Draw() [Color : Red, x : 15, y :44, radius :100Circle: Draw() [Color : Green, x : 19, y :10, radius :100Circle: Draw() [Color : Green, x : 94, y :32, radius :100Circle: Draw() [Color : White, x : 69, y :98, radius :100Creating circle of color : BlueCircle: Draw() [Color : Blue, x : 13, y :4, radius :100Circle: Draw() [Color : Green, x : 21, y :21, radius :100Circle: Draw() [Color : Blue, x : 55, y :86, radius :100Circle: Draw() [Color : White, x : 90, y :70, radius :100Circle: Draw() [Color : Green, x : 78, y :3, radius :100Circle: Draw() [Color : Green, x : 64, y :89, radius :100Circle: Draw() [Color : Blue, x : 3, y :91, radius :100Circle: Draw() [Color : Blue, x : 62, y :82, radius :100Circle: Draw() [Color : Green, x : 97, y :61, radius :100Circle: Draw() [Color : Green, x : 86, y :12, radius :100Circle: Draw() [Color : Green, x : 38, y :93, radius :100Circle: Draw() [Color : Red, x : 76, y :82, radius :100Circle: Draw() [Color : Blue, x : 95, y :82, radius :100

---

4 JDK源码解析（Integer类）

  Integer类使用了享元模式。我们先看下面的例子：

public class Demo {public static void main(String[] args) {Integer i1 = 127;Integer i2 = 127;System.out.println("i1和i2对象是否是同一个对象？" + (i1 == i2));Integer i3 = 128;Integer i4 = 128;System.out.println("i3和i4对象是否是同一个对象？" + (i3 == i4));}
}

  代码运行结果如下：

	i1和i2对象是否是同一个对象？truei3和i4对象是否是同一个对象？false

为什么第一个输出语句输出的是true，第二个输出语句输出的是false？

  通过反编译软件进行反编译，代码如下：

public class Demo {public static void main(String[] args) {Integer i1 = Integer.valueOf((int)127);Integer i2 Integer.valueOf((int)127);System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());Integer i3 = Integer.valueOf((int)128);Integer i4 = Integer.valueOf((int)128);System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());}
}

  上面代码可以看到，直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是 valueOf() ，所以只需要看该方法即可

public final class Integer extends Number implements Comparable<Integer> {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 {int h = 127;String integerCacheHighPropValue =sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");if (integerCacheHighPropValue != null) {try {int i = parseInt(integerCacheHighPropValue);i = Math.max(i, 127);// Maximum array size is Integer.MAX_VALUEh = Math.min(i, Integer.MAX_VALUE - (-low) -1);} catch( NumberFormatException nfe) {}}high = h;cache = new Integer[(high - low) + 1];int j = low;for(int k = 0; k < cache.length; k++)cache[k] = new Integer(j++);// range [-128, 127] must be interned (JLS7 5.1.7)assert IntegerCache.high >= 127;}private IntegerCache() {}}
}

可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创建一个新的 Integer 对象。

---

本文是博主的粗浅理解，可能存在一些错误或不完善之处，如有遗漏或错误欢迎各位补充，谢谢

  如果觉得这篇文章对您有所帮助的话，请动动小手点波关注💗，你的点赞👍收藏⭐️转发🔗评论📝都是对博主最好的支持~