阅读 248

设计模式:享元模式

享元模式(Flyweight Pattern)主要用于减少创建对象的数量,以减少内存占用和提高性能。这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结构的方式。

简介

重复字母

如上图所示,“hello world”中“L”出现了3次,为了节省开始,我们显然不需要重复创建三次“L”,享元模式正是为了应对此类情况的一种设计模式。

享元模式主要解决的问题:在有大量对象时,有可能会造成内存溢出,我们把其中共同的部分抽象出来,如果有相同的业务请求,直接返回在内存中已有的对象,避免重新创建。

应用flyweight设计模式之前,我们需要考虑以下因素:

1.应用程序要创建的对象数量很大;

2.对象创建在内存上很重要,也可能很耗时;

3.对象属性可以分为内在属性和外在属性,对象的外在属性应该由客户端程序定义。

结构

首先需要将Object的属性划分为内部属性和外部属性:

内部属性:可共享状态,享元对象分组依据;

外部属性:不共享的状态,每一个具体享元对象不同。

享元模式中主要包含以下三个构成:

1.抽象享元(FlyWeight):给出抽象接口,规定所有具体享元角色需要实现的方法;

2.具体享元(ConcreteFlyWeight):实现抽象享元所规定出的接口;存储内部状态;

3.不共享具体工厂(UnsharedConcreteFlyweight):Flyweight接口使共享成为可能,但它并不强制共享。在Flyweight对象结构的某些层次,UnsharedConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点;

4.享元工厂(FlyWeightFactory):创建和管理享元角色,保证享元对象可被共享;主要通过HashMap来实现。

其结构如下图所示:

FlyWeight结构

示例

以军队士兵为例,下面是一个享元模式的示例: 军队中的士兵可以分为很多种类,例如步兵,侦察兵等等; 在这种情况下,可以按照种类对士兵进行分组,同种类士兵共享相同的内部状态。在创建士兵时,与士兵种类相关的内部状态不会被重复的创建,而每个士兵的外部状态(在本示例中是士兵的位置)则各不相同。

protocol Soldier {
  func render(from location: CGPoint, to newLocation: CGPoint)
}
复制代码

Soldier为抽象享元,规定出士兵所需要实现的方法。

class Infantry: Soldier {
  
  private let modelData: Data
  
  init(modelData: Data) {
    self.modelData = modelData
  }
  
  func render(from location: CGPoint, to newLocation: CGPoint) {
    // Remove rendering from original location
    // Graphically render at new location
  }
}
复制代码

Infantry为具体享元,其中modelData即为可被共享的内部状态,被种类为Infantry的士兵共享。

class SoldierClient {
  
  // 1
  var currentLocation: CGPoint
  
  // 2
  let soldier: Soldier
  
  init(currentLocation: CGPoint, soldier: Soldier) {
    self.currentLocation = currentLocation
    self.soldier = soldier
  }
  
  // 3
  func moveSoldier(to nextLocation: CGPoint) {
    soldier.render(from: currentLocation, to: nextLocation)
    currentLocation = nextLocation
  }
}
复制代码

SoldierClient为具体生成的每一个士兵对象,其中保存了外部状态,也就是位置:currentLocation;同时也保存了享元的inference,这样,每次生成士兵对象时,可被共享的享元部分不会被重复生成。

class SoldierFactory {
  
  // 1
  enum SoldierType {
    case infantry
  }
  
  // 2
  private var availableSoldiers =  [SoldierType: Soldier]()
  
  // 3
  static let sharedInstance = SoldierFactory()
  
  private init(){}
  
  private func createSoldier(of type: SoldierType) -> Soldier {
    switch type {
    case .infantry:
      let infantry = Infantry(modelData: Data())
      availableSoldiers[type] = infantry
      return infantry
    }
  }
  
  // 4
  func getSoldier(type: SoldierType) -> Soldier {
    if let soldier = availableSoldiers[type] {
      return soldier
    } else {
      let soldier = createSoldier(of: type)
      return soldier
    }
  }
}
复制代码

SoldierFactory为享元工厂。享元工厂负责生成和管理享元,采用hashmap以保证同类的享元不会被重复生成。每次生成享元时,如果次类享元已存在,直接返回存在的享元,如果不存在,则生成新的。

let soldierFactory = SoldierFactory.sharedInstance
let infantry = soldierFactory.getSoldier(type: .infantry)
let firstSoldier = SoldierClient(currentLocation: CGPoint.zero, soldier: infantry)
let secondSoldier = SoldierClient(currentLocation: CGPoint(x: 5, y: 10), soldier: infantry)

firstSoldier.moveSoldier(to: CGPoint(x: 1, y: 5))
复制代码

在主函数中,首先通过SoldierFactory生成种类为infantry的享元,接下来生成士兵。 firstSoldier,secondSoldier种类都为infantry,此时享元infantry不会被重复的生成,被士兵共享;而士兵可以具有不同的外部状态(位置)。

通过上面的例子可以看出,在需要大量重复生成对象时,通过享元模式,可以实现分组后可被共享的状态不被重复生成,从而降低内存消耗,提高效率。

总结

优点:大大减少对象的创建,降低系统的内存,使效率提高

缺点:需要分离出外部状态和内部状态,提高了系统的复杂度

参考:

Article by Guo Dong