search

博客列表 >12月5日-单例模式、工厂模式及依赖管理-***线上九期班

12月5日-单例模式、工厂模式及依赖管理-***线上九期班

邯郸易住宋至刚
邯郸易住宋至刚原创
2019年12月19日 00:29:03684浏览

一、课堂代码全部上机操作至少一遍以上

1、单例模式 demo1.php

代码

  1. <?php
  2. namespace _1205;
  3. //use PDO;
  4. // 单例模式
  5. class Temp
  6. {
  7.     //只是一个类，不需要成员，为了演示 ...
  8. }
  9. //获取第一个对象
  10. $obj1 = new Temp();
  11. //获取第二个对象
  12. $obj2 = new Temp();
  13. //查看两个都是从一个类实例化对象的类型
  14. var_dump($obj1, $obj2);
  15. echo '<br>';
  16. //查看两个对象是否完全一样
  17. var_dump($obj1 === $obj2);
  18. echo '<hr>';
  20. // 单例模式原理
  21. class Demo1
  22. {
  23.     // 构造方法私有化，禁止外部访问
  24.     //外部实例化该类时，首先调用构造函数
  25.     private function __construct()
  26.     {
  27.     }
  29.     // 目前 由于构造函数已经私有化，外部调用是非法的，所以只能在类中的内部将类实例化
  30.     // 当前类的实例 静态属性
  31.     public static $instance = null;
  33.     // 实例化当前类的方法 静态方法
  34.     public static function getInstance()
  35.     {
  36.         // 实例化当前类,并返回类实例/对象
  37.         // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
  38.         //is_null()这个函数用来判断变量值是否为null，如果是null,返回true否则false
  39.         if (is_null(self::$instance)) {
  40.             //在当前类中调用类属性，使用self,同时self也是类本身
  41.             //对类进行实例化new self(),然后返回类实例对象，保存在变量$instance当中
  42.             self::$instance = new self();
  43.         }
  44.         //如果已经实例化，返回类实例对象本身
  45.         return self::$instance;
  46.     }
  48.     // 禁用克隆魔术方法
  49.     private function __clone()
  50.     {
  51.         // ...
  52.     }
  53. }
  55. //new Demo1();
  56. $obj1 = Demo1::getInstance();
  57. $obj2 = Demo1::getInstance();
  58. //查看两个实例对象是否完全相同
  59. var_dump($obj1 === $obj2);
  60. echo '<br>';
  61. //查看两个对象的类型
  62. var_dump($obj1, $obj2);
  63. echo '<hr>';

结果

2、单例模式应用场景

代码

  1. <?php
  2. // 单例模型应用场景
  3. class Db
  4. {
  5.     // 构造方法私有化 禁止外部调用
  6.     //...$connectParams是可变参数...$connectParams===$dsn，$username，$password
  7.     private function __construct(...$connectParams)
  8.     {
  9.         //初始化变量
  10.         $dsn = $connectParams[0];
  11.         $username = $connectParams[1];
  12.         $password = $connectParams[2];
  14.         //连接数据库
  15.         self::$pdo = new \PDO($dsn, $username, $password);
  16.     }
  18.     // 目前 由于构造方法的私有化，所以只能在类中的内部将类实例化
  19.     // 当前类的实例 静态属性
  20.     public static $pdo = null;
  22.     // 实例化当前类的方法
  23.     public static function getInstance(...$connectParams)
  24.     {
  25.         // 实例化当前类,并返回类实例/对象
  26.         // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
  27.         if (is_null(self::$pdo)) {
  28.             // 构造函数不需要返回，这里需要特别注意
  29.             new self(...$connectParams);
  30.         }
  32.         //返回数据库连接
  33.         return self::$pdo;
  34.     }
  36.     // 禁用克隆魔术方法
  37.     private function __clone()
  38.     {
  39.         // ...
  40.     }
  41. }
  42. echo '<hr>';
  44. //客户端调用
  45. //配置数据库连接参数$dsn,$username,$password
  46. $connectParams = ['mysql:host=localhost;dbname=mt', 'root', '111'];
  47. //实例化同时，传入数据库连接参数，连接数据库
  48. $pdo = Db::getInstance(...$connectParams);
  49. //这里直接调用了query（）方法，是为了简便演示进程，没有使用预处理过程，一般数据是从数据库中获取
  50. //在这里直接打印输出
  51. //PDO中的query和fetchAll方法
  52. echo '<pre>' .print_r($pdo->query('SELECT * FROM `user`')->fetchAll(),true) .'</pre>';

结果

3、工厂模式 demo2.php

