场景
网络联机下棋的时候，一台服务器连接了多个客户端（玩家），如果我们每个棋子都要创建对象，那一盘棋可能就有上百个对象产生，玩家多点的话，因为内存空间有限，一台服务器就难以支持了
问题来了
当一个软件系统在运行时产生的对象数量太多，将导致运行代价过高，带来系统性能下降等问题
问题改进
使用享元模式来设计该下棋软件的棋子对象，可实现节约内存进而提高系统性能
表述 (结构型模式)
运用共享技术有效地支持大量细粒度对象的复用
享元（flyweight）模式是一种用于性能优化的模式，“fly”在这里是苍蝇的意思，意为蝇量级。如果系统中因为创建了大量类似的对象而导致内存占用过高，享元模式就非常有用了，享元模式通过共享技术实现相同或相似对象的重用，存储这些共享实例对象的地方称为享元池(Flyweight Pool)
因为要求细粒度对象，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态(Intrinsic State)和外部状态(Extrinsic State)
- 内部状态：内部状态是存储在享元对象内部，并且不会随环境改变而改变的状态
- 外部状态：随环境改变而改变的、不可以共享的状态
享元模式类图
享元模式类图
-
Flyweight（抽象享元类）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）
-
ConcreteFlyweight（具体享元类）：继承抽象享元类实现其方法，其实例称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象
-
UnsharedConcreteFlyweight（非共享具体享元类）：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建
-
FlyweightFactory（享元工厂类）：享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中，享元池一般设计为一个存储“键值对”的集合（也可以是其他类型的集合），可以结合工厂模式进行设计；当用户请求一个具体享元对象时，首先从享元池中获取，如果享元池中不存在，则创建一个新的享元对象返回给用户，并在享元池中保存该新增对象
优点
- 可以极大减少内存中对象的数量，使得相同或相似对象在内存中只保存一份，从而可以节约系统资源，提高系统性能
- 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享
缺点
- 享元模式使得系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化
- 为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长
使用场景
- 一个系统有大量相同或者相似的对象，造成内存的大量耗费
- 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中
- 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式
示例（需求V1:不带外部状态，需求V2:带外部状态）
需求V1：网络联机下棋的时候，一台服务器连接了多个客户端（玩家），如果我们每个棋子都要创建对象，那一盘棋可能就有上百个对象产生，玩家多点的话，因为内存空间有限，一台服务器就难以支持了,为了节约存储空间，提高系统性能,我们使用享元模式实现
享元类
//定义抽象享元类
class Gobang {
func getColor() -> String {
return ""
}
func display() {
print("棋子颜色:\(self.getColor())")
}
}
//定义具体享元类--黑色棋子
class BlackGobang : Gobang {
override func getColor() -> String {
return "黑色"
}
}
//定义具体享元类--白色棋子
class WriteGobang : Gobang {
override func getColor() -> String {
return "白色"
}
}
享元工厂
//享元工厂(使用单例模式进行设计)
class GobangFactory {
private static let singleInstance = GobangFactory()
private init() {}
class func defaultSingleInstance() ->GobangFactory {
return singleInstance
}
var gobangDic = [String:Gobang]() //享元池
func getGobang(key:String) -> Gobang {
if !gobangDic.keys.contains(key) {
if key == "black" {
print("新建黑色棋子")
gobangDic[key] = BlackGobang.init()
}else{
print("新建白色棋子")
gobangDic[key] = WriteGobang.init()
}
}
return gobangDic[key]!
}
}
客户端
let factory = GobangFactory.defaultSingleInstance()
let black1 = factory.getGobang(key: "black")
black1.display()
let write1 = factory.getGobang(key: "write")
write1.display()
let black2 = factory.getGobang(key: "black")
black2.display()
let write2 = factory.getGobang(key: "write")
write2.display()
let black3 = factory.getGobang(key: "black")
black3.display()
let write3 = factory.getGobang(key: "write")
write3.display()
//新建黑色棋子
//棋子颜色:黑色
//新建白色棋子
//棋子颜色:白色
//棋子颜色:黑色
//棋子颜色:白色
//棋子颜色:黑色
//棋子颜色:白色
需求V2：将黑色棋子和白色棋子显示在棋盘的不同位置
增加一个坐标类Location
class Location {
var x:Int
var y:Int
init(x:Int,y:Int) {
self.x = x
self.y = y
}
func setX(x:Int) {
self.x = x
}
func setY(y:Int) {
self.y = y
}
func getX() -> Int{
return self.x
}
func getY() -> Int{
return self.y
}
}
修改抽象享元类
//定义抽象享元类
class Gobang {
func getColor() -> String {
return ""
}
func display(location:Location) {
print("棋子颜色:\(self.getColor()), 坐标是\(location.getX()),\(location.getY())")
}
}
客户端调用
let factory = GobangFactory.defaultSingleInstance()
let black1 = factory.getGobang(key: "black")
black1.display(location: Location.init(x: 1, y: 2))
let write1 = factory.getGobang(key: "write")
black1.display(location: Location.init(x: 2, y: 3))
let black2 = factory.getGobang(key: "black")
black2.display(location: Location.init(x: 3, y: 4))
let write2 = factory.getGobang(key: "write")
black2.display(location: Location.init(x: 4, y: 5))
let black3 = factory.getGobang(key: "black")
black3.display(location: Location.init(x: 5, y: 6))
let write3 = factory.getGobang(key: "write")
black3.display(location: Location.init(x: 6, y: 7))
//log:
//新建黑色棋子
//棋子颜色:黑色, 坐标是1,2
//新建白色棋子
//棋子颜色:黑色, 坐标是2,3
//棋子颜色:黑色, 坐标是3,4
//棋子颜色:黑色, 坐标是4,5
//棋子颜色:黑色, 坐标是5,6
//棋子颜色:黑色, 坐标是6,7
网友评论