AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

设计模式（十二）： Flyweight享元模式 -- 结构型模式

2017-03-03 1040
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
说明：
相对于其它模式，Flyweight模式在PHP实现似乎没有太大的意义，因为PHP的生命周期就在一个请求，请求执行完了，php占用的资源都被释放。我们只是为了学习而简单做了介绍。

 

1. 概述

面向对象技术可以很好地解决系统一些灵活性或可扩展性或抽象性的问题，但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时，将导致运行代价过高，带来性能下降等问题。比如:
例子1:图形应用中的图元等对象、字处理应用中的字符对象等。

2.解决方案：

          享元模式（Flyweight）：对象结构型模式运用共享技术有效地支持大量细粒度的对象。

        它使用共享物件，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件；它适合用于当大量物件只是重复因而导致无法令人接受的使用大量内存。通常物件中的部分状态是可以分享。常见做法是把它们放在外部数据结构，当需要使用时再将它们传递给享元。

 

4. 适用性

1）一个应用程序使用大量相同或者相似的对象，造成很大的存储开销。

2）对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。

3）如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。

4） 应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。

5）使用享元模式需要维护一个存储享元对象的享元池，而这需要耗费资源，因此，应当在多次重复使用享元对象时才值得使用享元模式

5.结构


6.构建模式的组成

1) 抽象享元类(Flyweight): 描述一个接口，通过这个接口flyweight可以接受并作用于外部状态。
2) 具体享元类(ConcreteFlyweight):实现Flyweight接口 ，并为内部状态（ 如果有的话 )增加存储空间 。ConcreteFlyweight对象必须是可共享的。它所存储的状态必须是内部的；即，它必须独立于ConcreteFlyweight对象的场景。
3) 非共享具体享元类(UnsharedConcreteFlyweight)：— 并非所有的Flyweight子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共享。在Flyweight对象结构的某些层次，UnsharedConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点。
4) 享元工厂类(FlyweightFactory):创建并管理flyweight对象, 确保合理地共享flyweight。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象   flyweight的时候，享元工厂角色（Flyweight Factory对象）会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
5）客户（Client）:维持一个对flyweight的引用。计算或存储一个（多个）flyweight的外部状态。

7. 效果

 

享元模式的优点：
1）享元模式的优点在于它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份。
2）享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。
享元模式的缺点：
1）享元模式使得系统更加复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
2）为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。

8.实现

享元模式可以分成单纯享元模式和复合享元模式两种形式。

【单纯享元模式】

在单纯的享元模式中，所有的享元对象都是可以共享的。

源代码：

 

  1. <?php  
  2.   
  3. /** 
  4.  * 单纯享元模式　 
  5.  * @author guisu 
  6.  */  
  7.   
  8. /** 
  9.  * 抽象享元角色 
  10.  */  
  11. abstract class Flyweight {  
  12.   
  13.     /** 
  14.      * 示意性方法 
  15.      * @param string $state 外部状态 
  16.      */  
  17.     abstract public function operation($state);  
  18. }  
  19.   
  20. /** 
  21.  * 具体享元角色 
  22.  */  
  23. class ConcreteFlyweight extends Flyweight {  
  24.   
  25.     private $_intrinsicState = null;  
  26.   
  27.     /** 
  28.      * 构造方法 
  29.      * @param string $state  内部状态 
  30.      */  
  31.     public function __construct($state) {  
  32.         $this->_intrinsicState = $state;  
  33.     }  
  34.   
  35.     public function operation($state) {  
  36.         echo 'ConcreteFlyweight operation, Intrinsic State = ' . $this->_intrinsicState  
  37.         . ' Extrinsic State = ' . $state . '<br />';  
  38.     }  
  39.   
  40. }  
  41.   
  42.   
  43. /** 
  44.  * 享元工厂角色 
  45.  */  
  46. class FlyweightFactory {  
  47.   
  48.     private $_flyweights;  
  49.   
  50.     public function __construct() {  
  51.         $this->_flyweights = array();  
  52.     }  
  53.   
  54.     public function getFlyweigth($state) {  
  55.         if (isset($this->_flyweights[$state])) {  
  56.             return $this->_flyweights[$state];  
  57.         } else {  
  58.             return $this->_flyweights[$state] = new ConcreteFlyweight($state);  
  59.         }  
  60.     }  
  61.   
  62. }  
  63.   
  64. class Client{  
  65.     static function main (){  
  66.         $flyweightFactory = new FlyweightFactory();  
  67.         $flyweight = $flyweightFactory->getFlyweigth('state A');  
  68.         $flyweight->operation('other state A');  
  69.           
  70.         $flyweight = $flyweightFactory->getFlyweigth('state B');  
  71.         $flyweight->operation('other state B');  
  72.           
  73.     }  
  74. }  
  75.   
  76.   
  77.   
  78. ?>  

