search

博客列表 >1205_依赖注入和服务容器复习及设计模式 第29课

1205_依赖注入和服务容器复习及设计模式 第29课

叮叮当当
叮叮当当原创
2019年12月06日 23:07:51680浏览

1. 将课堂代码全部上机操作至少一遍以上

单例模式：demo1.php

  1. # 单例模式
  3. namespace _1205;
  4. use PDO;
  6. class Temp{
  8. }
  10. $obj1 = new Temp();
  11. $obj2 = new Temp();
  12. var_dump($obj1, $obj2); # id不一样
  13. echo '<br>';
  14. var_dump($obj1===$obj2);
  15. echo '<hr>';
  19. # 单例模式原理
  20. class Demo1{
  22.     # 将构造方法私有化
  23.     private function __construct(){
  25.     }
  27.     # 目前只能在类内部将类实例化
  28.     # 当前类的实例
  29.     public static $instance = null;
  31.     # 实例化当前类的方法
  32.     public static function getInstance(){
  34.         # 实例化当前类，并返回类实例/对象
  35.         # 判断是否已经被实例化： 若没有实例化，实例下； 若已实例化，直接返回它
  36.         if( is_null(self::$instance) ){
  37.             self::$instance = new self();
  38.         }
  39.         return self::$instance;
  40.     }
  42.     # 禁用克隆方法
  43.     private function __clone(){
  45.     }
  46. }
  48. $obj1 = Demo1::getInstance();
  49. $obj2 = Demo1::getInstance();
  50. var_dump($obj1===$obj2);
  51. echo '<br>';
  52. var_dump($obj1, $obj2); # id一样
  53. echo '<hr>';
  57. # 单例模式应用场景
  58. class Db{
  60.     # 将构造方法私有化, 只能在类内部调用
  61.     private function __construct(...$connectParams){
  62.         $dsn = $connectParams[0];
  63.         $name = $connectParams[1];
  64.         $pwd = $connectParams[2];
  65.         self::$pdo = new PDO($dsn, $name, $pwd);
  66.     }
  68.     # 目前只能在类内部将类实例化
  69.     # 当前类的实例
  70.     public static $pdo = null;
  72.     # 实例化当前类的方法
  73.     public static function getInstance(...$connectParams){
  75.         # 实例化当前类，并返回类实例/对象
  76.         # 判断是否已经被实例化： 若没有实例化，实例下； 若已实例化，直接返回它
  77.         if( is_null(self::$pdo) ){
  78.             # 构造函数不需要返回
  79.             new self(...$connectParams); # 不是self::$instance = new self(...$connectParams);
  80.         }
  81.         return self::$pdo;
  82.     }
  84.     # 禁用克隆方法
  85.     private function __clone(){
  87.     }
  89. }
  91. $connectParams = ['mysql:host=127.0.0.1;dbname=SqlTest;charset=utf8','root','root'];
  92. $pdo = Db::getInstance(...$connectParams);
  94. $sql = 'SELECT * FROM `zsgc` WHERE `id`>1 AND `id`<4;';
  95. $data = $pdo->query($sql)->fetchAll(PDO::FETCH_ASSOC);
  96. echo '<pre>' .print_r( $data,true ). '</pre>';

工厂模式：demo2.php

  1. # 工厂模式：批量创建类的实例/对象
  3. namespace _1205;
  5. class Demo2{
  7. }
  9. # file1
  10. $obj = new Demo2();
  11. # file2
  12. $obj = new Demo2();
  13. # file3
  14. $obj = new Demo2();
  17. class Test1{
  19.     public function __construct( $arg1 ){
  20.         echo '对象创建成功,参数是'.$arg1;
  21.     }
  22. }
  24. class Test2{
  26.     public function __construct( $arg1, $arg2 ){
  27.         echo '对象创建成功,参数是'.implode(', ',[$arg1, $arg2]);
  28.     }
  29. }
  31. class Test3{
  33.     public function __construct( $arg1, $arg2, $arg3){
  34.         echo '对象创建成功,参数是'.implode(', ',[$arg1, $arg2, $arg3]);
  35.     }
  36. }
  38. # 创建工厂类，专用于创建类实例
  39. class factory{
  41.     public static function create($className, ...$argments ){
  42.         new $className(...$argments);
  43.     }
  44. }
  46. //echo Test1::class; # 完整类名，带命名空间
  48. # 用工厂类创建类实例/对象
  49. Factory::create( Test1::class, 100);
  50. echo '<br>';
  51. Factory::create( Test2::class, 100,200);
  52. echo '<br>';
  53. Factory::create( Test3::class, 100,200,300);
  54. echo '<br>';

复习（依赖注入和服务容器）

