【设计模式】【结构型模式（Structural Patterns）】之享元模式（Flyweight Pattern）

1. 设计模式原理说明

享元模式（Flyweight Pattern） 是一种用于性能优化的设计模式，其主要目的是通过共享尽可能多的对象来有效地支持大量的细粒度的对象。在享元模式中，细粒度的对象被称为“享元”，这些对象可以被共享，以减少内存的使用并提高效率。享元模式特别适用于那些对象数量巨大且大部分状态可以外部化的情况。

主要角色

Flyweight（享元）：定义一个接口，通过这个接口，Flyweight 可以接受并作用于外部状态。
ConcreteFlyweight（具体享元）：实现 Flyweight 接口，并为内部状态增加存储空间。一个 ConcreteFlyweight 对象必须是可共享的。通常情况下，它会被多个对象所共享。
UnsharedConcreteFlyweight（不可共享的具体享元）：并不是所有的 Flyweight 子类都需要被共享，因此 Flyweight 接口中声明的方法对于不可共享的具体享元同样适用。
FlyweightFactory（享元工厂）：负责创建和管理 Flyweight 对象。确保合理地共享 Flyweight 对象，当用户请求一个 Flyweight 对象时，FlyweightFactory 提供一个已有的实例或者创建一个新的实例。

2. UML 类图及解释

UML 类图

+-------------------+                +-----------------------+
|   Flyweight       |<--(implements)| ConcreteFlyweight     |
|-------------------|                |-----------------------|
| + operation(extrinsicState: String): void | + operation(extrinsicState: String): void |
+-------------------+                +-----------------------+^|
+-----------------------+              |
| UnsharedConcreteFlyweight |          |
|-----------------------|             |
| + operation(extrinsicState: String): void | +-----------------------+
+-----------------------+                | FlyweightFactory         |+-----------------------+| + getFlyweight(key: String): Flyweight |+-----------------------+

类图解释

Flyweight：定义了一个接口，通过这个接口，享元可以接收并作用于外部状态。
ConcreteFlyweight：实现了 Flyweight 接口，包含内部状态，可以被多个对象共享。
UnsharedConcreteFlyweight：虽然实现了 Flyweight 接口，但它的对象不能被共享，每个实例都有自己的状态。
FlyweightFactory：负责创建和管理享元对象。它使用一个数据结构（如哈希表）来存储已经创建的享元对象，以便复用。

3. 代码案例及逻辑详解

Java 代码案例

// 享元接口
interface Flyweight {void operation(String extrinsicState);
}// 具体享元
class ConcreteFlyweight implements Flyweight {private final String intrinsicState;public ConcreteFlyweight(String intrinsicState) {this.intrinsicState = intrinsicState;}@Overridepublic void operation(String extrinsicState) {System.out.println("Intrinsic State = " + this.intrinsicState);System.out.println("Extrinsic State = " + extrinsicState);}
}// 不可共享的具体享元
class UnsharedConcreteFlyweight implements Flyweight {@Overridepublic void operation(String extrinsicState) {System.out.println("I am not shared.");}
}// 享元工厂
class FlyweightFactory {private Map<String, Flyweight> flyweights = new HashMap<>();public Flyweight getFlyweight(String key) {if (!flyweights.containsKey(key)) {flyweights.put(key, new ConcreteFlyweight(key));}return flyweights.get(key);}
}// 客户端
public class Client {public static void main(String[] args) {FlyweightFactory factory = new FlyweightFactory();Flyweight fly1 = factory.getFlyweight("Key1");fly1.operation("Extrinsic State 1");Flyweight fly2 = factory.getFlyweight("Key1");fly2.operation("Extrinsic State 2");Flyweight unshared = new UnsharedConcreteFlyweight();unshared.operation("Extrinsic State 3");}
}

C++ 代码案例

