单例

场景引入

多人协同开发一个项目， 需要调用MySQL类的实例，原本只需要创建一个实例，就可以了，但是有一个开发者多创建了一个MySQL类实例，这样就导致重复的创建实例了。

解决方案

为了避免重复创建同一个实例的这种情况，老板想出以下的解决方案；

开会：谁多创建，就开除谁，但是这种方法不是一个长久之计， 谁也不能保证都可以乖乖听话。这时候技术总监就提出了使用单例来解决这种问题。

首先一个普通的类，可以使用new进行实例化， 那我们可不可以不让new

答：将构造方法使用protected/private进行修饰

    class single {
        protected function __construct()
        {

        }
    }
?>
1
2
3
4
5
6
7
8

但是这样又会出现一个问题，那就是一个对象也创建不了了， 看来不行，但是我们可以在类中创建一个对象， 这样就不会出现0例的情况。

于是我们就在类中创建一个对象，

    class single {
        protected function __construct()
        {

        }
        public function getInstance() {
            return new self();
        }
    }

?>
1
2
3
4
5
6
7
8
9
10
11
12

但是这样又会出现一个问题，是先有类还是先有对象呢？有对象调用方法创建类，有类创建方法，这就会陷入先有鸡还是现有蛋的问题上来，显然不合理。

我们继续想，我们可以创建一个静态方法，通过调用静态方法进行调用啊，静态方法和类同时存在，
同时消失

于是就有了下面这段代码

    class single {
        protected function __construct()
        {

        }
        public static function getInstance() {
            return new self();
        }
    }
    $s1 = single::getInstance();
    $s2 = single::getInstance();
?>
1
2
3
4
5
6
7
8
9
10
11
12
13

既然是单例，那么想必创建的对象也是一样的吧，那么我们来检测一下这两个变量是否为同一个变量
同一个对象的地址是相等的。

    class single {
        public $bash;
        protected function __construct()
        {
            $this->bash = rand(1, 99999);
        }
        public static function getInstance() {
            return new self();
        }
    }
    $s1 = single::getInstance();
    $s2 = single::getInstance();
    print_r($s1);
    print_r($s2);
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

检测出来两者的结果并不相同，所以还是创建了两个对象，但是我们可以加判断条件，先创建一个对象，并用一个变量进行存储，之后创建的对象判断是否为类的实例，如果是，那么将返回变量。

这样就实现了只创建一个对象

判断一个对象是否为某个类的实例，可以使用instanceof关键字

    class single {
        public $hash;
        static protected $ins = null;
        protected function __construct()
        {
            $this->hash = mt_rand(1, 99999);
        }
        public static function getInstance() {
            if (self::$ins instanceof self) {
                return self::$ins;
            }
            self::$ins = new self();
            return self::$ins;
        }
    }
    $s1 = single::getInstance();
    $s2 = single::getInstance();
    print_r($s1);
    print_r($s2);
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

但是如果有一个子类重载了上面这个类，然后重写上面的方法，这样又会导致上面的单例失效

我么来看看这个问题：

    class single {
        public $hash;
        static protected $ins = null;
        protected function __construct()
        {
            $this->hash = mt_rand(1, 99999);
        }
        public static function getInstance() {
            if (self::$ins instanceof self) {
                return self::$ins;
            }
            self::$ins = new self();
            return self::$ins;
        }
    }
    class son extends single {
        public function __construct()
        {   //重写父类的方法
            parent::__construct();
        }
    }
    $s1 = new son();
    $s2 = new son();
    if ($s1 == $s2) {
        echo "相等", '
';
    } else {
        echo "不相等", '
';
    }

?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

这个时候，为了防止这种情况我们引入新的关键字final，在Java中final修饰属性，此时的属性就是变量值，final修饰的方法，可以继承，但是不可以进行重写

    class single {
        public $hash;
        static protected $ins = null;
        final protected function __construct()
        {
            $this->hash = mt_rand(1, 99999);
        }
        public static function getInstance() {
            if (self::$ins instanceof self) {
                return self::$ins;
            }
            self::$ins = new self();
            return self::$ins;
        }
    }
    class son extends single {

    }
    //此时构造方法已经没有用了, 不可以直接new了
    $t1 = son::getInstance();
    $t2 = son::getInstance();
    if ($t1 == $t2) {
        echo "相等", "
";
    } else {
        echo "不想等", "
";
    }
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

关于PHP中重写和继承的事情，我会在后面重新细说