Community Learn Tools Library Leisure
search
English
Home > List of blog posts > PHP 第课 ：手写Demo5.php 12月4日
Blogger Information
Blog 26
fans 1
comment 0
visits 22358
Special Recommendation
More>
Related recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
PHP 第课 ：手写Demo5.php 12月4日
孤忆寻昔R
Original
815 people have browsed it

作业一

Demo1.php 认识静态static

  1. <?php
  3. namespace _1204; //认识静态static
  5. //static : 声明类中的静态成员
  7. /*class Db1
  8. {
  10. //    非静态成员： 必须实例化后才能访问
  11. //   public function demo()
  12. //   {
  13. //
  14. //   }
  15. //
  16. }*/
  18. //1、创建类
  19. use PDO;
  21. class Db1
  22. {
  24.     //2、添加类成员
  26. //    添加的静态成员: 属性， 方法
  27.     protected static $pdo;
  28.     protected static $dsn = 'mysql:host=127.0.0.1;dbname=pdo';
  29.     protected static $username = 'root';
  30.     protected static $password = 'root';
  32.     //静态方法
  33.     public  static function connect()
  34.     {
  36.         //在类中访问当前类的静态成员
  37.         self::$pdo = new PDO(self::$dsn,self::$username,self::$password);
  38.     }
  40.     //使用静态方法
  41.     public static function select()
  42.     {
  43.         self::connect();
  44.         return self::$pdo->query('select * from `users`',PDO::FETCH_ASSOC);
  47.     }
  49. }
  51. //3、访问类成员 静态调用不同实例化
  52. $result = Db1::select();
  54. foreach($result as $row){
  55.     echo '<pre>'.print_r($row,true).'</pre>';
  56. }

Demo2.php 静态调用

  1. <?php
  2. namespace _1204;
  3. //static: 后期静态绑定 延迟绑定
  5. //使用场景: 静态继承的上下文环境中
  7. //类成员访问绑定时间: 在声明的时候绑定，在调用的时候绑定
  9. //后期绑定就是在类成员被调用的时候在动态绑定，也叫: 延迟绑定
  12. use PDO;
  14. class Db2
  15. {
  16. //    1、添加静态成员
  17.     protected static $pdo;
  18.     protected static $dsn='mysql:host=127.0.0.1;dbname=pdo';
  19.     protected static $username = 'root';
  20.     protected static $password = 'root';
  23.     public static function connect()
  24.     {
  25. //        在类中访当前问静态成员: self::
  26.         self:: $pdo = new PDO(self::$dsn,self::$username,self::$password);
  29.     }
  31.     public static function select()
  32.     {
  33. //        1、在子类中使用父类方法需要将self换成 static
  34.         static::connect();
  35.         return self::$pdo->query('select * from `users`',PDO::FETCH_ASSOC);
  37.     }
  39. }
  41. //继承Db2父类
  42. class Sub extends Db2
  43. {
  44.     protected static $username = 'root';
  45.     protected static $password = 'root';
  47. //    使用子类自定义的connect方法
  48.     public static function connect()
  49.     {
  51.         self::$pdo = new PDO(self::$dsn,self::$password,self::$username);
  53.     }
  55. }
  57. //访问类成员
  59. //$result = Db2::select();
  61. $result = Sub::select();
  63. //实际使用子类中conncet
  65. foreach($result as $wor)
  66. {
  67.     echo '<pre>'.print_r($wor,true).'</pre>';
  68. }

Model.php 定义模型

  1. <?php
  3. namespace mvc;
  6. //模型类: 用于数据表的操作
  8. class Model
  9. {
  10.     public function getData()
  11.     {
  12.         //用来模拟数组从数据表中获得商品数据
  13.         return [
  14.             ['id'=>1, 'name'=>'苹果电脑', 'model'=>'MackBook Pro', 'price'=>25800],
  15.             ['id'=>2, 'name'=>'华为手机', 'model'=>'MackBook Pro', 'price'=>4988],
  16.             ['id'=>3, 'name'=>'小爱同学', 'model'=>'AI音箱', 'price'=>399],
  18.         ];
  20.     }
  22. }

