1. 概述

享元（Flyweight）模式采用共享方式向客户端提供数量庞大的细粒度对象。

所谓细粒度对象，是指实现了业务细节并相互独立的对象。细粒度对象是一种相对概念，一般不会进行更小粒度的拆分。

1.1角色

抽象享元（Flyweight）：
- 通常是一个接口或抽象类
- 它声明了具体享元类的公共方法
具体享元（Concrete Flyweight）
- 实现了抽象享元
- 包含内部状态和外部状态
  - 内部状态：不可以被改变
  - 外部状态：可以被改变
- 通常每一个具体享元类提供唯一的享元对象（可参考单例模式）
享元工厂（Flyweight Factory）：
- 负责创建和管理享元角色
- 它是享元的聚合，通常为：HashMap[key]Flyweight

当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

1.2 类图

2. 代码示例

2.1 设计

定义一个抽象棋子（抽象享元）
它的实现是黑子、白子两个实际享元
- 它的不变部分：颜色、形状
  - 它的Create()方法用来设置这些不可变部分
- 它的可变部分：位置
  - 它的Set()方法用来设置位置
定义一个享元工厂
- 它应该包含两个享元
  - 1号享元黑子
  - 2号享元白子
- 它的Get方法用来生产棋子
  - 如果有需要的棋子则返回查到的结果
  - 如果没有需要的棋子则创建该棋子
调用
- 创建一个享元工厂
- 下第一颗子
  - 用享元工厂Get()方法实例化一个黑子
    - 此时享元工厂中没有黑子享元，它会创建一个黑子享元并返回。（当然这个过程用户看不出来，想看的话你可以在这之前打印享元工厂或者调试）
  - 用黑子的Set()方法设置这颗棋子的位置
  - 查看结果
- 下第二颗子，也是白子的第一颗子
  - 用享元工厂Get()方法实例化一个白子
    - 此时享元工厂中没有白子享元，它会创建一个白子享元并返回。（当然这个过程用户看不出来，想看的话你可以在这之前打印享元工厂或者调试）
  - 用黑子的Set()方法设置这颗棋子的位置
  - 查看结果
- 下第三颗子，也是黑子的第三颗子
  - 用享元工厂Get()方法实例化一个黑子
    - 此时享元工厂已经有黑子享元，它会直接返回这个享元。（当然这个过程用户看不出来，想看的话你可以在这之前打印享元工厂或者调试）
  - 用黑子的Set()方法设置这颗棋子的位置
  - 查看结果

2.2 代码

package mainimport ("errors""fmt"
)//定义一个抽象享元
type Flyweight interface {Create()Set(x int64, y int64)Get()
}
//定义一个实际享元（白色棋子）
type ConcreteFlyweightA struct {//它的不变部分Color stringShape string//它的可变部分PostX int64PostY int64
}
//定义设置不变部分的方法（设置棋子本身）
func (c *ConcreteFlyweightA) Create() {c.Color = "黑色"c.Shape = "圆形"
}
//定义设置可变部分的方法（棋子的位置）
func (c *ConcreteFlyweightA) Set(x int64, y int64) {c.PostX = xc.PostY = y
}
//查看方法
func (c *ConcreteFlyweightA) Get() {fmt.Printf("%+v\n", c)
}
//定义另一个具体享元（黑子），和第一个类似
type ConcreteFlyweightB struct {Color stringShape stringPostX int64PostY int64
}
//定义设置不变部分的方法（设置棋子本身）
func (c *ConcreteFlyweightB) Create() {c.Color = "白色"c.Shape = "圆形"
}
//定义设置可变部分的方法（棋子的位置）
func (c *ConcreteFlyweightB) Set(x int64, y int64) {c.PostX = xc.PostY = y
}
//查看方法
func (c *ConcreteFlyweightB) Get() {fmt.Printf("%+v\n", c)
}
//定义享元工厂，它包含所需的享元且用key标识
type FlyweightFactory struct {Flyweights map[int64]Flyweight
}
//定义创建享元的方法。如果找到就返回，找不到就创建
func (f *FlyweightFactory) Get(id int64) (flyweight Flyweight, err error) {flyweight, ok := f.Flyweights[id]if ok {return flyweight, nil} else {switch id {case 1:flyweight = &ConcreteFlyweightA{}flyweight.Create()f.Flyweights[1] = flyweightreturn flyweight, nilcase 2:flyweight = &ConcreteFlyweightB{}flyweight.Create()f.Flyweights[2] = flyweightreturn flyweight, nildefault:errors.New("id无效")return nil, err}}
}func main() {//实例化一个享元工厂flyweightFactory := FlyweightFactory{Flyweights: make(map[int64]Flyweight),}fmt.Println("=========黑棋落第一个子=========")//实例化第一个黑子，因为享元工厂中没有复合条件的棋子，因此会创建一个享元返回flyweight001, err := flyweightFactory.Get(1)if err != nil {return}//设置该棋子的位置flyweight001.Set(3, 3)//查看结果flyweight001.Get()fmt.Println("=========白棋落第一个子=========")//实例化第一个白子，因为享元工厂中没有复合条件的棋子，因此会创建一个享元返回flyweight002, err := flyweightFactory.Get(2)if err != nil {return}//设置该棋子的位置flyweight002.Set(17, 4)//查看结果flyweight002.Get()fmt.Println("=========黑棋落第二个子=========")//实例化第二个黑子，此时享元工厂有复合条件的享元，返回查到的结果（但是我们封装到工厂里，用户并不能察觉是创建还是复制）flyweight003, err := flyweightFactory.Get(1)if err != nil {return}//设置该棋子的位置flyweight003.Set(3, 17)//查看结果flyweight003.Get()
}

输出

=========黑棋落第一个子=========
&{Color:黑色 Shape:圆形 PostX:3 PostY:3} 
=========白棋落第一个子=========
&{Color:白色 Shape:圆形 PostX:17 PostY:4}
=========黑棋落第二个子=========
&{Color:黑色 Shape:圆形 PostX:3 PostY:17}