Java设计模式-享元模式
Posted xstxjs
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java设计模式-享元模式相关的知识，希望对你有一定的参考价值。
简介
在Java领域的软件开发中，设计模式是提高代码可维护性和可扩展性的重要工具。其中，享元模式是一种被广泛使用的设计模式，它通过优化对象的重用来提升系统性能。
享元模式是一种结构型设计模式，旨在通过共享对象来减少系统中的对象数量，从而提升性能和减少内存消耗。在享元模式中，对象分为两类：内部状态（Intrinsic State）和外部状态（Extrinsic State）。内部状态是对象可共享的部分，而外部状态是对象的变化部分，每个对象都有自己的外部状态。
与其他设计模式的区别：
- 享元模式与单例模式：单例模式关注于只有一个实例的创建，而享元模式关注于对象的重用。享元模式允许多个对象存在，但通过共享内部状态来减少重复对象的创建。
- 享元模式与原型模式：原型模式通过复制现有对象来创建新的对象，而享元模式通过共享现有对象来避免创建新对象。享元模式在多个对象之间共享相同的状态，而原型模式则不共享。
实现
下面是使用Java编程语言实现外观模式的示例代码：
// 定义享元接口
public interface Shape
void draw();
// 具体享元类
public class Circle implements Shape
private String color;
public Circle(String color)
this.color = color;
public void draw()
System.out.println("Drawing a circle with color: " + color);
// 享元工厂类
public class ShapeFactory
private static final Map<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 a new circle with color: " + color);
return circle;
// 客户端代码
public class Client
private static final String[] colors = "Red", "Green", "Blue" ;
public static void main(String[] args)
for (int i = 0; i < 20; i++)
Circle circle = (Circle) ShapeFactory.getCircle(getRandomColor());
circle.draw();
private static String getRandomColor()
return colors[(int)(Math.random() * colors.length)];
优缺点
优点
- 减少对象的数量：享元模式通过共享内部状态来减少系统中的对象数量，从而减少内存消耗。
- 提升性能：由于重复对象的创建被避免，享元模式可以显著提升系统的性能。
- 简化对象结构：通过将对象的状态划分为内部状态和外部状态，享元模式可以简化对象的结构，使得系统更易于理解和维护。
缺点
- 需要维护共享池：享元模式需要维护一个共享对象的池，这可能会增加代码的复杂性和维护成本。
- 对象状态共享可能引发线程安全问题：如果多个线程同时访问共享对象并修改其外部状态，需要确保线程安全性。
运用场景
享元模式适用于以下场景：
- 当系统中存在大量相似对象且消耗大量内存时，可以考虑使用享元模式来减少内存消耗。
- 当需要频繁创建和销毁对象时，可以使用享元模式提升系统性能。
- 当对象的内部状态与外部状态分离，并且外部状态相对较少时，可以考虑使用享元模式。
总结
享元模式是Java设计模式中一种被广泛应用的优化性能的设计模式。通过共享内部状态来减少对象的数量，从而降低内存消耗和提升系统性能。与单例模式和原型模式相比，享元模式注重对象的重用而不是单例或复制。使用Java编程语言实现享元模式可以通过共享池来管理对象的共享和创建。
该模式的优点在于减少对象数量、提升性能和简化对象结构。通过共享对象，系统内存占用减少，同时避免了重复创建对象的开销，从而提高了系统的性能。通过划分内部状态和外部状态，对象结构更清晰，更易于理解和维护。
然而，享元模式也存在一些缺点和限制。维护共享池可能增加代码的复杂性和维护成本。并且，共享对象的状态共享可能引发线程安全问题，需要注意并发访问和修改共享对象的外部状态。
适用场景包括系统中存在大量相似对象且消耗大量内存的情况，通过共享对象可以减少内存消耗。在需要频繁创建和销毁对象的情况下，享元模式可以提升系统性能。当对象的内部状态与外部状态分离，且外部状态相对较少时，也可以考虑使用该模式。
通过合理应用享元模式，开发人员可以优化系统设计，提高代码的可维护性和可扩展性。通过共享对象，我们可以更有效地管理系统资源，提升系统的性能和响应能力。因此，享元模式在Java开发中具有重要的应用和意义。
Java设计模式之——享元模式
1、什么是享元模式？
Use sharing to support large numbers of fine-grained objects efficiently.
享元模式（Flyweight Pattern）：使用共享对象可有效地支持大量的细粒度的对象。
说人话：复用对象，节省内存。
2、享元模式定义
①、Flyweight——抽象享元角色
是一个产品的抽象类， 同时定义出对象的外部状态和内部状态的接口或实现。
一个对象信息可以分为内部状态和外部状态。
内部状态：对象可共享出来的信息， 存储在享元对象内部并且不会随环境改变而改变，可以作为一个对象的动态附加信息， 不必直接储存在具体某个对象中， 属于可以共享的部分。
外部状态：对象得以依赖的一个标记， 是随环境改变而改变的、 不可以共享的状态。
②、ConcreteFlyweight——具体享元角色
具体的一个产品类， 实现抽象角色定义的业务。 该角色中需要注意的是内部状态处理应该与环境无关， 不应该出现一个操作改变了内部状态， 同时修改了外部状态， 这是绝对不允许的。
③、unsharedConcreteFlyweight——不可共享的享元角色
不存在外部状态或者安全要求（如线程安全） 不能够使用共享技术的对象， 该对象一般不会出现在享元工厂中。
④、FlyweightFactory——享元工厂
职责非常简单， 就是构造一个池容器， 同时提供从池中获得对象的方法。
3、享元模式通用代码
/**
* 抽象享元角色
*/
public abstract class Flyweight {
// 内部状态
private String instrinsic;
// 外部状态 通过 final 修改，防止修改
protected final String extrinsic;
protected Flyweight(String extrinsic) {
this.extrinsic = extrinsic;
}
// 定义业务操作
public abstract void operate();
public String getInstrinsic() {
return instrinsic;
}
public void setInstrinsic(String instrinsic) {
this.instrinsic = instrinsic;
}
}
/**
* 具体享元角色1
*/
public class ConcreteFlyweight1 extends Flyweight{
protected ConcreteFlyweight1(String extrinsic) {
super(extrinsic);
}
@Override
public void operate() {
System.out.println("具体享元角色1");
}
}
/**
* 具体享元角色2
*/
public class ConcreteFlyweight2 extends Flyweight{
protected ConcreteFlyweight2(String extrinsic) {
super(extrinsic);
}
@Override
public void operate() {
System.out.println("具体享元角色2");
}
}
public class FlyweightFactory {
// 定义一个池容器
private static HashMap<String,Flyweight> pool = new HashMap<>();
// 享元工厂
public static Flyweight getFlyweight(String extrinsic){
// 需要返回的对象
Flyweight flyweight = null;
// 池中没有该对象
if(pool.containsKey(extrinsic)){
flyweight = pool.get(extrinsic);
}else{
// 根据外部状态创建享元对象
flyweight = new ConcreteFlyweight1(extrinsic);
// 放置到池中
pool.put(extrinsic,flyweight);
}
return flyweight;
}
}
4、通过享元设计文本编辑器
假设文本编辑器只包含文字编辑功能，而且只记录文字和格式两部分信息，其中格式包括文字的字体型号、大小、颜色等信息。
4.1 普通实现
通常设计是把每个文字看成一个单独对象。
package com.itcoke.designpattern.flyweight.edittext;
/**
* 单个文字对象
*/
public class Character {
// 字符
private char c;
// 字体型号
private String font;
// 字体大小
private int size;
// 字体颜色
private int colorRGB;
public Character(char c, String font, int size, int colorRGB){
this.c = c;
this.font = font;
this.size = size;
this.colorRGB = colorRGB;
}
@Override
public String toString() {
return String.valueOf(c);
}
}
/**
* 编辑器实现
*/
public class Editor {
private ArrayList<Character> chars = new ArrayList<>();
public void appendCharacter(char c, String font, int size, int colorRGB){
Character character = new Character(c,font,size,colorRGB);
chars.add(character);
}
public void display(){
System.out.println(chars);
}
}
客户端：
public class EditorClient {
public static void main(String[] args) {
Editor editor = new Editor();
editor.appendCharacter(\'A\',"宋体",11,0XFFB6C1);
editor.appendCharacter(\'B\',"宋体",11,0XFFB6C1);
editor.appendCharacter(\'C\',"宋体",11,0XFFB6C1);
editor.display();
}
}
4.2 享元模式改写
上面的问题很容易发现，每一个字符就会创建一个 Character 对象，如果是几百万个字符，那内存中就会存在几百万的对象，那怎么去节省这些内存呢？
其实，分析一下，对于字体的格式，通常不会有很多，于是我们可以把字体格式设置为享元，也就是上面说的可以共享的内部状态。
内部状态（共享）：字体类型、大小、颜色
外部状态（不共享）：字符
于是代码改写如下：
public class CharacterStyle {
// 字体型号
private String font;
// 字体大小
private int size;
// 字体颜色
private int colorRGB;
public CharacterStyle(String font, int size, int colorRGB) {
this.font = font;
this.size = size;
this.colorRGB = colorRGB;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
CharacterStyle that = (CharacterStyle) o;
return size == that.size &&
colorRGB == that.colorRGB &&
Objects.equals(font, that.font);
}
@Override
public int hashCode() {
return Objects.hash(font, size, colorRGB);
}
}
public class CharacterStyleFactory {
private static final Map<CharacterStyle,CharacterStyle> mapStyles = new HashMap<>();
public static CharacterStyle getStyle(String font, int size, int colorRGB){
CharacterStyle newStyle = new CharacterStyle(font,size,colorRGB);
if(mapStyles.containsKey(newStyle)){
return mapStyles.get(newStyle);
}
mapStyles.put(newStyle,newStyle);
return newStyle;
}
}
public class Character {
private char c;
private CharacterStyle style;
public Character(char c, CharacterStyle style) {
this.c = c;
this.style = style;
}
@Override
public String toString() {
return String.valueOf(c);
}
}
public class Editor {
private List<Character> chars = new ArrayList<>();
public void appendCharacter(char c, String font, int size, int colorRGB){
Character character = new Character(c,CharacterStyleFactory.getStyle(font,size,colorRGB));
chars.add(character);
}
public void display(){
System.out.println(chars);
}
}
5、享元模式在 java.lang.Integer 中应用
看下面这段代码，打印结果是啥？
public class IntegerTest {
public static void main(String[] args) {
Integer i1 = 56;
Integer i2 = 56;
Integer i3 = 129;
Integer i4 = 129;
System.out.println(i1 == i2);
System.out.println(i3 == i4);
}
}
为什么是这种结果呢？
首先说一下 Integer i = 59；底层执行了：Integer i = Integer.valueOf(59); 这是自动装箱。
int j = i; 底层执行了：int j = i.intValue(); 这是自动拆箱。
然后我们Integer.valueOf() 方法：
再看 IntegerCache 源码：
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
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_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
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() {}
}
其实这就是我们前面说的享元对象的工厂类，缓存 -128 到 127 之间的整型值，这是最常用的一部分整型值，当然JDK 也提供了方法来让我们可以自定义缓存的最大值。
6、享元模式优点
减少应用程序创建的对象， 降低程序内存的占用， 增强程序的性能。
但它同时也提高了系统复杂性， 需要分离出外部状态和内部状态， 而且外部状态具有固化特性， 不应该随内部状态改变而改变， 否则导致系统的逻辑混乱。
7、享元模式应用场景
①、系统中存在大量的相似对象。
②、细粒度的对象都具备较接近的外部状态， 而且内部状态与环境无关， 也就是说对象没有特定身份。
③、需要缓冲池的场景。
以上是关于Java设计模式-享元模式的主要内容，如果未能解决你的问题，请参考以下文章