View.php 定义视图模板

  1. <?php
  3. namespace mvc;
  5. //视图类: 渲染数据
  7. class View
  8. {
  9. //    创建视图模板方法
  10.     public function fetch($data)
  11.     {
  12.         $table = '<table>';
  13.         $table .= '<caption>商品信息表</caption>';
  14.         $table .= '<tr><th>ID</th><th>品名</th><th>型号</th><th>价格</th></tr>';
  16. //        循环数据表
  17.         foreach($data as $product)
  18.         {
  19.             $table .= '<tr>';
  20.             $table .= '<td>'.$product['id'].'</td>';
  21.             $table .= '<td>'.$product['name'].'</td>';
  22.             $table .= '<td>'.$product['model'].'</td>';
  23.             $table .= '<td>'.$product['price'].'</td>';
  24.             $table .= '</tr>';
  25.         }
  26.         $table .= '</table>';
  27.         return $table;
  28.     }
  29. }
  31. //给表增加样式
  32. echo '<style>
  33. table {border-collapse: collapse;border: 1px solid; width: 500px;height: 150px}
  34. caption {font-size: 1.2rem; margin-bottom: 10px;}
  35. tr:first-of-type{background-color:lightblue;}
  36. td,th {border: 1px solid}
  37. td:first-of-type {text-align:center}
  38. </style>';
  40. //echo '<style>
  41. //table {border-collapse: collapse; border: 1px solid; width: 500px;height: 150px}
  42. //caption {font-size: 1.2rem; margin-bottom: 10px;}*/
  43. //tr:first-of-type { background-color:lightblue;}
  44. //td,th {border: 1px solid}
  45. //td:first-of-type {text-align: center}
  46. //</style>';

Demo1.php 控制器设置将表中的数据返回出来

  1. <?php
  3. //控制器： 将商品信息表展示出来
  6. namespace mvc;
  8. //1、加载模型
  9. require 'Model.php';
  13. //2、加载视图
  14. require 'View.php';
  16. //3、创建控制器
  17. class Controller1
  18. {
  19.     public function index()
  20.     {
  21.         //    3.1 获取数据
  22.             $model =new Model();
  23.            $data =  $model->getData();
  26.         //    3.2 渲染模板
  27.         $view = new View();
  28.         return $view->fetch($data);
  30.     }
  32. }
  34. //4、客户端调用  : 访问类成员
  35. $controller = new Controller1();
  36. echo $controller->index()；

Demo2.php 

  1. <?php
  3. //控制器： 将商品信息表展示出来
  5. //将类中的对其他类的实例化，模型/视图分离出来，降低耦合度
  7. //依赖注入
  9. namespace mvc;
  11. //1、加载模型
  12. require 'Model.php';
  16. //2、加载视图
  17. require 'View.php';
  21. //3、创建控制器
  22. class Controller2
  23. {
  24.     public function index( Model $model,View $view) //index方法要依赖于模型对象和视图对象 怎么办？通过参数方式传入
  25.     {
  26.         //在控制器中不不应该对模型和视图进行实例化  怎么办? 拿到类的外面去
  28.         //    3.1 获取数据
  29. //        $model =new Model();
  30.         $data =  $model->getData();
  33.         //    3.2 渲染模板
  34. //        $view = new View();
  35.         return $view->fetch($data);
  37.     }
  39. }
  41. //4、客户端调用  : 访问类成员
  42. //将模型与视图的实例化代码从控制器中分离出来， 放到了客户端
  43. $model = new Model();
  44. $view = new View();
  47. //将模型对象与视图对象，以参数的方式再次注入到控制器的方法
  48. $controller = new Controller2();
  49. echo $controller->index($model,$view); //'解决的耦合度