【复合享元模式】
复合享元模式对象是由一些单纯享元使用合成模式加以复合而成
复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。

 

 

  1. <?php  
  2.   
  3. /** 
  4.  * 复合享元模式 
  5.  *  
  6.  */  
  7.   
  8. /** 
  9.  * 抽象享元角色 
  10.  */  
  11. abstract class Flyweight {  
  12.   
  13.     /** 
  14.      * 示意性方法 
  15.      * @param string $state 外部状态 
  16.      */  
  17.     abstract public function operation($state);  
  18. }  
  19.   
  20. /** 
  21.  * 具体享元角色 
  22.  */  
  23. class ConcreteFlyweight extends Flyweight {  
  24.   
  25.     private $_intrinsicState = null;  
  26.   
  27.     /** 
  28.      * 构造方法 
  29.      * @param string $state  内部状态 
  30.      */  
  31.     public function __construct($state) {  
  32.         $this->_intrinsicState = $state;  
  33.     }  
  34.   
  35.     public function operation($state) {  
  36.         echo 'ConcreteFlyweight operation, Intrinsic State = ' . $this->_intrinsicState  
  37.         . ' Extrinsic State = ' . $state . '<br />';  
  38.     }  
  39.   
  40. }  
  41.   
  42. /** 
  43.  * 不共享的具体享元，客户端直接调用 
  44.  */  
  45. class UnsharedConcreteFlyweight extends Flyweight {  
  46.   
  47.     private $_flyweights;  
  48.   
  49.     /** 
  50.      * 构造方法 
  51.      * @param string $state  内部状态 
  52.      */  
  53.     public function __construct() {  
  54.         $this->_flyweights = array();  
  55.     }  
  56.   
  57.     public function operation($state) {  
  58.         foreach ($this->_flyweights as $flyweight) {  
  59.             $flyweight->operation($state);  
  60.         }  
  61.     }  
  62.   
  63.     public function add($state, Flyweight $flyweight) {  
  64.         $this->_flyweights[$state] = $flyweight;  
  65.     }  
  66.   
  67. }  
  68.   
  69. /** 
  70. * 享元工厂角色 
  71. */  
  72. class FlyweightFactory {  
  73.   
  74.     private $_flyweights;  
  75.   
  76.     public function __construct() {  
  77.         $this->_flyweights = array();  
  78.     }  
  79.   
  80.     public function getFlyweigth($state) {  
  81.         if (is_array($state)) { //  复合模式  
  82.             $uFlyweight = new UnsharedConcreteFlyweight();  
  83.   
  84.             foreach ($state as $row) {  
  85.                 $uFlyweight->add($row, $this->getFlyweigth($row));  
  86.             }  
  87.             return $uFlyweight;  
  88.         } else if (is_string($state)) {  
  89.             if (isset($this->_flyweights[$state])) {  
  90.                 return $this->_flyweights[$state];  
  91.             } else {  
  92.                 return $this->_flyweights[$state] = new ConcreteFlyweight($state);  
  93.             }  
  94.         } else {  
  95.             return null;  
  96.         }  
  97.     }  
  98.   
  99. }  
  100.   
  101. class Client{  
  102.     static function main (){  
  103.         $flyweightFactory = new FlyweightFactory();  
  104.         $flyweight = $flyweightFactory->getFlyweigth('state A');  
  105.         $flyweight->operation('other state A');  
  106.           
  107.         $flyweight = $flyweightFactory->getFlyweigth('state B');  
  108.         $flyweight->operation('other state B');  
  109.           
  110.         /* 复合对象*/  
  111.         $uflyweight = $flyweightFactory->getFlyweigth(array('state A', 'state B'));  
  112.         $uflyweight->operation('other state A');  
  113.   
  114.     }  
  115. }  
  116.   
  117.   
  118. ?>  

 

9. 与其他相关模式

客户端要引用享元对象，是通过工厂对象创建或者获得的，客户端每次引用一个享元对象，都是可以通过同一个工厂对象来引用所需要的享元对象。因此，可以将享元工厂设计成单例模式，这样就可以保证客户端只引用一个工厂实例。因为所有的享元对象都是由一个工厂对象统一管理的，所以在客户端没有必要引用多个工厂对象。不管是单纯享元模式还是复合享元模式中的享元工厂角色，都可以设计成为单例模式，对于结果是不会有任何影响的。

       Composite模式：Flyweight模式通常和Composite 模式结合起来，用共享叶结点的有向无环图实现一个逻辑上的层次结构。复合享元模式实际上是单纯享元模式与合成模式的组合。单纯享元对象可以作为树叶对象来讲，是可以共享的，而复合享元对象可以作为树枝对象， 因此在复合享元角色中可以添加聚集管理方法。通常，最好用Flyweight实现State 和Strategy 对象。

10.总结

 

