search

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

设计模式与服务容器-第九期PHP线上班

emagic
emagic原创
2019年12月08日 22:54:14653浏览

12月5日作业

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

2. 代码中的注释文字, 不得少于代码量的四分之一



demo1

  1. <?php
  2. namespace _1205;
  3. use PDO;
  4. //单例模式
  5. class Temp{
  7. }
  9. //创建一个实例
  10. $obj1 = new Temp();
  11. //再创建一个实例用于比较;
  12. $obj2 = new Temp();
  13. //查看对象的类型
  14. var_dump($obj1,$obj2);
  15. echo '<br>';
  16. var_dump($obj1===$obj2);
  17. //这样创建的实体其实是两个完全不同的对象
  18. echo '<hr>';
  20. //单例模式
  21. //应该场景,如数据库连接,只允许有限的连接数,不允许无限连接,一般一个对象创建一次连接就行
  22. class Demo1{
  23.   //1.构造方法私有化
  24.     private function __construct()
  25.     {
  26.     }
  27.     //目前只能在类的内部将类实例化，这样类中访问只能用静态成员
  28. //  当前类的实例
  29.     public static $instance=null; //可以不赋值，默认也是null
  31.     //实例化当前类的方法，类中也不能实例化调用，也要申明为一个静态方法
  32.     public static function getInstance(){
  33.         //实例化当前类，并返回实例/对象
  34.         //判断当前类是否已经被实例化过了，如果没有的化就实例化，如果已创建就返回他
  35.         if(is_null(self::$instance)){
  36.             //判断当前类实例是否是空
  37. //            没有就创建类实例
  38.             self::$instance=new self(); //new产生的实例保存在当前静态类成员中
  39.         }
  40.         return self::$instance;
  41.     }
  43.     private function __clone()
  44.     {
  45.         // 禁用克隆魔术方法
  46. //        设置魔术方法__clone为私有方法，内容为空
  47.     }
  49. }
  51. //思路：把外面实例化的操作功能禁用掉，禁用new新实例
  52. //new Demo1();
  53. //创建一个实例
  54. $obj1 =  Demo1::getInstance();
  55. //再创建一个实例用于比较;
  56. $obj2 =  Demo1::getInstance();
  57.     var_dump($obj1===$obj2);
  58. echo '<br>';
  59. var_dump($obj1,$obj2);
  61. //单例模式的应用场景
  62. class Db{
  64.     //1.构造方法私有化
  65.     private function __construct(...$connectParams)
  66.     {
  67.         $dsn=$connectParams[0];
  68.         $username=$connectParams[1];
  69.         $password=$connectParams[2];
  70.         self::$pdo = new PDO($dsn,$username,$password);
  71.     }
  72.         //如果前面不加use PDO 这里要写成 \PDO() 在根目录全局下
  73.     //目前只能在类的内部将类实例化，这样类中访问只能用静态成员
  74. //  当前类的实例
  75.     public static $pdo=null; //可以不赋值，默认也是null
  77.     //实例化当前类的方法，类中也不能实例化调用，也要申明为一个静态方法
  78.     public static function getInstance(...$connectParams)
  79.     {
  80.         //实例化当前类，并返回实例/对象
  81.         //判断当前类是否已经被实例化过了，如果没有的化就实例化，如果已创建就返回他
  82.         if(is_null(self::$pdo)){
  83.             //判断当前类实例是否是空
  84. //            没有就创建类实例
  85.             //构造函数不需要返回，因为在__construct中self::$pdo = new PDO($dsn,$username,$password);已经初始化了
  86.             new self(...$connectParams);
  87. //构造函数没有返回值，这里无需写成self::$pdo=new self(...$connectParams)赋值，将new产生的实例保存在当前静态类成员中的格式
  88.         }
  89.         return self::$pdo;
  90.     }
  92.     private function __clone()
  93.     {
  94.         // 禁用克隆魔术方法
  95. //        设置魔术方法__clone为私有方法，内容为空
  96.     }
  99. }
  101. echo '<hr>';
  102. $connectParams=['mysql:host=localhost;dbname=youya','root','root'];
  103. //当前DB类实例化
  104. $pdo =Db::getInstance(...$connectParams);
  106. print_r($pdo->query('SELECT * FROM `user`')->fetchAll());
  107. //    为了演示这里没用预处理