Demo3.php
<?php

  1. //控制器： 将商品信息表展示出来
  3. //依赖注入: 将注入点改到了控制器的构造方法中
  5. namespace mvc;
  7. //1、加载模型
  8. require 'Model.php';
  11. //2、加载视图
  12. require 'View.php';
  16. //3、创建控制器
  17. class Controller3
  18. {
  19.     protected $model;
  20.     protected $view;
  22.     //定点注入可以使用构造方法
  23. //    添加构造器,注入点改到了构造方法中，实现了模型与视图对象的共享
  24.     public function __construct(Model $model,View $view)
  25.     {
  26.         $this->model = $model;
  27.         $this->view = $view;
  28.     }
  30.     public function index( ) //index方法要依赖于模型对象和视图对象 怎么办？通过参数方式传入
  31.     {
  32.         //在控制器中不不应该对模型和视图进行实例化  怎么办? 拿到类的外面去
  34.         //    3.1 获取数据
  35. //        $model =new Model();
  36.         $data =  $this->model->getData();
  39.         //    3.2 渲染模板
  40. //        $view = new View();
  41.         return $this->view->fetch($data);
  43.     }
  45. }
  47. //4、客户端调用  : 访问类成员
  48. //将模型与视图的实例化代码从控制器中分离出来， 放到了客户端
  49. $model = new Model();
  50. $view = new View();
  53. //将模型对象与视图对象，以参数的方式再次注入到控制器的方法
  54. $controller = new Controller3($model,$view);
  55. echo $controller->index(); //'解决的耦合度

Demo4.php

  1. <?php
  3. //控制器： 将商品信息表展示出来
  5. //依赖注入: 将注入点改到了控制器的构造方法中
  7. namespace mvc;
  9. //1、加载模型 需要使用use 模型
  10. use BaconQrCode\Common\Mode;
  12. require 'Model.php';
  16. //2、加载视图
  17. require 'View.php';
  18. /*******************************************************************/
  22. //添加服务容器器
  23. class Container
  24. {
  25.     //    容器属性，就是一个数组，里面全是创建对象的方法
  26.         protected $instance =[];
  28.     //    1、放进去: 将类的实例化过程绑定到容器中
  29. //    $alias:类实例的别名
  30.         public function bind($alias,\Closure $process)
  31.         {
  32.             //将类实例化的方法绑定/ 存储到服务器容器中
  33.             $this->instance[$alias] = $process;
  35. //            $this->instance['model'] = 'new Model()';
  36.         }
  38.     //    2、取出来: 执行容器中的实例方法
  39.     public function make($alias,$params=[])
  40.     {
  41.         return call_user_func_array($this->instance[$alias],[]);
  43.     }
  45. }
  47. //实例容器
  48. $container =new Container();
  49. //用到模型对象，视图对象，将他们绑定到容器中    在写入代码时注意  参数以及拼写
  50. $container->bind('model',function(){return new Model();});
  51. $container->bind('view',function(){return new View();});
  52. //$container->bind('view', function () {return View();});
  55. /*******************************************************************/
  57. //3、创建控制器
  58. class Controller4
  59. {
  61.     public function index(Container $container ) //index方法要依赖于模型对象和视图对象 怎么办？通过参数方式传入
  62.     {
  63.         //在控制器中不不应该对模型和视图进行实例化  怎么办? 拿到类的外面去
  65.         //    3.1 获取数据
  66. //        $model =new Model();
  67.         $data =  $container->make('model')->getData();
  70.         //    3.2 渲染模板 
  71. //        $view = new View();
  72.         return $container->make('view')->fetch($data);
  74.     }
  76. }
  78. //4、客户端调用  : 访问类成员
  80. //将模型对象与视图对象，以参数的方式再次注入到控制器的方法
  81. $controller = new Controller4();
  82. echo $controller->index($container); //'解决的耦合度