代码

  1. <?php
  2. namespace _1205;
  3. // 工厂模式: 用于批量创建类的实例/对象
  4. use mvc\Facade;
  6. class Demo2
  7. {
  8.     // ...
  9. }
  10. //如果需要很多类的对象，那就需要做大量重复的操作，
  11. // file1.php
  12. $obj = new Demo2();
  13. // file2.php
  14. $obj = new Demo2();
  15. // file3.php
  16. $obj = new Demo2();
  18. /********************************************/
  20. class Test1
  21. {
  22.     //构造函数，外部调用该类时，首先调用构造函数
  23.     public function __construct($arg1)
  24.     {
  25.         echo '对象创建成功, 参数是: ' . $arg1;
  26.     }
  27. }
  29. class Test2
  30. {
  31.     public function __construct($arg1, $arg2)
  32.     {
  33.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2]);
  34.     }
  35. }
  37. class Test3
  38. {
  39.     public function __construct($arg1, $arg2, $arg3)
  40.     {
  41.         //implode(',',[$arg1,$arg2,$arg3])= '$arg1,$arg2,$arg3';
  42.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2, $arg3]);
  43.     }
  44. }
  46. // 工厂类, 专用于创建类实例
  47. class Factory
  48. {
  49.     //静态方法 $className 类名 ...$arguments是可变变量
  50.     public static function create($className, ...$arguments)
  51.     {
  52.         //根据传过来的类名和参数，对类进行实例化，并返回实例对象
  53.         return new $className(...$arguments);
  54.     }
  55. }
  57. //echo Test1::class; // _1205\Test1: 完整的类名, 带有命名空间的
  58. //Test1::class是完整的类名，是带有命名空间的类名，在本命名空间下是指 _1205\Test1
  59. // 用工厂类来创建类实例/对象
  60. Factory::create(Test1::class, 100);
  61. echo '<br>';
  62. Factory::create(Test2::class, 100, 200);
  63. echo '<br>';
  64. Factory::create(Test3::class, 100, 200, 300);

结果

4、_1205\base\Travel1.php

代码

  1. <?php
  2. // ***类: 使用最传统的方式
  4. namespace base;
  6. // 设置引用的外部类名的别名
  7. use base\inc1\Car;
  8. use base\inc1\Train;
  9. use base\inc1\Plane;
  11. require __DIR__ . '/autoload.php';
  13. class Travel1
  14. {
  15.     // 交通工具 私有属性 只能在类内部调用，子类也不能调用
  16.     private $vehicle;
  18.     // 构造方法
  19.     public function __construct($vehicle)
  20.     {
  21.         //根据外部传入参数来对私有属性$vehicle存入相应类实例化得到的对象
  22.         switch (strtolower($vehicle)) {
  23.             case 'car':
  24.                 $this->vehicle = new Car();
  25.                 break;
  26.             case 'train':
  27.                 $this->vehicle = new Train();
  28.                 break;
  29.             case 'plane':
  30.                 $this->vehicle = new Plane();
  31.         }
  32.     }
  34.     // 调用外部一个依赖对象
  35.     public function travelModel()
  36.     {
  37.         //此时的$this->vehicle就是某个类的实例化对象，所以会调用相应类中的方法
  38.         return $this->vehicle->drive() . ' : 去***';
  39.     }
  40. }
  42. // 客户端调用
  44. echo  (new Travel1('car'))->travelModel(), '<br>';
  45. echo  (new Travel1('train'))->travelModel(), '<br>';
  46. echo  (new Travel1('plane'))->travelModel(), '<br>';

结果

5、_1205\base\Travel2.php

代码

  1. <?php
  2. // ***类: 使用最传统的方式
  4. namespace base;
  6. // 设置引用的外部类名的别名
  7. use base\inc1\Car;
  8. use base\inc1\Train;
  9. use base\inc1\Plane;
  10. use base\inc1\Ship;
  12. require __DIR__ . '/autoload.php';
  14. // 工厂类, 专用于创建类实例
  15. class Factory
  16. {
  17.     //添加静态变量static $instance 用于存储类实例
  18.    protected static $instance = null;
  20.    //外部传入参数，得到相应类的实例对象
  21.    public static function getInstance($vehicle)
  22.    {
  23.        switch (strtolower($vehicle)) {
  24.            case 'car':
  25.                //类内调用该类属性使用self::
  26.                self::$instance = new Car();
  27.                break;
  28.            case 'train':
  29.                self::$instance = new Train();
  30.                break;
  31.            case 'ship':
  32.                self::$instance = new Ship();
  33.                break;
  34.            case 'plane':
  35.                self::$instance = new Plane();
  36.        }
  38.        // 返回当前具体的交通工具
  39.        return self::$instance;
  40.    }
  41. }
  44. class Travel2
  45. {
  46.     // 交通工具
  47.     private $vehicle;
  49.     // 构造方法
  50.     public function __construct($vehicle)
  51.     {
  52.         //Factory::getInstance($vehicle)==self::$instance
  53.         //此时的$this->vehicle就是Factory::getInstance($vehicle)==self::$instance
  54.         //就是一个类实例
  55.         $this->vehicle = Factory::getInstance($vehicle);
  56.     }
  58.     // 调用外部一个依赖对象
  59.     public function travelModel()
  60.     {
  61.         //$this->vehicle是类实例，可以调用相应的类中的方法
  62.         return $this->vehicle->drive() . ' : @@@@  去***';
  63.     }
  64. }
  66. // 客户端调用
  67. echo  (new Travel2('car'))->travelModel(), '<br>';
  68. echo  (new Travel2('train'))->travelModel(), '<br>';
  69. echo  (new Travel2('plane'))->travelModel(), '<br>';
  70. echo  (new Travel2('ship'))->travelModel(), '<br>';

