享元模式原理
享元模式是一种结构型设计模式，它旨在有效地支持大量细粒度对象的共享。该模式通过共享对象的内部状态来减少内存使用和对象创建的开销。
享元模式的核心思想是将对象的状态分为内部状态和外部状态。内部状态是对象可共享的部分，它不会随着对象的上下文而改变。而外部状态是对象的上下文相关的部分，它会随着对象的上下文而变化。
通过将内部状态和外部状态分离，享元模式可以将多个对象共享同一个内部状态，从而减少内存占用。这种共享可以在多个对象之间共享，从而提高系统的性能和效率。
在实现享元模式时，通常会使用一个工厂类来创建和管理共享对象。工厂类会维护一个对象池，用于存储和复用已经创建的对象。当需要获取对象时，工厂类会检查对象池中是否已经存在符合要求的对象，如果存在则直接返回；如果不存在，则创建一个新的对象并将其加入对象池中。
总结一下，享元模式通过共享对象的内部状态来减少内存使用和对象创建的开销，从而提高系统的性能和效率。它适用于需要创建大量细粒度对象，并且这些对象可以共享一部分状态的场景。
下面是一个使用Go语言实现享元模式的简单示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
package main
import "fmt"
// Flyweight接口定义了享元对象的方法
type Flyweight interface {
Operation()
}
// ConcreteFlyweight是具体的享元对象，实现了Flyweight接口
type ConcreteFlyweight struct {
sharedState string
}
func (f *ConcreteFlyweight) Operation() {
fmt.Println("具体享元对象的操作，共享状态为：", f.sharedState)
}
// FlyweightFactory是享元工厂，负责创建和管理享元对象
type FlyweightFactory struct {
flyweights map[string]Flyweight
}
func NewFlyweightFactory() *FlyweightFactory {
return &FlyweightFactory{
flyweights: make(map[string]Flyweight),
}
}
func (factory *FlyweightFactory) GetFlyweight(key string) Flyweight {
// 如果已经存在对应的享元对象，则直接返回
if flyweight, ok := factory.flyweights[key]; ok {
return flyweight
}
// 如果不存在对应的享元对象，则创建一个新的对象并存储到工厂中
flyweight := &ConcreteFlyweight{sharedState: key}
factory.flyweights[key] = flyweight
return flyweight
}
func main() {
factory := NewFlyweightFactory()
// 获取或创建享元对象
flyweight1 := factory.GetFlyweight("state1")
flyweight2 := factory.GetFlyweight("state2")
flyweight3 := factory.GetFlyweight("state1")
// 调用享元对象的操作
flyweight1.Operation()
flyweight2.Operation()
flyweight3.Operation()
// 输出结果：
// 具体享元对象的操作，共享状态为： state1
// 具体享元对象的操作，共享状态为： state2
// 具体享元对象的操作，共享状态为： state1
}
|
在上面的示例中，我们定义了一个 Flyweight 接口，以及具体的享元对象 ConcreteFlyweight 。 FlyweightFactory 负责创建和管理享元对象。在 main 函数中，我们通过工厂获取或创建享元对象，并调用其操作方法。
这个示例展示了如何使用享元模式来共享相同的状态。在这个例子中，我们创建了两个享元对象，它们共享相同的状态。当我们获取第三个享元对象时，由于已经存在相同状态的对象，所以直接返回了已有的对象。
