享元模式通过共享内部状态减少对象数量，降低内存消耗。在Golang中，定义如CharacterStyle的不可变内部状态，由StyleFactory以键值缓存复用；外部状态（如坐标）由客户端传入，结合享元对象实现高效渲染。示例中相同样式被多次请求但仅创建一次，验证了对象复用。该模式适用于大量相似对象场景，需确保内部状态不可变，并在并发时保护工厂的线程安全。
享元模式（Flyweight Pattern）是一种结构型设计模式，主要用于减少创建对象的数量，降低内存占用和提高性能。在 Golang 中，当程序中存在大量相似对象且这些对象包含可共享的状态时，使用享元模式非常合适。
享元模式的核心思想
享元模式通过共享技术来支持大量细粒度对象的复用。它将对象的状态分为两种：
- 内部状态（Intrinsic State）：可以被共享，不会随环境改变，通常作为享元对象的不可变属性。
- 外部状态（Extrinsic State）：依赖于上下文，不能共享，需在使用时由客户端传入。
通过分离这两种状态，可以避免重复创建相同内部状态的对象，从而节省资源。
Golang 中实现享元模式的步骤
下面以一个文本编辑器中字符渲染为例，展示如何在 Golang 中应用享元模式。
立即学习“go语言免费学习笔记（深入）”；
假设我们要渲染大量字符，每个字符有字体、颜色、大小等样式信息（内部状态），以及位置坐标（外部状态）。1. 定义享元接口或结构体
定义一个表示字符样式的结构体，作为可共享的享元对象：
Golang Uber Dig
下载
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
type CharacterStyle struct {
Font string
Size int
Color string
}
func NewCharacterStyle(font string, size int, color string) *CharacterStyle {
return &CharacterStyle{Font: font, Size: size, Color: color}
}
2. 创建享元工厂管理对象池
使用 map 缓存已创建的样式对象，确保相同样式的对象只创建一次：
type StyleFactory struct {
styles map[string]*CharacterStyle
}
func NewStyleFactory() *StyleFactory {
return &StyleFactory{
styles: make(map[string]*CharacterStyle),
}
}
// getKey 用于生成唯一键，标识一种样式组合
func (f *StyleFactory) getKey(font string, size int, color string) string {
return fmt.Sprintf("%s-%d-%s", font, size, color)
}
func (f *StyleFactory) GetStyle(font string, size int, color string) *CharacterStyle {
key := f.getKey(font, size, color)
if style, exists := f.styles[key]; exists {
return style
}
newStyle := NewCharacterStyle(font, size, color)
f.styles[key] = newStyle
return newStyle
}
3. 定义使用外部状态的上下文对象
字符本身还包含位置等外部状态，这部分不被共享：
type Character struct {
symbol rune
x, y int // 外部状态
style *CharacterStyle
}
func NewCharacter(symbol rune, x, y int, style *CharacterStyle) *Character {
return &Character{
symbol: symbol,
x: x,
y: y,
style: style,
}
}
func (c *Character) Display() {
fmt.Printf("Char '%c' at (%d,%d) with style: %+v\n", c.symbol, c.x, c.y, c.style)
}
4. 使用示例
在主程序中使用享元工厂创建共享样式，并结合不同位置绘制字符：
func main() {
factory := NewStyleFactory()
// 获取共享样式
style1 := factory.GetStyle("Arial", 12, "black")
style2 := factory.GetStyle("Times", 14, "red")
style3 := factory.GetStyle("Arial", 12, "black") // 相同样式，应复用
// 创建多个字符，复用 style1 和 style2
chars := []*Character{
NewCharacter('H', 0, 0, style1),
NewCharacter('e', 10, 0, style1),
NewCharacter('l', 20, 0, style2),
NewCharacter('l', 30, 0, style1),
NewCharacter('o', 40, 0, style3), // 使用与 style1 相同的实例
}
for _, c := range chars {
c.Display()
}
// 验证 style1 和 style3 是否为同一实例
fmt.Printf("style1 == style3: %t\n", style1 == style3)
}
输出结果会显示，尽管多次请求相同样式，实际只创建了一次，实现了对象复用。
适用场景与注意事项
- 当程序需要创建大量相似对象时，适合使用享元模式优化内存。
- 内部状态必须是不可变的，否则共享会导致数据错乱。
- 外部状态需由调用方维护并在运行时传入。
- 并发环境下，享元工厂应保证线程安全，例如使用读写锁保护 map。
基本上就这些。Golang 虽无继承机制，但通过结构体组合和接口依然能优雅地实现享元模式，关键在于识别可共享的状态并合理设计对象结构。
