设计模式之享元模式

一、背景

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。
例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景

二、定义

享元（Flyweight）模式的定义：Flyweight是“轻量级”的意思，指的是拳击比赛中，选手体重最轻的登记。顾名思义，该设计模式的作用是为了让对象变“轻”。运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

• 内部状态指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；
• 外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

2.1. 模式的结构

享元模式的主要角色有如下。

1. 抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
2. 具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
3. 非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
4. 享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

图 1 是享元模式的结构图，其中：

• UnsharedConcreteFlyweight 是非享元角色，里面包含了非共享的外部状态信息 info；
• Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；
• ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；
• FlyweightFactory 是享元工厂角色，它是关键字 key 来管理具体享元；
• 客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

 2.2 代码

using System;
using System.Collections.Generic;

namespace ConsoleApp1
{
    /// <summary>
    /// 非享元角色
    /// </summary>
    class UnsharedConcreteFlyweight
    {
        private String info;
        public UnsharedConcreteFlyweight(String info)
        {
            this.info = info;
        }
        public String getInfo()
        {
            return info;
        }
        public void setInfo(String info)
        {
            this.info = info;
        }
    }

    /// <summary>
    /// 抽象享元角色
    /// </summary>
    interface Flyweight
    {
        void operation(UnsharedConcreteFlyweight state);
    }

    /// <summary>
    /// 具体享元角色
    /// </summary>
    class ConcreteFlyweight : Flyweight
    {
        private String key;
        public ConcreteFlyweight(String key)
        {
            this.key = key;
            Console.WriteLine("具体享元" + key + "被创建！");
        }
        public void operation(UnsharedConcreteFlyweight outState)
        {
            Console.WriteLine("具体享元" + key + "被调用，");
            Console.WriteLine("非享元信息是:" + outState.getInfo());
        }
    }

    /// <summary>
    /// 享元工厂角色
    /// </summary>
    class FlyweightFactory
    {
        private Dictionary<String, Flyweight> flyweights = new Dictionary<String, Flyweight>();
        public Flyweight getFlyweight(String key)
        {
            Flyweight flyweight = null;
            flyweights.TryGetValue(key, out flyweight);
            if (flyweight != null)
            {
                Console.WriteLine("具体享元" + key + "已经存在，被成功获取！");
            }
            else
            {
                flyweight = new ConcreteFlyweight(key);
                flyweights.Add(key, flyweight);
            }
            return flyweight;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            FlyweightFactory factory = new FlyweightFactory();
            Flyweight f01 = factory.getFlyweight("a");
            Flyweight f02 = factory.getFlyweight("a");
            Flyweight f03 = factory.getFlyweight("a");
            Flyweight f11 = factory.getFlyweight("b");
            Flyweight f12 = factory.getFlyweight("b");
            f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
            f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));
            f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));
            f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));
            f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
            Console.ReadKey();
        }
    }
}

运行结果

三、总结

应用场景：

1、C# 中的 String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面。

2、数据库的数据池。

优点：它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份；享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享

缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

参考：

http://c.biancheng.net/view/1371.html

https://blog.csdn.net/justloveyou_/article/details/55045638