【设计模式】结构型-享元模式

news2024/11/30 11:45:09

在浮华世界中，享元犹如静水深流，细品每一片风景，留下岁月的深情。

文章目录

一、内存溢出问题
二、享元模式
三、享元模式的核心组成
四、运用享元模式
五、享元模式的应用场景
六、小结
推荐阅读

一、内存溢出问题

class Circle {
    private String color;

    public Circle(String color) {
        this.color = color;
    }

    public void draw() {
        System.out.println("Drawing a " + color + " circle.");
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 1000000; i++) {
            Circle circle = new Circle("red");
            circle.draw();
        }
    }
}

在上面的例子中，我们创建了一百万个红色的 Circle 对象。每个对象都有自己的内存空间，这会消耗大量的内存。如果我们需要更多的 Circle 对象，或者 Circle 对象的大小更大，那么内存消耗将会更严重。

二、享元模式

享元模式是一种结构型设计模式，旨在通过共享尽可能多的对象来减少内存使用和提高性能。在享元模式中，对象被分为内部状态和外部状态。内部状态是可以共享的，而外部状态则取决于对象的上下文，因此不能共享。享元模式通过共享内部状态来减少相似对象的数量，从而节省内存。

例如，考虑一个文字处理应用程序，用户在文档中使用了大量相同的字体和字号的文字。在享元模式中，字体和字号可以作为内部状态，而文字内容则是外部状态。这样，如果多个文字具有相同的字体和字号，它们可以共享同一个字体对象，从而节省内存。

三、享元模式的核心组成

享元模式的核心组件主要包括以下几个部分：

Flyweight（享元接口）：这是享元模式的核心接口，用于定义共享对象的方法。
ConcreteFlyweight（具体享元类）：这是享元接口的实现类，用于实现共享对象的方法。
FlyweightFactory（享元工厂类）：这是享元模式的关键组件，负责创建和管理享元对象。享元工厂类通常包含一个池（缓存）用于存储和复用已经创建的享元对象。

在这里插入图片描述

在这个类图中：

Flyweight 是享元接口，定义了享元对象的方法。
ConcreteFlyweight 是具体享元类，实现了享元接口。
UnsharedConcreteFlyweight 是不共享的具体享元类，它也实现了享元接口，但不被享元工厂所共享。
FlyweightFactory 是享元工厂类，负责创建和管理享元对象。它包含一个 flyweights 字段，这是一个映射，用于存储和复用已经创建的享元对象。

四、运用享元模式

场景假设：有一个绘图应用程序，需要绘制大量的圆形。这些圆可能有不同的颜色，但除颜色外，所有的圆都是相同的。

定义享元接口：首先，我们需要定义一个享元接口，这个接口定义了享元对象的方法。在我们的示例中，我们定义了一个 Circle 接口，它有一个 draw 方法。
```
public interface Circle {
    void draw();
}
```

创建具体享元类：然后，我们需要创建一个实现享元接口的具体享元类。在我们的示例中，我们创建了一个 ConcreteCircle 类，它实现了 Circle 接口。

public class ConcreteCircle implements Circle {
    private String color;

    public ConcreteCircle(String color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " circle.");
    }
}

创建享元工厂：接下来，我们需要创建一个享元工厂，它负责创建和管理享元对象。在我们的示例中，我们创建了一个 CircleFactory 类，它包含一个 circleMap 字段，这是一个映射，用于存储和复用已经创建的 ConcreteCircle 对象。

public class CircleFactory {
    private Map<String, Circle> circleMap;

    public CircleFactory() {
        circleMap = new HashMap<>();
    }

    public Circle getCircle(String color) {
        Circle circle = circleMap.get(color);

        if (circle == null) {
            circle = new ConcreteCircle(color);
            circleMap.put(color, circle);
        }

        return circle;
    }
}

使用享元工厂：最后，我们可以使用享元工厂来获取享元对象并使用它们。在我们的示例中，我们使用 CircleFactory 来获取 Circle 对象，并调用它们的 draw 方法。

public class Main {
    public static void main(String[] args) {
        CircleFactory factory = new CircleFactory();

        Circle redCircle = factory.getCircle("red");
        redCircle.draw();

        Circle blueCircle = factory.getCircle("blue");
        blueCircle.draw();

        Circle redCircle2 = factory.getCircle("red");
        redCircle2.draw();
    }
}

在这个示例中，我们只创建了两个 ConcreteCircle 对象，即使我们调用了三次 getCircle 方法。这是因为当我们第二次请求一个红色的圆时，享元工厂返回了第一次创建的那个红色的圆，而不是创建一个新的对象。

这就是享元模式的优势，它可以通过共享对象来减少内存消耗和提高性能。但是，享元模式也会增加系统的复杂性，因此在使用时需要权衡利弊。

在适合的场景下，享元模式可以带来显著的性能提升。在不适合的场景下，可能会引入不必要的复杂性。所以，我们需要根据实际情况来选择是否使用享元模式。

五、享元模式的应用场景

享元模式适用于以下场景：

大量相似对象的情况：当系统中存在大量相似对象，且这些对象的区别在于它们的内部状态而不是外部状态时，可以考虑使用享元模式。通过共享内部状态，可以减少对象的数量，从而节省内存。
对象的数量对系统性能造成影响时：如果系统中创建大量对象会导致内存占用过高或性能下降，可以考虑使用享元模式来共享这些对象，从而减少内存消耗和提高性能。
多个对象共享相同状态的情况：当多个对象需要共享相同的状态时，可以使用享元模式来避免重复创建这些状态，提高系统的效率。
对象的外部状态相对较少：如果对象的外部状态相对较少，且可以被抽象出来作为享元对象的外部状态，那么适合使用享元模式。