demo2

  1. <?php
  2. namespace _1205;
  3. //工厂模式:批量new类生产，用于批量创建类的实例/对象
  4. class Demo2
  5. {
  7. }
  8. //file1.php
  9. $obj1 = new Demo2();
  10. //file2.php
  11. $obj2 = new Demo2();
  12. //file3.php
  13. $obj3 = new Demo2();
  15. /************************************************************/
  16. //创建一个批量生成器
  17. class Test1
  18. {
  19.     public function __construct($arg1)
  20.     {
  21.         echo '对象创建成功，参数是：'.$arg1;
  22.     }
  23. }
  25. class Test2
  26. {
  27.     public function __construct($arg1,$arg2)
  28.     {
  29.         echo '对象创建成功，参数是：'.implode(',',[$arg1,$arg2]);
  30.         //数组切割implode拆成字符串
  31.     }
  32. }
  34. class Test3
  35. {
  36.     public function __construct($arg1,$arg2,$arg3)
  37.     {
  38.         echo '对象创建成功，参数是：'.implode(',',[$arg1,$arg2,$arg3]);
  39.         //数组切割implode拆成字符串
  40.     }
  41. }
  43. //把上面三个类Test1,Test2,Test3,都实例化
  44. //原始的笨办法 new Test1（）；new Test2();new Test3();
  45. //现在优化的方法就是用工厂类
  46. class Factory
  47. {
  48.     //尽可能不要实例化，用类来访问，写成静态方法
  49.     // creat(类名称，构造方法的参数)
  50.     public static function creat($className,...$argments)
  51.     {
  52.             //里面专业new类，最后return出来给调用者
  53.         return new $className(...$argments);
  54.     }
  55. }
  57. echo Test1::class; //Test1::class返回来的类名是带有命名空间的完成的类名
  58. //用工厂类来创建类实例
  59. Factory::creat(Test1::class,100);
  60. //☆☆☆☆☆☆☆☆注意，类是有命名空间的，要写上命名空间，不要忽略了,写成_1205\Test1,或者Test1::class
  61. echo '<hr>';
  62. Factory::creat(Test2::class,100,200);
  63. echo '<hr>';
  64. Factory::creat(Test3::class,100,200,300);

demo3 依赖注入的知识复习

  1. <?php
  2. namespace _1205;
  3. //依赖注入：解决对象调用之间的耦合问题
  4. //依赖注入需要两个类：
  5. //1.工作类 ：真正干活的
  7. class Person
  8. {
  9.     //这是一个工作类,先把要依赖的外部对象创建成属性
  10.     private $car=null;
  12.     //构造方法中把依赖的外部对象全部实例化
  13.     //就是把注入点放在构造方法中,在new的过程中直接完成注入
  14.     public function __construct()
  15. //        依赖注入的目标就是将类方法中的new干掉
  16.     {
  17.         $this->car=new Car();
  18.     }
  20. //    外部对象执行一个动作
  21.     public function work()
  22.     {
  23.         return $this->car->drive();
  24.     }
  25. }
  27. //2.依赖的外部类
  28. class Car
  29. {
  30. //    这个Car类就是Person类所依赖的外部对象
  31.     public function drive()
  32.         {
  33.             return '开车去上班';
  34.         }
  36. }
  39. //客户端访问 实例化工作类(真正干活的)
  40. $person=new Person();
  41. //然后直接访问工作类的一个方法
  42. echo $person->work();
  43. echo '<hr>';
  44. //以上为传统模式,但耦合度太高,类中出现类new 实例化对象方法
  45. /***************************************************************/
  46. //那么在那里实例化呢?把它放在客户端
  48. class Person1
  49. {
  50.     //这是一个工作类,先把要依赖的外部对象创建成属性
  51.     private $car=null;
  53.     //构造方法中把依赖的外部对象全部实例化
  54.     //就是把注入点放在构造方法中,在new的过程中直接完成注入
  55.     public function __construct(Car $car)
  56. //         这里先写一个类型申明,然后创建一个变量叫$car,这样就实现了通过外部对象注入到当前类中
  57. //        依赖注入的目标就是将类方法中的new干掉
  59.     {
  60.         $this->car=$car;
  61.     }
  63. //    外部对象执行一个动作
  64.     public function work()
  65.     {
  66.         return $this->car->drive();
  67.     }
  68. }
  70. //2.依赖的外部类
  71. class Car1
  72. {
  73. //    这个Car类就是Person类所依赖的外部对象
  74.     public function drive()
  75.     {
  76.         return '开车去上班';
  77.     }
  79. }
  81. //客户端访问 实例化工作类(真正干活的)
  82. //那么在那里实例化呢?把它放在客户端:$car=new Car();,然后注入到构造方法的参数中$person=new Person1($car)
  83. $car=new Car();
  84. $person=new Person1($car);
  85. //然后直接访问工作类的一个方法
  86. echo $person->work();
  87. echo '<hr>';

