search

博客列表 >1205作业设计模式与服务容器-PHP培训第九期线上班

1205作业设计模式与服务容器-PHP培训第九期线上班

淡月
淡月原创
2019年12月09日 17:38:17942浏览

单例模式

  1. <?php
  2. namespace _1205;
  3. //use PDO;
  4. // 单例模式
  5. class Temp
  6. {
  7.     // ...
  8. }
  9. $obj1 = new Temp();
  10. $obj2 = new Temp();
  11. var_dump($obj1, $obj2);
  12. echo '<br>';
  13. var_dump($obj1 === $obj2);
  14. echo '<hr>';
  15. // 单例模式原理
  16. class Demo1
  17. {
  18.     // 构造方法私有化
  19.     private function __construct()
  20.     {
  21.     }
  22.     // 目前 只能在类中的内部将类实例化
  23.     // 当前类的实例
  24.     public static $instance = null;
  25.     // 实例化当前类的方法
  26.     public static function getInstance()
  27.     {
  28.         // 实例化当前类,并返回类实例/对象
  29.         // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
  30.         if (is_null(self::$instance)) {
  31.             self::$instance = new self();
  32.         }
  33.         return self::$instance;
  34.     }
  35.     // 禁用克隆魔术方法
  36.     private function __clone()
  37.     {
  38.         // ...
  39.     }
  40. }
  41. //new Demo1();
  42. $obj1 = Demo1::getInstance();
  43. $obj2 = Demo1::getInstance();
  44. var_dump($obj1 === $obj2);
  45. echo '<br>';
  46. var_dump($obj1, $obj2);
  47. echo '<hr>';
  48. // 单例模型应用场景数据库链接
  49. class Db
  50. {
  51.     // 构造方法私有化
  52.     private function __construct(...$connectParams)
  53.     {
  54.         $dsn = $connectParams[0];
  55.         $username = $connectParams[1];
  56.         $password = $connectParams[2];
  57.         self::$pdo = new \PDO($dsn, $username, $password);
  58.     }
  59.     // 目前 只能在类中的内部将类实例化
  60.     // 当前类的实例
  61.     public static $pdo = null;
  62.     // 实例化当前类的方法
  63.     public static function getInstance(...$connectParams)
  64.     {
  65.         // 实例化当前类,并返回类实例/对象
  66.         // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
  67.         if (is_null(self::$pdo)) {
  68.             // 构造函数不需要返回
  69.             new self(...$connectParams);
  70.         }
  71.         return self::$pdo;
  72.     }
  73.     // 禁用克隆魔术方法
  74.     private function __clone()
  75.     {
  76.         // ...
  77.     }
  78. }
  79. echo '<hr>';
  80. $connectParams = ['mysql:host=localhost;dbname=mysql', 'root', 'root'];
  81. $pdo = Db::getInstance(...$connectParams);
  82. print_r($pdo->query('SELECT * FROM `db`')->fetchAll());

工厂模式

  1. <?php
  2. //工床模式
  3. class Test1
  4. {
  5.     public function __construct($arg1)
  6.     {
  7.         echo '对象创建成功, 参数是: ' . $arg1;
  8.     }
  9. }
  10. class Test2
  11. {
  12.     public function __construct($arg1, $arg2)
  13.     {
  14.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2]);
  15.     }
  16. }
  17. class Test3
  18. {
  19.     public function __construct($arg1, $arg2, $arg3)
  20.     {
  21.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2, $arg3]);
  22.     }
  23. }
  24. // 工厂类, 专用于创建类实例
  25. class Factory
  26. {
  27.     public static function create($className, ...$argments)
  28.     {
  29.         return new $className(...$argments);
  30.     }
  31. }
  32. // 用工厂类来创建类实例/对象
  33. Factory::create(Test1::class, 500);
  34. echo '<br>';
  35. Factory::create(Test2::class,'第一个参数','第二个参数');
  36. echo '<br>';
  37. Factory::create(Test3::class, '第一个参数','第二个参数','第三个参数');

依赖注入

  1. <?php
  2. //依赖注入
  3. namespace dem;
  4. //创建类
  5. class Person
  6. {
  7. //    要依赖的外部对象
  8.     private  $car;
  9. //在构造方法中将依赖的外部对象 全部实例化
  10.     public  function __construct()
  11.     {
  12.         $this->car=new Car();
  13.     }
  14. //外部对象的方法
  15.     public  function  work()
  16.     {
  17.         return $this->car->drive();
  18.     }
  19. }
  20. //依赖外部的类
  21. class Car
  22. {
  23. //    外部类的方法
  24.     public function drive()
  25.     {
  26.         return '开车去上工作';
  27.     }
  28. }
  29. //实例化类
  30. $Person=new Person();
  31. echo $Person->work();
  32. echo '<hr>';
  33. class Person1
  34. {
  35.     // 要依赖的外部对象
  36.     private $car ;
  37.     // 在构造方法中将依赖的外部对象全部实例化
  38.     // 注入点放到构造方法中
  39.     public function __construct(Car $car)
  40.     {
  41.         $this->car = $car;
  42.     }
  43.     // 外部对象执行一个动作
  44.     public function work()
  45.     {
  46.         return $this->car->drive();
  47.     }
  48. }
  49. // 依赖的外部类
  50. class Car1
  51. {
  52.     public function drive()
  53.     {
  54.         return '开车去上班';
  55.     }
  56. }
  57. // 实例化类
  58. $car = new Car();
  59. $person = new Person1($car);
  60. echo $person->work();
  61. echo '<hr>';

