设计模式类

单例模式

• .指的是在PHP的应用程序的范围内只对指定的类创建一个实例。
• .通常拥有一个私有构造函数和一个私有克隆函数，以防 止用户通过创建对象或者克隆对其进行实例化。
• .有一个静态私有成员变量$instance 与静态方法getInstance.
• getInstance 负责对其本身实例化，然后将这个对象存储在$instance 静态成员变量中，以确保只有一个实例被创建。

应用：
1.应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加
2. 网站的计数器，一般也是采用单例模式实现，否则难以同步。
3.单例模式：应用配置

代码实现：

<?php
//单例类
class Singleton
{
    private static $instance;

    private function __construct()
    {

    }

    public static function getInstance()
    {
        if(!self::$_instance){
            self::$_instance = new Singleton();
        }

        return self::$_instance;
    }
    //或者
    public static function getInstance()
    {
        if (self::$_instance == null) {
            self::$_instance = new self();
        }

        return self::$_instance;
    }

}
?>
//调用：
$a = Singleton::getInstance();

特点：
1.$_instance必须声明为静态的私有变量
2.构造函数和析构函数必须声明为私有,防止外部程序new 类从而失去单例模式的意义
3.getInstance()方法必须设置为公有的,必须调用此方法 以返回实例的一个引用
4.::操作符只能访问静态变量和静态函数
5.new对象都会消耗内存
6.使用场景:最常用的地方是数据库连接。
7.使用单例模式生成一个对象后， 该对象可以被其它众多对象所使用。
8.私有的__clone()方法防止克隆对象

补充2020.04：

https://www.runoob.com/design-pattern/singleton-pattern.html
https://www.cnblogs.com/sgm4231/p/9851725.html

模板模式（抽奖系统）

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

实现方式：

a) 父类模板类（规定要执行的方法和顺序，只关心方法的定义及顺序，不关心方法实现）
b) 子类实现类（实现a规定要执行的方法，只关心方法实现，不关心调用顺序）

优点：
1）封装不变部分，扩展可变部分：把认为不变部分的算法封装到父类实现，可变部分则可以通过继承来实现，很容易扩展。
2）提取公共部分代码，便于维护。
3）行为由父类控制，由子类实现。
缺点：
模板方法模式颠倒了我们平常的设计习惯：抽象类负责声明最抽象、最一般的事物属性和方法，实现类实现具体的事物属性和方法。在复杂的项目中可能会带来代码阅读的难度。

<?php
/**
 * Created by PhpStorm.
 * User: maggielai
 * Date: 17-9-20
 * Time: 上午10:26
 * 规则基类
 */
abstract class Bll_LuckDraw_Rules_RulesBase{
    //规则校验方法
    abstract public function checkFrequences();
    //规则执行方法
    abstract public function dealFrequences();
    //规则编辑方法
    abstract public function editFrequences();
}

<?php

/**
 * ip每分钟访问限制规则
 * *********必须要传入参数params['ip'] actId
 */
class Bll_LuckDraw_Rules_IpFrequences extends Bll_LuckDraw_Rules_RulesBase
{
}

//多个规则配置类，
//经活动配置选中哪些规则校验，进行一系列的规则校验

简单工厂模式

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少扩展的情况（这样工厂类才不用经常更改）。
它由三种角色组成：
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。如例子中的Driver类。
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例中的Car接口。
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现，如例子中的Benz、Bmw类。

Test1.php
 2 <?php
 3 class Test1{
 4     static function test(){
 5         echo __FILE__;
 6     }
 7 }
 8 
 9 Factory.php
10 <?php
11 class Factory{
12     /*
13      * 如果某个类在很多的文件中都new ClassName()，那么万一这个类的名字
14      * 发生变更或者参数发生变化，如果不使用工厂模式，就需要修改每一个PHP
15      * 代码，使用了工厂模式之后，只需要修改工厂类或者方法就可以了。
16      */
17     static function createDatabase(){
18         $test = new Test1();
19         return $test;
20     }
21 }
22 
23 Test.php
24 <?php
25 spl_autoload_register('autoload1');
26 
27 $test = Factory::createDatabase();
28 $test->test();
29 function autoload1($class){
30     $dir  = __DIR__;
31     $requireFile = $dir."\\".$class.".php";
32     require $requireFile;
33 }