1 依赖注入( 降低对象之间耦合 )：demo3.php

  1. # 依赖注入：解决对象调用之间耦合
  2. # 目标：将类方法中的new干掉
  4. namespace _1205;
  6. # 工作类
  7. class Person{
  9.     # 要依赖的外部对象
  10.     private $car = null;
  12.     # 注入点放到构造方法中，将依赖的外部对象全部实例化
  13.     public function __construct(){
  15.         $this->car = new Car();
  16.     }
  18.     # 外部对象执行一个动作
  19.     public function work(){
  21.         return $this->car->drive();
  22.     }
  23. }
  25. # 依赖的外部类
  26. class Car{
  28.     public function drive(){
  29.         return '开车去上班';
  30.     }
  31. }
  33. # 实例化类
  34. $person = new Person();
  35. echo $person->work();
  36. echo '<hr>';
  39. # 工作类
  40. class Person1{
  42.     # 要依赖的外部对象
  43.     private $car = null;
  45.     # 注入点放到构造方法中，将依赖的外部对象全部实例化
  46.     public function __construct( Car1 $car ){
  48.         $this->car = $car;
  49.     }
  51.     # 外部对象执行一个动作
  52.     public function work(){
  54.         return $this->car->drive();
  55.     }
  56. }
  58. # 依赖的外部类
  59. class Car1{
  61.     public function drive(){
  62.         return '开车去上班,呀呀呀';
  63.     }
  64. }
  66. # 实例化类
  67. # 把工作类里new干掉 拎到外面注入，降低耦合
  68. $car = new Car1();
  69. $person = new Person1( $car );
  70. echo $person->work();
  71. echo '<hr>';

2.1 容器小案例之准备一：Product.php

  1. namespace _1205;
  3. class Product{
  5.     public function get( Maker $maker){
  7.         return '该手机由<span style="color:green;font-weight: bolder">'. $maker->get(). '</span>生产的';
  8.     }
  9. }

2.2 容器小案例之准备二：Maker.php

  1. # 制造商
  3. namespace _1205;
  5. class Maker{
  7.     public function get( ){
  9.         return '华为';
  10.     }
  11. }

2.3 容器小案例之对比( 先不用容器 )：demo1.php

  1. # 先不用容器
  2. namespace _1205;
  4. require "Product.php";
  5. require "Maker.php";
  7. class Client1{
  9.     # 输出商品与制造商
  10.     public function show(){
  12.         # 创建产品的实例
  13.         $product = new Product();
  15.         # 创建制造商的实例
  16.         $maker = new Maker();
  18.         # 制造商注入到产品类中
  19.         return $product->get( $maker );
  20.     }
  21. }
  23. # 客户端调用
  24. echo ( new Client1() )->show();

2.4 容器小案例之准备三：Container.php

  1. # 容器类
  3. namespace _1205;
  5. # 引用闭包别名
  6. use \Closure;
  8. class Contatiner{
  10.     # 类实例容器
  11.     protected $instance = [];
  13.     # 将类实例化的过程绑定到容器中
  14.     public function bind( $alias, Closure $process ){
  15.         $this->instance[$alias] = $process;
  16.     }
  18.     # 取出供养在容器中的实例化过程的闭包，并执行它
  19.     public function make($alias){
  20.         return $this->instance[$alias](); # 闭包，括号不能少
  21.     }
  22. }

2.5 容器小案例之调用：demo2.php

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

工厂方法实例之准备一：Car.php

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

工厂方法实例之准备二：Plane.php

  1. namespace base\inc1;
  3. class Plane{
  5.     public function drive(){
  6.         return '乘飞车';
  7.     }
  8. }

工厂方法实例之准备三：Train.php

  1. namespace base\inc1;
  3. class Train{
  5.     public function drive(){
  6.         return '坐火车';
  7.     }
  8. }

工厂方法实例之准备四：autoload.php

  1. # 自动加载 是让命名空间的路径和文件所在路径一致
  3. spl_autoload_register( function ($className){
  5.     # 将"\"替换成路径分隔符, 推荐使用常量:DIRECTORY_SEPARATOR, 而不是"/",可跨平台支持
  6.     $path = str_replace('\\', DIRECTORY_SEPARATOR, $className);
  8.     require dirname(__DIR__) . DIRECTORY_SEPARATOR . $path . '.php';
  9. });

工厂方法实例之对比( 先使用传统方法 )：Travel1.php

  1. # 旅行类: 使用最传统方式
  3. namespace base;
  5. # 设置引用外部类名的别名
  6. use base\inc1\Car;
  7. use base\inc1\Train;
  8. use base\inc1\Plane;
  10. require __DIR__ . '/autoload.php';
  12. class Travel1{
  14.     # 交通工具
  15.     private $vehicle;
  17.     public function __construct( $vehicle ){
  19.         switch( strtolower($vehicle) ){
  20.             case 'car':
  21.                 $this->vehicle = new Car();
  22.                 break;
  23.             case 'train':
  24.                 $this->vehicle = new Train();
  25.                 break;
  26.             case 'plane':
  27.                 $this->vehicle = new Plane();
  28.         }
  29.     }
  31.     # 调用外部一个依赖对象
  32.     public function travelModel(){
  34.         return $this->vehicle->drive() . ' : 去旅行';
  35.     }
  36. }
  38. # 客户端调用
  39. echo  (new Travel1('car'))->travelModel(), '<br>';
  40. echo  (new Travel1('train'))->travelModel(), '<br>';
  41. echo  (new Travel1('plane'))->travelModel(), '<br>';

