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 main

import (
	"errors"
	"fmt"
)

//定义一个抽象享元
type Flyweight interface {
	Create()
	Set(x int64, y int64)
	Get()
}
//定义一个实际享元（白色棋子）
type ConcreteFlyweightA struct {
    //它的不变部分
	Color string
	Shape string
	//它的可变部分
	PostX int64
	PostY int64
}
//定义设置不变部分的方法（设置棋子本身）
func (c *ConcreteFlyweightA) Create() {
	c.Color = "黑色"
	c.Shape = "圆形"
}
//定义设置可变部分的方法（棋子的位置）
func (c *ConcreteFlyweightA) Set(x int64, y int64) {
	c.PostX = x
	c.PostY = y
}
//查看方法
func (c *ConcreteFlyweightA) Get() {
	fmt.Printf("%+v\n", c)
}
//定义另一个具体享元（黑子），和第一个类似
type ConcreteFlyweightB struct {
	Color string
	Shape string
	PostX int64
	PostY int64
}
//定义设置不变部分的方法（设置棋子本身）
func (c *ConcreteFlyweightB) Create() {
	c.Color = "白色"
	c.Shape = "圆形"
}
//定义设置可变部分的方法（棋子的位置）
func (c *ConcreteFlyweightB) Set(x int64, y int64) {
	c.PostX = x
	c.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] = flyweight
			return flyweight, nil
		case 2:
			flyweight = &ConcreteFlyweightB{}
			flyweight.Create()
			f.Flyweights[2] = flyweight
			return flyweight, nil
		default:
			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}

2.3 类图示例

这里我们的客户端实际是调用了Flyweight接口
当然我们也可以如示例中一样直接调用每一个实际享元。

---