是建立一个工厂类，对实现了同一接口的一些类进行实例的创建，
之后的使用类，通过静态调用工厂类方法去实例化具体类。

实现方式:

a) 抽象产品类（也可以是接口）

b) 多个具体的产品类

c) 工厂类（包括创建a的实例的方法）

工厂模式

工厂模式，工厂方法或者类生成对象，而不是在代码中直接new。
使用工厂模式，可以避免当改变某个类的名字或者方法之后，在调用这个类的所有的代码中都修改它的名字或者参数。

重点：都不要直接实例化。

优点：
工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点：
由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

观察者模式

1：观察者模式(Observer)，当一个对象状态发生变化时，依赖它的对象全部会收到通知，并自动更新。
2：场景:一个事件发生后，要执行一连串更新操作。传统的编程方式，就是在事件的代码之后直接加入处理的逻辑。当更新的逻辑增多之后，代码会变得难以维护。这种方式是耦合的，侵入式的，增加新的逻辑需要修改事件的主体代码。
3：观察者模式实现了低耦合，非侵入式的通知与更新机制。
定义一个事件触发抽象类。

代码实现：
定义一个事件触发抽象类。

EventGenerator.php
 2 <?php
 3 require_once 'Loader.php';
 4 abstract class EventGenerator{
 5     private $observers = array();
 6     function addObserver(Observer $observer){
 7         $this->observers[]=$observer;
 8     }
 9     function notify(){
10         foreach ($this->observers as $observer){
11             $observer->update();
12         }
13     }
14 }

定义一个观察者接口

Observer.php
<?php
require_once 'Loader.php';
interface Observer{
    function update();***//这里就是在事件发生后要执行的逻辑***
}

<?php
 2 //一个实现了EventGenerator抽象类的类，用于具体定义某个发生的事件
 3 require 'Loader.php';
 4 class Event extends EventGenerator{
 5     function triger(){
 6         echo "Event<br>";
 7     }
 8 }
 9 class Observer1 implements Observer{
10     function update(){
11         echo "逻辑1<br>";
12     }
13 }
14 class Observer2 implements Observer{
15     function update(){
16         echo "逻辑2<br>";
17     }
18 }
19 $event = new Event();
20 $event->addObserver(new Observer1());
21 $event->addObserver(new Observer2());
22 $event->triger();
23 $event->notify();

当某个事件发生后，需要执行的逻辑增多时，可以以松耦合的方式去增删逻辑。也就是代码中的红色部分(加粗部分)，只需要定义一个实现了观察者接口的类，实现复杂的逻辑，然后在红色的部分加上一行代码即可。这样实现了低耦合。

策略模式

策略模式是对象的行为模式，用意是对一组算法的封装。动态的选择需要的算法并使用。

策略模式指的是程序中涉及决策控制的一种模式。策略模式功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性思想。

策略模式的三个角色：

1．抽象策略角色

2．具体策略角色

3．环境角色（对抽象策略角色的引用）

实现步骤：

1．定义抽象角色类（定义好各个实现的共同抽象方法）

2．定义具体策略类（具体实现父类的共同方法）

3．定义环境角色类（私有化申明抽象角色变量，重载构造方法，执行抽象方法）

就在编程领域之外，有许多例子是关于策略模式的。例如：

如果我需要在早晨从家里出发去上班，我可以有几个策略考虑：我可以乘坐地铁，乘坐公交车，走路或其它的途径。每个策略可以得到相同的结果，但是使用了不同的资源。

文献：
https://www.cnblogs.com/yuanwanli/p/8796402.html
https://www.cnblogs.com/leedaily/p/8250158.html
https://www.cnblogs.com/ZSG-DoBestMe/p/5175761.html
https://www.cnblogs.com/yueguanguanyun/p/9584501.html