一、设计模式简介

    1. 首先我们来认识一下什么是设计模式：
    3. 　　设计模式是一套被反复使用、容易被他人理解的、可靠的代码设计经验的总结。
    5. 　　设计模式不是Java的专利，我们用面向对象的方法在PHP里也能很好的使用23种设计模式。
    7. 那么我们常说的架构、框架和设计模式有什么关系呢？
    9. 　　架构是一套体系结构，是项目的整体解决方案；框架是可供复用的半成品软件，是具体程序代码。架构一般会涉及到采用什么样的框架来加速和优化某部分问题的解决，而好的框架代码里合理使用了很多设计模式。

    二、提炼设计模式的几个原则：

    开闭原则：模块应对扩展开放，而对修改关闭。

    里氏代换原则：如果调用的是父类的话，那么换成子类也完全可以运行。

    依赖倒转原则：抽象不依赖细节，面向接口编程，传递参数尽量引用层次高的类。

    接口隔离原则：每一个接口只负责一种角色。

    合成/聚合复用原则：要尽量使用合成/聚合，不要滥用继承。

    三、设计模式的功用？

    1. 设计模式能解决：
    3.     1、替换杂乱无章的代码，形成良好的代码风格
    5.     2、代码易读，工程师们都能很容易理解
    7.   3、增加新功能时不用修改接口，可扩展性强
    9.     4、稳定性好，一般不会出现未知的问题设
    1. 计模式不能解决：
    3. 1、设计模式是用来组织你的代码的模板，而不是直接调用的库；
    5. 2、设计模式并非最高效，但是代码的可读性和可维护性更重要；
    7. 3、不要一味追求并套用设计模式，重构时多考虑；

    四、设计模式分类

    1. 1、创建型模式：
    2.      单例模式、工厂模式（简单工厂、工厂方法、抽象工厂）、创建者模式、原型模式。
    4. 2、结构型模式：
    5. 　　适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
    7. 3、行为型模式：
    8. 　　模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

    五、创建型设计模式

    1. 1、单例模式
    3. 　　目的：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
    4. 　　应用场景：数据库连接、缓存操作、分布式存储。
    5.     <?php
    6.     /**
    7.     * 优才网公开课示例代码
    8.     *
    9.     * 单例模式
    10.     *
    11.     *@author 优才网全栈工程师教研组
    12.     *@see http://www.ucai.cn
    13.     */
    14.     class DbConn
    15.     {
    16.         privatestatic $_instance = null;
    17.         protectedstatic $_counter = 0;
    18.         protected$_db;
    19.         //私有化构造函数，不允许外部创建实例
    20.         privatefunction __construct()
    21.         {
    22.             self::$_counter+= 1;
    23.         }
    24.         publicfunction getInstance()
    25.         {
    26.             if(self::$_instance == null)
    27.             {
    28.                 self::$_instance= new DbConn();
    29.             }
    30.             returnself::$_instance;
    31.         }
    32.         publicfunction connect()
    33.         {
    34.             echo"connected: ".(self::$_counter)."\n";
    35.             return$this->_db;
    36.         }
    37.     }
    38.     /*
    39.     * 不使用单例模式时，删除构造函数的private后再测试，第二次调用构造函数后，_counter变成2
    40.     */
    41.     // $conn = new DbConn();
    42.     // $conn->connect();
    43.     // $conn = new DbConn();
    44.     // $conn->connect();
    45.     //使用单例模式后不能直接new对象，必须调用getInstance获取
    46.     $conn = DbConn::getInstance();
    47.     $db = $conn->connect();
    48.     //第二次调用是同一个实例，_counter还是1
    49.     $conn = DbConn::getInstance();
    50.     $db = $conn->connect();
    51.     ?>
    52. 　特别说明：这里getInstance里有if判断然后再生成对象，在多线程语言里是会有并发问题的。例如java的解决方案有二个，给方法加上synchronized关键词变成同步，或者把_instanc的初始化提前放到类成员变量定义时，但是这2种方式php都不支持。不过因为php不支持多线程所以不需要考虑这个问题了。
    54. 2、工厂模式
    56. 　　实现：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
    57. 　　应用场景：众多子类并且会扩充、创建方法比较复杂。
    58.     <?php
    59.     /**
    60.     * 优才网公开课示例代码
    61.     *
    62.     * 工厂模式
    63.     *
    64.     *@author 优才网全栈工程师教研组
    65.     *@see http://www.ucai.cn
    66.     */
    67.     //抽象产品
    68.     interface Person {
    69.         public function getName();
    70.     }
    71.     //具体产品实现
    72.     class Teacher implements Person {
    73.         function getName() {
    74.             return "老师\n";
    75.         }
    76.     }
    77.     class Student implements Person {
    78.         function getName() {
    79.             return "学生\n";
    80.         }
    81.     }
    82.     //简单工厂
    83.     class SimpleFactory {
    84.         publicstatic function getPerson($type) {
    85.             $person= null;
    86.             if($type == 'teacher') {
    87.                 $person= new Teacher();
    88.             }elseif ($type == 'student') {
    89.                 $person= new Student();
    90.             }
    91.             return$person;
    92.         }
    93.     }
    94.     //简单工厂调用
    95.     class SimpleClient {
    96.         functionmain() {
    97.             //如果不用工厂模式，则需要提前指定具体类
    98.             //$person = new Teacher();
    99.             //echo $person->getName();
    100.             //$person = new Student();
    101.             //echo $person->getName();
    102.             //用工厂模式，则不需要知道对象由什么类产生，交给工厂去决定
    103.             $person= SimpleFactory::getPerson('teacher');
    104.             echo$person->getName();
    105.             $person= SimpleFactory::getPerson('student');
    106.             echo$person->getName();
    107.         }
    108.     }
    109.     //工厂方法
    110.     interface CommFactory {
    111.         public function getPerson();
    112.     }
    113.     //具体工厂实现
    114.     class StudentFactory implements CommFactory{
    115.         function getPerson(){
    116.             return new Student();
    117.         }
    118.     }
    119.     class TeacherFactory implements CommFactory{
    120.         function getPerson() {
    121.             return new Teacher();
    122.         }
    123.     }
    124.     //工厂方法调用
    125.     class CommClient {
    126.         static function main() {
    127.             $factory = new TeacherFactory();
    128.             echo $factory->getPerson()->getName();
    129.             $factory = new StudentFactory();
    130.             echo $factory->getPerson()->getName();
    131.         }
    132.     }
    133.     //抽象工厂模式另一条产品线
    134.     interface Grade {
    135.         functiongetYear();
    136.     }
    137.     //另一条产品线的具体产品
    138.     class Grade1 implements Grade {
    139.         publicfunction getYear() {
    140.             return'2003级';
    141.         }
    142.     }
    143.     class Grade2 implements Grade {
    144.         publicfunction getYear() {
    145.             return'2004级';
    146.         }
    147.     }
    148.     //抽象工厂
    149.     interface AbstractFactory {
    150.         functiongetPerson();
    151.         functiongetGrade();
    152.     }
    153.     //具体工厂可以产生每个产品线的产品
    154.     class Grade1TeacherFactory implementsAbstractFactory {
    155.         publicfunction getPerson() {
    156.             returnnew Teacher();
    157.         }
    158.         publicfunction getGrade() {
    159.             returnnew Grade1();
    160.         }
    161.     }
    162.     class Grade1StudentFactory implementsAbstractFactory {
    163.         publicfunction getPerson() {
    164.             returnnew Student();
    165.         }
    166.         publicfunction getGrade() {
    167.             returnnew Grade1();
    168.         }
    169.     }
    170.     class Grade2TeacherFactory implementsAbstractFactory {
    171.         publicfunction getPerson() {
    172.             returnnew Teacher();
    173.         }
    174.         publicfunction getGrade() {
    175.             returnnew Grade2();
    176.         }
    177.     }
    178.     //抽象工厂调用
    179.     class FactoryClient {
    180.         functionprintInfo($factory) {
    181.             echo $factory->getGrade()->getYear().$factory->getPerson()->getName();
    182.         }
    183.         functionmain() {
    184.             $client= new FactoryClient();
    185.             $factory= new Grade1TeacherFactory();
    186.             $client->printInfo($factory);
    187.             $factory= new Grade1StudentFactory();
    188.             $client->printInfo($factory);
    189.             $factory= new Grade2TeacherFactory();
    190.             $client->printInfo($factory);
    191.         }
    192.     }
    193.     //简单工厂
    194.     //SimpleClient::main();
    195.     //工厂方法
    196.     //CommClient::main();
    197.     //抽象工厂
    198.     FactoryClient::main();
    199.     ?>
    200. 　　三种工厂的区别是，抽象工厂由多条产品线，而工厂方法只有一条产品线，是抽象工厂的简化。而工厂方法和简单工厂相对，大家初看起来好像工厂方法增加了许多代码但是实现的功能和简单工厂一样。
    201. 　　但本质是，简单工厂并未严格遵循设计模式的开闭原则，当需要增加新产品时也需要修改工厂代码。但是工厂方法则严格遵守开闭原则，模式只负责抽象工厂接口，具体工厂交给客户去扩展。在分工时，核心工程师负责抽象工厂和抽象产品的定义，业务工程师负责具体工厂和具体产品的实现。只要抽象层设计的好，框架就是非常稳定的。
    203. 3、创建者模式
    205. 　在创建者模式中，客户端不再负责对象的创建与组装，而是把这个对象创建的责任交给其具体的创建者类，把组装的责任交给组装类，客户端支付对对象的调用，从而明确了各个类的职责。
    206. 　　应用场景：创建非常复杂，分步骤组装起来。
    207.     <?php
    208.     /**
    209.     * 优才网公开课示例代码
    210.     *
    211.     * 创建者模式
    212.     *
    213.     *@author 优才网全栈工程师教研组
    214.     *@see http://www.ucai.cn
    215.     */
    216.     //购物车
    217.     class ShoppingCart {
    218.         //选中的商品
    219.         private $_goods = array();
    220.         //使用的优惠券
    221.         private $_tickets = array();
    222.         publicfunction addGoods($goods) {
    223.             $this->_goods[]= $goods;
    224.         }
    225.         public function addTicket($ticket) {
    226.             $this->_tickets[] = $ticket;
    227.         }
    228.         public function printInfo() {
    229.             printf("goods:%s,tickets:%s\n", implode(',', $this->_goods), implode(',',$this->_tickets));
    230.         }
    231.     }
    232.     //假如我们要还原购物车的东西，比如用户关闭浏览器后再打开时会根据cookie还原
    233.     $data = array(
    234.         'goods'=> array('衣服', '鞋子'),
    235.         'tickets'=> array('减10'),
    236.     );
    237.     //如果不使用创建者模式，则需要业务类里一步步还原购物车
    238.     // $cart = new ShoppingCart();
    239.     // foreach ($data['goods'] as $goods) {
    240.     // $cart->addGoods($goods);
    241.     // }
    242.     // foreach ($data['tickets'] as $ticket) {
    243.     // $cart->addTicket($ticket);
    244.     // }
    245.     // $cart->printInfo();
    246.     // exit;
    247.     //我们提供创建者类来封装购物车的数据组装
    248.     class CardBuilder {
    249.         private$_card;
    250.         function__construct($card) {
    251.             $this->_card= $card;
    252.         }
    253.         functionbuild($data) {
    254.             foreach($data['goods'] as $goods) {
    255.                 $this->_card->addGoods($goods);
    256.             }
    257.             foreach($data['tickets'] as $ticket) {
    258.                 $this->_card->addTicket($ticket);
    259.             }
    260.         }
    261.         functiongetCrad() {
    262.             return$this->_card;
    263.         }
    264.     }
    265.     $cart = new ShoppingCart();
    266.     $builder = new CardBuilder($cart);
    267.     $builder->build($data);
    268.     echo "after builder:\n";
    269.     $cart->printInfo();
    270.     ?>
    271. 　　可以看出，使用创建者模式对内部数据复杂的对象封装数据组装过程后，对外接口就会非常简单和规范，增加修改新数据项也不会对外部造成任何影响。
    273. 4、原型模式
    275. 　　用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
    276. 　　应用场景：类的资源非常多、性能和安全要求，一般和工厂方法结合使用。
    277.     <?php
    278.     /**
    279.     * 优才网公开课示例代码
    280.     *
    281.     * 原型模式
    282.     *
    283.     *@author 优才网全栈工程师教研组
    284.     *@see http://www.ucai.cn
    285.     */
    286.     //声明一个克隆自身的接口
    287.     interface Prototype {
    288.         function copy();
    289.     }
    290.     //产品要实现克隆自身的操作
    291.     class Student implements Prototype {
    292.         //简单起见，这里没有使用getset
    293.         public $school;
    294.         public $major;
    295.         public$name;
    296.         publicfunction __construct($school, $major, $name) {
    297.             $this->school= $school;
    298.             $this->major= $major;
    299.             $this->name= $name;
    300.         }
    301.         publicfunction printInfo() {
    302.             printf("%s,%s,%s\n",$this->school, $this->major, $this->name);
    303.         }
    304.         public function copy() {
    305.             return clone $this;
    306.         }
    307.     }
    308.     $stu1 = new Student('清华大学', '计算机', '张三');
    309.     $stu1->printInfo();
    310.     $stu2 = $stu1->copy();
    311.     $stu2->name = '李四';
    312.     $stu2->printInfo();
    313.     ?>
    314.     这里可以看到，如果类的成员变量非常多，如果由外部创建多个新对象再一个个赋值，则效率不高代码冗余也容易出错，通过原型拷贝复制自身再进行微小修改就是另一个新对象了。
    1. 转自：https://mp.weixin.qq.com/s/8pyZkkC1zellVn4jU-zkag