demo4容器的知识复习

  1. <?php
  3. //容器类
  4. namespace _1205;
  5. //引入闭包别名
  6. use Closure; //类的new创建过程代码是个闭包函数,先use引入
  8. class Container
  9. {
  10.     //类实例容器
  11.     protected $instance=[];
  12.     // 1.将类实例化的过程绑定到容器中
  13.     public function bind($alias,Closure $process)
  14.         //绑定的时候需要参数?哪些参数--实例对象名,绑定过程的闭包函数
  15.     {
  16.         $this->instance[$alias]=$process;
  17. //                     $product=new Product(); ↑对应关系
  18.     }
  20.     // 2.取出保存在容器中的实例化过程的闭包,并执行它
  21.     public function make($alias)
  22.     {
  23.         return $this->instance[$alias]();
  24. // 用户代理call_user_func_array是异步调用的过程,由系统决定何时运行,不会导致堵塞
  25.     }
  26. }
  1. <?php
  2. namespace _1205;
  3. //先不用容器.用传统方式
  4. //先创建一个客户端的类
  5. use http\Client;
  7. require 'Product.php';
  8. require 'Maker.php';
  9. require 'Container.php';
  10. //把产品类和制造商类导入
  12. class Client2
  13. {
  14. //    输出商品与制造商
  15.     public function show(Product $product,Maker $maker)
  16.     {
  17. //        //1.创建一个产品的实例
  18. //        $product=new Product();
  19. //        //2.创建一个制造商的实例
  20. //        $maker=new Maker();
  21. //        用了容器,传统方法的1.2.步骤就不用了
  22.         //3.把制造商注入到产品类中
  23.         return $product->get($maker);
  24.     }
  25. }
  26. //客户端调用
  27. //将类实例绑定到容器中并实例化且返回
  28. $container = new Container();
  29. //将实例化代码绑定到容器实例中
  30. $container->bind('product',function(){return new Product();});
  31. $container->bind('maker',function(){return new Maker();});
  32. //这里bind('product')别名无所谓,写'abc'也可以,只要对应起来就可以,function()不用参数{return new 类}
  33. //创建实例并返回
  34. $product=$container->make('product');
  35. //    这里make要传参数,你调用谁就传谁,实例化的别名
  36. $maker=$container->make('maker');
  38. echo (new Client2())->show($product,$maker);
  39. //依赖注入

demo5

  1. <?php
  2. //旅行,使用最原始的方式
  4. namespace base;
  6. //设置引用的外部别名
  7. use base\inc2\Car;
  8. use base\inc2\Ship;
  9. use base\inc2\Train;
  10. use base\inc2\Plane;
  11. use base\inc2\iVehicle; //导入接口空间
  12. require __DIR__ . '/autoload.php'; //自动加载类
  14. class Travel3
  15. {
  16.     //交通工具
  17.     private $vehicle;
  19.     //构造方法
  20.     public function __construct(iVehicle $vehicle)
  21.     {
  22.         $this->vehicle=$vehicle;
  23. //        实现了接口的类实例可以这样直接调用
  24.     }
  26.     //        调用外部依赖对象
  27.     public function travelModel()
  28.     {
  29.         return $this->vehicle->drive().'======去旅行';
  30.     }
  31. }
  33. //客户端调用
  34. $car=new Car();
  35. echo (new Travel3($car))->travelModel().'<br>';
  36. //这里需要传参，传什么参数，这里需要的是一个对象了public function __construct(iVehicle $vehicle)
  37. echo (new Travel3(new Train()))->travelModel().'<br>';
  38. echo (new Travel3(new Plane()))->travelModel().'<br>';
  39. echo (new Travel3(new Ship()))->travelModel().'<br>';

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


.

课堂小结：

1.单例模式

思路：把外面实例化的操作功能禁用掉，禁用new新实例,把构造方法__congstruct改为private
目前只能在类的内部将类实例化，这样类中访问只能用静态成员,成员属性和方法都static静态化
判断当前类是否已经被实例化过了，如果没有的化就实例化，如果已创建就返回他

2.工厂模式

批量new类生产，用于批量创建类的实例/对象
尽可能不要实例化，用类来访问，写成静态方法

  1.     public static function creat($className,...$argments)
  2.     {
  3.             //里面专业new类，最后return出来给调用者
  4.         return new $className(...$argments);
  5.     }

3.依赖注入

目标：就是将类方法中的new干掉，解决对象调用之间的耦合问题。除了单例模式，其他类中尽量不要出现new xxx（）实例化类；
那么不要new在那里实例化呢?——把它放在客户端 拿到对象后，把他注入到构造方法中作为参数*
依赖注入需要两个类：

(1)工作类 ：真正干活的

构造方法中把依赖的外部对象全部实例化，方法很简单，就是把注入点放在构造方法中作为参数

(2)依赖的外部类

4.容器复习

容器里有个数组
例如$instance[对象]=类的new创建过程代码
关键：
（1）类实例容器$instance=[];
（1）放进去:将类实例化的过程绑定到容器中 bind（）//绑定的时候需要参数?哪些参数—实例对象名,绑定过程的闭包函数
（2）取出来用：取出保存在容器中的实例化过程的闭包,并执行它。
make（）对应类的new创建过程代码
结合用户代理来用call_user_func_arry()

面向接口编程

接口命名规划用小写开头 如iVehicle
implements实现接口类
小技巧：按alt键选择可以多点编辑

  1.     //构造方法
  2.     public function __construct(iVehicle $vehicle)
  3.     {
  4.         $this->vehicle=$vehicle;
  5.     }
上一条：028-12月04日-PHP第18节-静态类、MVC框架、依赖注入等下一条：异常处理+文件上传+模型类映射
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多