1)  享元模式是一个考虑系统性能的设计模式，通过使用享元模式可以节约内存空间，提高系统的性能。 
2)  享元模式的核心在于享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，用户需要对象时，首先从享元池中获取，如果享 元池中不存在，则创       建一个新的享元对象返回给用户，并在享元池中保存该新增对象。
3)   享元模式以共享的方式高效地支持大量的细粒度对象，享元对象能做到共享的关键是区分内部状态(Internal State)和外部状态(External State)。
       (1)   内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，因此内部状态可以共享。
 
       (2)   外部状态是随环境改变而改变的、不可以共享的状态。享元对象的外部状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候 再传入到享元对               象内部。一个外部状态与另一个外部状态之间是相互独立的。
 
 
 
本文转自二郎三郎博客园博客，原文链接：http://www.cnblogs.com/haore147/p/3888124.html，如需转载请自行联系原作者
文章标签：
存储
PHP
设计模式
关键词：
设计模式享元模式
设计模式flyweight
设计模式结构型模式
文艺小青年
目录
相关文章
flzjkl
|
4月前
|
设计模式 存储 缓存
【设计模式】【结构型模式】享元模式（Flyweight）
一、入门 什么是享元模式？ 享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享对象来减少内存使用，特别适用于存在大量相似对象的情况。 它的核心思想是将对象的内在状态（不变
flzjkl
172 16
摘星.
|
4月前
|
设计模式 缓存 安全
【高薪程序员必看】万字长文拆解Java并发编程！(8)：设计模式-享元模式设计指南
🌟 ​大家好，我是摘星！​ 🌟今天为大家带来的是并发编程中的经典对象复用设计模式-享元模式，废话不多说让我们直接开始。
摘星.
100 0
SlackClimb
|
7月前
|
设计模式 存储 缓存
「全网最细 + 实战源码案例」设计模式——享元模式
享元模式（Flyweight Pattern）是一种结构型设计模式，旨在减少大量相似对象的内存消耗。通过分离对象的内部状态（可共享、不变）和外部状态（依赖环境、变化），它有效减少了内存使用。适用于存在大量相似对象且需节省内存的场景。模式优点包括节省内存和提高性能，但会增加系统复杂性。实现时需将对象成员变量拆分为内在和外在状态，并通过工厂类管理享元对象。
SlackClimb
248 92
flzjkl
|
4月前
|
设计模式 Java 数据库连接
【设计模式】【结构型模式】代理模式（Proxy）
一、入门 什么是代理模式？ 代理模式（Proxy Pattern）是一种结构型设计模式，允许你提供一个代理对象来控制对另一个对象的访问。 代理对象在客户端和目标对象之间起到中介作用，可以在不改变目标对
flzjkl
105 10
flzjkl
|
4月前
|
设计模式 Java 定位技术
【设计模式】【结构型模式】组合模式（Composite）
一、入门 什么是组合模式 组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构来表示“部分-整体”的层次关系。组合模式使得客户端可以统一处理单个对象和组合对
flzjkl
137 10
flzjkl
|
4月前
|
关系型数据库 Java MySQL
【设计模式】【结构型模式】桥接模式（Bridge）
一、入门 什么是桥接模式？ 桥接模式（Bridge Pattern）是一种结构型设计模式，核心思想是将抽象与实现分离，让它们可以独立变化。简单来说，它像一座“桥”连接了两个维度的变化，避免用继承导致代
flzjkl
292 10
flzjkl
|
4月前
|
设计模式 前端开发 Java
【设计模式】【结构型模式】适配器模式（Adpter）
一、入门 什么是适配器模式？ 适配器模式是Java中常用的结构型设计模式，它的核心作用就像现实中的电源转换器一样---让原本不兼容的两个接口能够协同工作。 为什么要用适配器模式？ 假设我们需要在电商系
flzjkl
110 10
flzjkl
|
4月前
|
设计模式 Java 数据库连接
【设计模式】【结构型模式】外观模式（Facde）
一、入门 什么是外观模式？ 一种结构型设计模式，通过为子系统中的一组接口提供一个统一的高层接口（称为外观），来简化客户端与复杂子系统的交互过程。其本质是建立抽象层来隔离复杂度。 为什么要有外观模式？
flzjkl
199 9
flzjkl
|
4月前
|
设计模式 缓存 安全
【设计模式】【结构型模式】装饰者模式（Decorator）
一、入门 什么是装饰者模式？ 装饰者模式（Decorator Pattern）是 Java 中常用的结构型设计模式，它能在不修改原有对象结构的前提下，动态地为对象添加额外的职责。 为什么要装饰者模式？
flzjkl
83 8
热爱技术的小郑
|
设计模式 存储 Java
【九】设计模式~~~结构型模式~~~外观模式（Java）
文章详细介绍了外观模式（Facade Pattern），这是一种对象结构型模式，通过引入一个外观类来简化客户端与多个子系统之间的交互，降低系统的耦合度，并提供一个统一的高层接口来使用子系统。通过文件加密模块的实例，展示了外观模式的动机、定义、结构、优点、缺点以及适用场景，并讨论了如何通过引入抽象外观类来提高系统的可扩展性。
热爱技术的小郑
175 1
【九】设计模式~~~结构型模式~~~外观模式（Java）