Facade.php 门面模式 包含了依赖依赖注入和嵌套容器

  1. <?php
  3. //控制器： 将商品信息表展示出来
  5. //依赖注入: 将注入点改到了控制器的构造方法中
  7. //Facdae技术: 规范/统一了对外部对象的调用方式，全部改为了静态调用，不管之前的方法是什么类型
  10. namespace mvc;
  12. //1、加载模型 使用use 完成操作
  13. use BaconQrCode\Common\Mode;
  15. require 'Model.php';
  19. //2、加载视图
  20. require 'View.php';
  21. /*******************************************************************/
  25. //添加服务容器器
  26. class Container1
  27. {
  28.     //    容器属性，就是一个数组，里面全是创建对象的方法
  29.     protected $instance =[];
  31.     //    1、放进去: 将类的实例化过程绑定到容器中
  32. //    $alias:类实例的别名
  33.     public function bind($alias,\Closure $process)
  34.     {
  35.         //将类实例化的方法绑定/ 存储到服务器容器中
  36.         $this->instance[$alias] = $process;
  38. //            $this->instance['model'] = 'new Model()';
  39.     }
  41.     //    2、取出来: 执行容器中的实例方法
  42.     public function make($alias,$params=[])
  43.     {
  44.         return call_user_func_array($this->instance[$alias],[]);
  46.     }
  48. }
  50. /******************************************************/
  51. //添加Facade门面
  53. class Facade
  54. {
  55.     protected static $container = null;
  56.     protected static $data = [];
  57.     //用上面的容器给他初始化
  58.     public static function initialize(Container1 $container)
  59.     {
  60.         static::$container = $container;
  62.     }
  64.     //用静态代理的方法将模型中的getData()静态化
  65.     public static function getData()
  66.     {
  67.         static::$data = static::$container->make('model')->getData();
  69.     }
  71.     //用静态代理方式见视图总的fetch()静态化
  72.     public static function fetch()
  73.     {
  74.        return static::$container->make('view')->fetch(static::$data);
  75.     }
  77. }
  80. //声明一个学生类 ： 做一个子类子
  81. class Student extends Facade
  82. {
  83.     // 增删改查都可以用静态方法
  84. //    这样就能直接用子类调用
  86. }
  89. /******************************************************/
  91. //实例容器
  92. $container1 =new Container1();
  93. //用到模型对象，视图对象，将他们绑定到容器中
  94. $container1->bind('model',function(){return new Model();});
  95. $container1->bind('view',function(){return new View();});
  96. //$container->bind('view', function () {return View();});
  99. /*******************************************************************/
  101. //3、创建控制器
  102. class Controller5
  103. {
  104.     public function __construct(Container1 $container)
  105.     {
  106.         //调用Facade里面的初始化方法
  107.         Facade::initialize($container);
  110.     }
  112.     public function index() //index方法要依赖于模型对象和视图对象 怎么办？通过参数方式传入
  113.     {
  114.         //在控制器中不不应该对模型和视图进行实例化  怎么办? 拿到类的外面去
  116.         //    3.1 获取数据
  117. //        $model =new Model();
  118.         Student::getData();
  121.         //    3.2 渲染模板
  122. //        $view = new View();
  123.         return Student::fetch();
  125.     }
  127. }
  129. //4、客户端调用  : 访问类成员
  131. //将模型对象与视图对象，以参数的方式再次注入到控制器的方法
  132. $controller = new Controller5($container1);
  133. echo $controller->index(); //'解决的耦合度

作业二


总结

1、static静态调用访问成员，不用实例化！使用self 不能使用$this,成员也是static

2、模型用来设置操作数据表的，将模型和视图放在同命名空间下，不能使用同样的类

3、创建容器后可以不用在类中，实例化模型和和视图，维护更放心，代码优化

4、Facade门面 使用将常用的操作方法封装成静态，然后用子类调用

Correcting teacher：天蓬老师天蓬老师

Correction status：qualified

Teacher's comments：理解这里面的原理就可以了, 具体实现可以有不同方案
Statement of this Website
The copyright of this blog article belongs to the blogger. Please specify the address when reprinting! If there is any infringement or violation of the law, please contact admin@php.cn Report processing!
All comments Speak rationally on civilized internet, please comply with News Comment Service Agreement
0 comments
Author's latest blog post