namespace base\inc1\car

  1. <?php
  2. namespace base\inc1;
  3. class Car
  4. {
  5.     public function drive()
  6.     {
  7.         return '开汽车';
  8.     }
  9. }

namespace base\inc1\plane

namespace base\inc1\train

namespace base\travel1.php

  1. <?php
  2. //***类
  3. namespace  base;
  4. //引用类
  5. use base\inc1\Car;
  6. use base\inc1\Train;
  7. use base\inc1\Plane;
  8. require __DIR__ .'/autoload.php';
  9. class Travel1
  10. {
  11. //    交通工具
  12.     private  $vehicle;
  13. //    构造方法
  14. public  function __construct($vehicle)
  15. {
  16.     switch (strtolower($vehicle)){
  17.         case 'car';
  18.         $this->vehicle=new Car();
  19.         break;
  20.         case 'train';
  21.         $this->vehicle=new Train();
  22.         break;
  23.         case 'plane';
  24.         $this->vehicle=new Plane();
  25. break;
  26.     }
  27. }
  28. //调用外部一个对象
  29. public  function travelModel()
  30. {
  31.     return $this->vehicle->drive().'去玩耍';
  32. }
  33. }
  34. //客户端调用
  35. echo  (new Travel1('car'))->travelModel() . '<br>';
  36. echo  (new Travel1('train'))->travelModel() . '<br>';
  37. echo  (new Travel1('plane'))->travelModel() . '<br>';

接口

  1. <?php
  2. namespace base\inc1;
  3. // 交通工具的接口
  4. interface iVehicle
  5. {
  6.     public function drive();
  7. }

ravel3.php

  1. <?php
  2. // ***类: 使用最传统的方式
  3. namespace base;
  4. // 设置引用的外部类名的别名
  5. use base\inc1\Car;
  6. use base\inc1\Train;
  7. use base\inc1\Plane;
  8. use base\inc1\Ship;
  9. use base\inc1\iVehicle;
  10. require __DIR__ . '/autoload.php';
  11. class Travel3
  12. {
  13.     // 交通工具
  14.     private $vehicle;
  15.     // 构造方法
  16.     public function __construct(iVehicle $vehicle)
  17.     {
  18.         $this->vehicle = $vehicle;
  19.     }
  20.     // 调用外部一个依赖对象
  21.     public function travelModel()
  22.     {
  23.         return $this->vehicle->drive() . ' : ======= 去***';
  24.     }
  25. }
  26. // 客户端调用
  27. $car = new Car();
  28. echo  (new Travel3($car))->travelModel(), '<br>';
  29. echo  (new Travel3(new Train()))->travelModel(), '<br>';
  30. echo  (new Travel3(new Plane()))->travelModel(), '<br>';
  31. echo  (new Travel3(new Ship()))->travelModel(), '<br>';

Container

  1. <?php
  2. //容器类
  3. namespace _1205;
  4. //引用闭包
  5. use Closure;
  6. class  Container
  7. {
  8. //    类实例
  9. protected  $instance=[];
  10. //将实例化过程绑定到容中
  11. public  function bind($alias, Closure $process)
  12. {
  13.     $this->instance[$alias]=$process;
  14. }
  15. //取出保存在容器中的实例化过程
  16. public  function maker($alias)
  17. {
  18.     return $this->instance[$alias];
  19. }
  20. }

Maker

  1. <?php
  2. namespace _1205;
  3. class Maker
  4. {
  5.     public  function get()
  6.     {
  7.         return '华为';
  8.     }
  9. }

Product

  1. <?php
  2. namespace _1205;
  3. class Product {
  4.     public  function get(Maker $maker)
  5.     {
  6.         return '该手机是由：'.$maker->get().'生产的';
  7.     }
  8. }

deomo1

  1. <?php
  2. require 'Product.php';
  3. require 'Maker.php';
  4. class  Client1
  5. {
  6. //    直接输出
  7. public  function  show(){
  8.     $product=new \_1205\Product();
  9.     $make=new \_1205\Maker();
  10.     return $product->get($make);
  11. }
  12. }
  13. // 调用
  14. echo  (new Client1())->show();
  15. $sh=new Client1();
  16. echo $sh->show();

demo2

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

手抄作业

上一条：1204 1205作业 (补）下一条：1207作业：简易mvc框架 电影网
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多