设计模式(9) - Flyweight享元模式

目录

1.意图

2.UML类图

3.代码实现

4.总结

---

1.意图

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

“共享” 是享元模式的精髓，将那些数量众多的，具有很多内部状态而很少的外部状态的对象进行共享，就是享元模式的使用方式。

如本篇中的例子所示：在一个大型游戏中，每一局的内部，存在大量的细粒度的实例对象：
    --各个角色的数量众多，成百上千。
    --每个角色都有大量的内部状态，如战斗力值，武器，位置，队伍等等，很多属性。这些内部属性，不会随着客户端多少而改变。也就是不管玩家有多少，角色属性是唯一的。
    --每个角色的外部状态很少。上面所说的属性值，基本都是内部状态，存储在服务端。与客户端相关的属性，相对很少。

2.UML类图

  享元模式共分为四种角色：

1. Flyweight（抽象享元类）：通常是一个接口或者是抽象类，在抽象享元类中声明了共享享元类的公共方法，通过这些方法可以访问享元类的内部数据（内部状态），也可以设置享元类的外部数据（外部状态）
2. Concrete Flyweight（共享具体享元类）：实现抽象享元类，其实例称为享元对象，一般为单例模式，提供唯一的享元对象
3. UnsharedConcrete Flyweight（非共享具体享元类）：实现抽象享元类，但是不共享，通过构造函数进行实例化
4. Flyweight Factory（享元工厂类）：创建并管理享元对象，以内部的键值对结构存储享元对象

3.代码实现

  如第1节所说，我们使用一个游戏相关的代码场景，来说明享元模式。

  在一个游戏中，会有大量的角色对象，且这些对象的创建成本比较高。如果每次都需要服务端动态创建大量的这种类似的重复的对象，服务端压力巨大。这时候，就是享元模式减少内存并提高性能的绝佳机会。

#include <iostream>
#include <map>
#include <string>

enum WeaponType {
    Minigun = 1,  //机枪
    Pistol  = 2,  //手枪
    Knife   = 3,  //刺刀
};
enum RoleType {
    EagleAlpha  = 1,
    EagleBeta   = 2,
    WolfAlpha   = 3,
    WolfBeta    = 4,
};

class Role {
public:
    virtual void SetWeapon(WeaponType wt) = 0;
    virtual std::string Desription() = 0;
};

//鹰队
class EagleTeam : public Role {
public:
    EagleTeam(int power) : power(power) {}
    void SetWeapon(WeaponType wt) {
        weapon = wt;
    }
    std::string Desription() {
        char buffer[20];
        sprintf_s(buffer, sizeof(buffer), "%p", this);
        return "Eagle with power:" + std::to_string(power) + ", weapon:" + std::to_string(weapon) + ", objPtr:" + buffer;
    }
private:
    int power;  //战斗力值
    WeaponType weapon;  //武器类型
};

//狼队
class WolfTeam : public Role {
public:
    WolfTeam(int power) : power(power) {}
    void SetWeapon(WeaponType wt) {
        weapon = wt;
    }
    std::string Desription() {
        char buffer[20];
        sprintf_s(buffer, sizeof(buffer), "%p", this);
        return "Wolf with power:" + std::to_string(power) + ", weapon:" + std::to_string(weapon) + ", objPtr:" + buffer;
    }
private:
    int power;  //战斗力值
    WeaponType weapon;  //武器类型
};

class RoleFactory {
public:
    Role* GetRole(RoleType roleType) {
        auto iter = roles.find(roleType);
        if (iter != roles.end()) {
            return iter->second;
        }
        Role* r = NULL;
        switch (roleType) {
        case WolfAlpha:
        {
            r = new WolfTeam(100);
            r->SetWeapon(Minigun);
            roles[roleType] = r;
            break;
        }
        case WolfBeta:
        {
            r = new WolfTeam(60);
            r->SetWeapon(Pistol);
            roles[roleType] = r;
            break;
        }
        case EagleAlpha:
        {
            r = new EagleTeam(80);
            r->SetWeapon(Pistol);
            roles[roleType] = r;
            break;
        }
        case EagleBeta:
        {
            r = new EagleTeam(40);
            r->SetWeapon(Knife);
            roles[roleType] = r;
            break;
        }
        default:
            break;
        }
        return r;
    }
private:
    std::map<RoleType, Role*> roles;
};

int main() {
    RoleFactory rf;
    Role *role = rf.GetRole(EagleAlpha);
    std::cout << role->Desription() << std::endl;
    role = rf.GetRole(EagleBeta);
    std::cout << role->Desription() << std::endl;
    role = rf.GetRole(EagleAlpha);
    std::cout << role->Desription() << std::endl;
    role = rf.GetRole(WolfBeta);
    std::cout << role->Desription() << std::endl;
    role = rf.GetRole(WolfAlpha);
    std::cout << role->Desription() << std::endl;
    role = rf.GetRole(WolfBeta);
    std::cout << role->Desription() << std::endl;
    return 0;
}

运行结果：
Eagle with power:80, weapon:2, objPtr:005ED3D8
Eagle with power:40, weapon:3, objPtr:005ED448
Eagle with power:80, weapon:2, objPtr:005ED3D8
Wolf with power:60, weapon:2, objPtr:005ED410
Wolf with power:100, weapon:1, objPtr:005ED4B8
Wolf with power:60, weapon:2, objPtr:005ED410

可以看到，相同类型的对象，是共享的（this指针地址相同）。

4.总结

享元模式的核心思想就是尽可能的共享对象，特别适用于存在大量细粒度对象，而这些对象内部状态特别多，外部状态较少的场景。

共享具体享元类与非共享具体享元类实现抽象享元类，能够保证他们对外具有一致的行为接口，为客户端的使用提供了便利，客户端通过享元工厂类获取共享享元对象。