工厂方法实例之调用：Travel2.php

  1. # 旅行类: 使用工厂类（此时工作类依赖工厂类，而工厂类依赖3个外部类）
  3. namespace base;
  5. # 设置引用外部类名的别名
  6. use base\inc1\Car;
  7. use base\inc1\Train;
  8. use base\inc1\Plane;
  10. require __DIR__ . '/autoload.php';
  13. # 工厂类, 专用于创建类实例
  14. class Factory
  15. {
  16.     protected static $instance = null;
  18.     public static function getInstance( $vehicle )
  19.     {
  20.         switch( strtolower($vehicle) ){
  21.             case 'car':
  22.                 self::$instance = new Car();
  23.                 break;
  24.             case 'train':
  25.                 self::$instance = new Train();
  26.                 break;
  27.             case 'plane':
  28.                 self::$instance = new Plane();
  29.         }
  31.         # 返回当前具体的交通工具
  32.         return self::$instance;
  33.     }
  34. }
  37. class Travel2{
  39.     # 交通工具
  40.     private $vehicle;
  42.     public function __construct( $vehicle ){
  44.         $this->vehicle = Factory::getInstance( $vehicle );
  45.     }
  47.     # 调用外部一个依赖对象
  48.     public function travelModel(){
  50.         return $this->vehicle->drive() . ' : 去流浪';
  51.     }
  52. }
  54. # 客户端调用
  55. echo  (new Travel2('car'))->travelModel(), '<br>';
  56. echo  (new Travel2('train'))->travelModel(), '<br>';
  57. echo  (new Travel2('plane'))->travelModel(), '<br>';

接口实例之准备一：iVehicle.php

  1. namespace base\inc2;
  3. # 交通工具的接口
  4. interface iVehicle{
  6.     public function drive();
  7. }

接口实例之准备二：接口子类 Car.php ( Plane.php / Train.php同理 )

  1. namespace base\inc2;
  3. class Car implements iVehicle {
  5.     public function drive(){
  6.         return '开汽车';
  7.     }
  8. }

接口实例之调用：Travel3.php

  1. # 旅行类: 使用一个接口 （此时工作类仅依赖一个接口类）
  2. # 3个外部类继承接口并实现接口方法，工作类注入的3个外部类实例此时都是接口实例，做到面向接口
  3. # 好处：可以更方便的扩展代码，如新增ship类，只需继承接口并实现接口方法，工作类再注入此接口实例
  5. namespace base;
  7. # 设置引用外部类名的别名
  8. use base\inc2\Car;
  9. use base\inc2\Train;
  10. use base\inc2\Plane;
  11. use base\inc2\iVehicle;
  13. require __DIR__ . '/autoload.php';
  16. class Travel3{
  18.     # 交通工具
  19.     private $vehicle;
  21.     # 注入接口实例
  22.     public function __construct( iVehicle $vehicle ){
  24.         $this->vehicle = $vehicle;
  25.     }
  27.     # 调用外部一个依赖对象
  28.     public function travelModel(){
  30.         return $this->vehicle->drive() . ' : 去闯荡';
  31.     }
  32. }
  34. # 客户端调用
  35. echo  (new Travel3( new Car() ))->travelModel(), '<br>';
  36. echo  (new Travel3( new Train() ))->travelModel(), '<br>';
  37. echo  (new Travel3( new Plane() ))->travelModel(), '<br>';

2. 手写课堂笔记:1205.md

总结：

  • 1. 单例模式：创建类的唯一实例
  • 2. 工厂模式：批量创建类实例
  • 3. 依赖注入：在外部实例化，并将实例注入到类中，避免直接在类里实例化，降低耦合
  • 4. 服务容器：将类的实例化过程与容器绑定，并通过容器类来执行，统一管理，而不是在外部各自随便实例化
  • 5. 面向接口编程：先通过传统方法实现，缺点是工作类与外部类耦合性太高；然后通过工厂方法实例改进，虽降低了工作类与外部类的耦合，但工厂类依旧依赖外部类；最后通过面向接口的方法，使外部类实例都成了接口实例，达到了工作类只依赖接口类的效果，统一了实例化过程，后续扩展代码更加方便
上一条：12月5日作业--php培训九期线上班下一条：12月05日设计模式与服务容器-九期线上班
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多