Serialize/Unserialize破坏单例

·        作者: Laruence(   )
·        本文地址: http://www.laruence.com/2011/03/18/1909.html
·        转载请注明出处
我们经常采用如下方式定义单列:
1.       class Singleton {
2.           private
static$instance = NULL;
3.        
4.           /**
不容许直接调用构造函数 */
5.           private
function__construct() {
6.        
7.           }
8.        
9.           /**
不容许深度复制 */
10.        private
function__clone() {
11.        }
12.     
13.        public
staticfunctiongetInstance() {
14.            if (NULL === self::$instance)
{
15.                 self::$instance =
newself();
16.              }
17.     
18.            return self::$instance;
19.        }
20.    }
很多人都会记得对深度copy的保护,
但, 其实我们却疏忽了一点:
1.       <?php
2.       $a = Singleton::getInstance();
3.       $b =
unserialize(serialize($a));
4.        
5.       var_dump($a ===
$b);
6.       //bool(false)
呵呵,
可见还需要修补,
加上对序列化的保护:
1.       class Singleton {
2.           private
static$instance = NULL;
3.        
4.           /**
不容许直接调用构造函数 */
5.           private
function__construct() {
6.        
7.           }
8.        
9.           /**
不容许深度复制 */
10.        private
function__clone() {
11.        }
12.     
13.        /**
不容许serialize */
14.        private
function__sleep() {
15.        }
16.     
17.        /**
不容许unserialize */
18.        private 
function__wakeup() {
19.        }

20.     
21.        public
staticfunctiongetInstance() {
22.            if (NULL === self::$instance)
{
23.                 self::$instance =
newself();
24.              }
25.     
26.            return self::$instance;
27.        }
28.    }
然而,
有的时候我们是希望我们的单利类是能序列化的,
这个时候可以考虑如下的方式:
1.       class Singleton {
2.           private
static$instance = NULL;
3.        
4.           /**
不容许直接调用构造函数 */
5.           private
function__construct() {
6.        
7.           }
8.        
9.           /**
不容许深度复制 */
10.        private
function__clone() {
11.        }
12.     
13.        public 
function__wakeup() {
14.            self::$instance =
$this;
15.        }
16.     
17.        /**
需要在单利切换的时候做清理工作 */
18.        public
function__destruct() {
19.            self::$instance = NULL;
20.        }
21.     
22.        public
staticfunctiongetInstance() {
23.            if (NULL === self::$instance)
{
24.                self::$instance =
newself();
25.            }
26.     
27.            return self::$instance;
28.        }
29.    }
请注意上面,
我们在wakeup的时候,
切换了当前的单例实例,
来实现在序列化/反序列化的时刻保证单例.
另外,
对于一些包含全局资源的单例类,
我们需要定义析构函数,
来在切换的过程中做资源回收工作.
现在,
请大家仔细看看,
然后想想这段代码有没有什么问题?
接着往下看,
这段代码在有些条件下,
可能会达不到我们预期的目标,
比如:
1.       $a = Singleton::getInstance();
2.       $a =
unserialize(serialize($a));
3.        
4.       var_dump($a === Singleton::getInstance());
5.       //bool(false)