若转载教程，请注明出自SW-X框架官方文档！

    1. <?php
    2. /**
    3.  * 设计模式之享元模式
    4.  * 场景：缓存调用 - 当需要重复调用一个工厂生产模型时，我们往往可以把这个模型实例缓存起来，以便多次重复调用，减少内存消耗。
    5.  * 小黄牛
    6.  */
    7. header("Content-type: text/html; charset=utf-8");
    8. # 动物接口
    9. interface AnimalInterface{
    10.     public function getType();
    11. }
    12. /**
    13.  * 创建 - 鸡模型
    14.  */
    15. class ChiCken implements AnimalInterface{
    16.     public function getType(){
    17.         echo "这是一只鸡~<br/>";
    18.     }
    19. }
    20. /**
    21.  * 创建 - 猪模型
    22.  */
    23. class Pig implements AnimalInterface{
    24.     public function getType(){
    25.         echo "这是一只猪~<br/>";
    26.     }
    27. }
    28. # 农场缓存池
    29. class Farm{
    30.     private $_farmMap = array(); // 对象缓存池
    31.     public function Produce($type){
    32.         # 对象缓存池判断
    33.         if (key_exists($type, $this->_farmMap)) {
    34.             echo "来自缓存池-> ";
    35.             return $this->_farmMap[$type]; // 返回缓存
    36.         }
    37.         # 建立缓存
    38.         switch ($type) {
    39.         case 'chicken':
    40.             return $this->_farmMap[$type] =  new Chicken();
    41.             break;
    42.         case 'pig':
    43.             return $this->_farmMap[$type] =  new Pig();
    44.             break;
    45.         }
    46.     }
    47. }
    48. # 初始化一个缓存池
    49. $farm = new Farm();
    50. # 成产一只鸡
    51. $farm->Produce('chicken')->getType();
    52. # 再生产一只鸡
    53. $farm->Produce('chicken')->getType();
    54. # 再生产一只鸡
    55. $farm->Produce('chicken')->getType();
    56. # 生产一只猪
    57. $farm->Produce('pig')->getType();
    58. # 再生产一只猪
    59. $farm->Produce('pig')->getType();
    60. # 再生产一只猪
    61. $farm->Produce('pig')->getType();

    浏览器输出

    1. 这是一只鸡~
    2. 来自缓存池-> 这是一只鸡~
    3. 来自缓存池-> 这是一只鸡~
    4. 这是一只猪~
    5. 来自缓存池-> 这是一只猪~
    6. 来自缓存池-> 这是一只猪~

    享元模式

    1. 享元工厂角色（FWFactory）：创建并管理BlogModel对象。
    2. 所有具体享元父接口角色（BolgModel）：接受并作用与外部状态。
    3. 具体享元角色（JobsBlog）：具体变化点，为内部对象增加储存空间。

    优点

    1. 1.减少运行时对象实例的个数，节省内存
    2. 2.将许多“虚拟”对象的状态集中管理

    缺点
    一旦被实现，单个的逻辑实现将无法拥有独立而不同的行为
    使用场景

    1. 就是缓存了创建型模式创建的对象，不知道为什么会归在结构型模式中，个人觉得创建型模式更合适，哈哈～
    2. 其次，享元强调的缓存对象，外观模式强调的对外保持简单易用，是不是就大体构成了目前牛逼哄哄且满大街的【依赖注入容器】
    3. 当一个类有许多的实例，而这些实例能被同一方法控制的时候，我们就可以使用享元模式。