#include <iostream>
#include <map>
#include <memory>
#include <string>// 享元接口
class Flyweight {
public:virtual void operation(const std::string& extrinsicState) const = 0;virtual ~Flyweight() {}
};// 具体享元
class ConcreteFlyweight : public Flyweight {
private:std::string intrinsicState;
public:ConcreteFlyweight(const std::string& state) : intrinsicState(state) {}void operation(const std::string& extrinsicState) const override {std::cout << "Intrinsic State = " << intrinsicState << std::endl;std::cout << "Extrinsic State = " << extrinsicState << std::endl;}
};// 不可共享的具体享元
class UnsharedConcreteFlyweight : public Flyweight {
public:void operation(const std::string& extrinsicState) const override {std::cout << "I am not shared." << std::endl;}
};// 享元工厂
class FlyweightFactory {
private:std::map<std::string, std::shared_ptr<Flyweight>> flyweights;
public:std::shared_ptr<Flyweight> getFlyweight(const std::string& key) {if (flyweights.find(key) == flyweights.end()) {flyweights[key] = std::make_shared<ConcreteFlyweight>(key);}return flyweights[key];}
};// 客户端
int main() {FlyweightFactory factory;auto fly1 = factory.getFlyweight("Key1");fly1->operation("Extrinsic State 1");auto fly2 = factory.getFlyweight("Key1");fly2->operation("Extrinsic State 2");UnsharedConcreteFlyweight unshared;unshared.operation("Extrinsic State 3");return 0;
}

Python 代码案例

from abc import ABC, abstractmethod
from collections import defaultdict# 享元接口
class Flyweight(ABC):@abstractmethoddef operation(self, extrinsic_state: str) -> None:pass# 具体享元
class ConcreteFlyweight(Flyweight):def __init__(self, intrinsic_state: str) -> None:self._intrinsic_state = intrinsic_statedef operation(self, extrinsic_state: str) -> None:print(f"Intrinsic State = {self._intrinsic_state}")print(f"Extrinsic State = {extrinsic_state}")# 不可共享的具体享元
class UnsharedConcreteFlyweight(Flyweight):def operation(self, extrinsic_state: str) -> None:print("I am not shared.")# 享元工厂
class FlyweightFactory:_flyweights: dict[str, Flyweight] = {}def get_flyweight(self, key: str) -> Flyweight:if key not in self._flyweights:self._flyweights[key] = ConcreteFlyweight(key)return self._flyweights[key]# 客户端
if __name__ == "__main__":factory = FlyweightFactory()fly1 = factory.get_flyweight("Key1")fly1.operation("Extrinsic State 1")fly2 = factory.get_flyweight("Key1")fly2.operation("Extrinsic State 2")unshared = UnsharedConcreteFlyweight()unshared.operation("Extrinsic State 3")

Go 代码案例

package mainimport ("fmt"
)// 享元接口
type Flyweight interface {operation(extrinsicState string)
}// 具体享元
type ConcreteFlyweight struct {intrinsicState string
}func (f *ConcreteFlyweight) operation(extrinsicState string) {fmt.Printf("Intrinsic State = %s\n", f.intrinsicState)fmt.Printf("Extrinsic State = %s\n", extrinsicState)
}// 不可共享的具体享元
type UnsharedConcreteFlyweight struct{}func (u *UnsharedConcreteFlyweight) operation(extrinsicState string) {fmt.Println("I am not shared.")
}// 享元工厂
type FlyweightFactory struct {flyweights map[string]Flyweight
}func NewFlyweightFactory() *FlyweightFactory {return &FlyweightFactory{flyweights: make(map[string]Flyweight)}
}func (f *FlyweightFactory) getFlyweight(key string) Flyweight {if fw, ok := f.flyweights[key]; ok {return fw}fw := &ConcreteFlyweight{intrinsicState: key}f.flyweights[key] = fwreturn fw
}// 客户端
func main() {factory := NewFlyweightFactory()fly1 := factory.getFlyweight("Key1")fly1.operation("Extrinsic State 1")fly2 := factory.getFlyweight("Key1")fly2.operation("Extrinsic State 2")unshared := &UnsharedConcreteFlyweight{}unshared.operation("Extrinsic State 3")
}