结果

6、_1205\base\Travel3.php

代码

  1. <?php
  2. // 旅行类: 使用最传统的方式
  4. namespace base;
  6. // 设置引用的外部类名的别名
  7. use base\inc2\Car;
  8. use base\inc2\Train;
  9. use base\inc2\Plane;
  10. use base\inc2\Ship;
  11. use base\inc2\iVehicle;
  13. require __DIR__ . '/autoload.php';
  16. class Travel3
  17. {
  18.     // 交通工具 私有属性，只能在本类内部调用，外部、子类都不能调用
  19.     private $vehicle;
  21.     // 构造方法
  22.     public function __construct(iVehicle $vehicle)
  23.     {
  24.         //属性$this->vehicle初始化
  25.         $this->vehicle = $vehicle;
  26.     }
  28.     // 调用外部一个依赖对象
  29.     public function travelModel()
  30.     {
  31.         return $this->vehicle->drive() . ' : ======= 去旅行';
  32.     }
  33. }
  35. // 客户端调用
  36. $car = new Car();
  37. echo  (new Travel3($car))->travelModel(), '<br>';
  40. //new Train()作为参数传给new Travel3()，然后调用travelModel()
  41. echo  (new Travel3(new Train()))->travelModel(), '<br>';
  42. echo  (new Travel3(new Plane()))->travelModel(), '<br>';
  45. echo  (new Travel3(new Ship()))->travelModel(), '<br>';

结果

7、容器 _1205\lesson1\demo1.php

代码

  1. <?php
  3. namespace _1205;
  5. require 'Product.php';
  6. require 'Maker.php';
  8. // 先不用容器，将外部类的对象的依赖直接放在本类中实例化
  9. class Client1
  10. {
  11.     // 输出商品与制造商
  12.     public function show()
  13.     {
  14.         // 创建产品的实例
  15.         $product = new Product();
  17.         // 创建制造商的实例
  18.         $maker = new Maker();
  20.         // 制造商注入到产品类中
  21.         return $product->get($maker);
  22.     }
  23. }
  25. // 客户端调用
  26. echo  (new Client1())->show();

结果

8、容器 _1205\lesson1\demo2.php

代码

  1. <?php
  3. namespace _1205;
  5. require 'Product.php';
  6. require 'Maker.php';
  7. require 'Container.php';
  9. //使用容器类
  10. class Client2
  11. {
  12.     // 输出商品与制造商
  13.     public function show(Product $product, Maker $maker)
  14.     {
  15.         // 制造商注入到产品类中
  16.         return $product->get($maker);
  17.     }
  18. }
  20. // 客户端调用
  22. // 将类实例绑定到容器中并实例化且返回
  23. $container = new Container();
  24. // 将实例化代码绑定到容器中
  25. $container->bind('product', function () {return new Product();});
  26. $container->bind('maker', function () {return new Maker();});
  27. // 创建类实例并返回
  28. $product = $container->make('product');
  29. $maker = $container->make('maker');
  33. echo  (new Client2())->show($product, $maker);

结果

二、手写1205.md

三、总结

1、容器Container

容器中存入了所依赖的类的实例对象队列，并且将类与类实例化代码的闭包函数绑定到容器中，bind()方法是放进去，make()是调用容器中的实例化方法。

2、依赖注入

类分为工作类和依赖类
工作类中需要调用其它类时，为了降低耦合度，需要将对被依赖的类的实例过程中的new消灭掉，这就是依赖注入的目的。

上一条：10月9日作业，抽象类和CRUD接口实现下一条：js-1216第一课-javaScript基本语法-九期线上班
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多