1
package flyweight
2

3
import "sync"
4

5
// TextStyle 文本格式享元——不可变
6
type TextStyle struct {
7
    Font   string
8
    Size   int
9
    Color  string
10
}
11

12
// textStyleKey 用作享元池的键
13
type textStyleKey struct {
14
    Font  string
15
    Size  int
16
    Color string
17
}
18

19
// StyleFactory 享元工厂，确保相同格式只创建一份
20
type StyleFactory struct {
21
    mu    sync.RWMutex
22
    pool  map[textStyleKey]*TextStyle
23
}
24

25
func NewStyleFactory() *StyleFactory {
26
    return &StyleFactory{
27
        pool: make(map[textStyleKey]*TextStyle),
28
    }
29
}
30

31
// GetStyle 获取享元对象，相同参数返回同一指针
32
func (f *StyleFactory) GetStyle(font string, size int, color string) *TextStyle {
33
    key := textStyleKey{Font: font, Size: size, Color: color}
34

35
    f.mu.RLock()
36
    if style, ok := f.pool[key]; ok {
37
        f.mu.RUnlock()
38
        return style // 命中：返回已有实例
39
    }
40
    f.mu.RUnlock()
41

42
    // 未命中：创建新实例
43
    f.mu.Lock()
44
    defer f.mu.Unlock()
45

46
    // 双重检查，防止并发创建
47
    if style, ok := f.pool[key]; ok {
48
        return style
49
    }
50

51
    style := &TextStyle{Font: font, Size: size, Color: color}
52
    f.pool[key] = style
53
    return style
54
}
55

56
// Character 字符对象——外部状态独立，内部状态共享
57
type Character struct {
58
    Char  rune
59
    X, Y  float64     // 外部状态：位置
60
    Style *TextStyle   // 内部状态：共享的享元
61
}

1
// 享元工厂：确保相同值只创建一份
2
class FlyweightFactory<T> {
3
  private pool = new Map<string, T>();
4

5
  // 获取或创建享元对象
6
  intern(key: string, create: () => T): T {
7
    if (this.pool.has(key)) {
8
      return this.pool.get(key)!;
9
    }
10
    const value = create();
11
    this.pool.set(key, value);
12
    return value;
13
  }
14

15
  has(key: string): boolean {
16
    return this.pool.has(key);
17
  }
18

19
  get size(): number {
20
    return this.pool.size;
21
  }
22
}
23

24
// 使用示例：游戏引擎中的树木渲染
25
interface TreeModel {
26
  mesh: string;
27
  texture: string;
28
}
29

30
interface Tree {
31
  x: number;
32
  y: number;
33
  health: number;
34
  model: TreeModel; // 享元：所有同类树共享同一个模型
35
}
36

37
const modelFactory = new FlyweightFactory<TreeModel>();
38

39
// 1000 棵松树共享同一个模型对象
40
const pineModel = modelFactory.intern("pine", () => ({
41
  mesh: "pine.mesh",
42
  texture: "pine.texture",
43
}));
44

45
const trees: Tree[] = Array.from({ length: 1000 }, (_, i) => ({
46
  x: Math.random() * 1000,
47
  y: Math.random() * 1000,
48
  health: 100,
49
  model: pineModel, // 全部指向同一个对象
50
}));
51

52
// 相等性检查：指针比较即可
53
console.log(trees[0].model === trees[999].model); // true