简体中文（ZH-CN）English（EN）繁体中文（ZH-TW）日本語（JA）한국어（KO）Melayu（MS）Français（FR）Deutsch（DE）
Home
Article
Q&A
Course
Topic
Download
Game
Dictionary
Recent Updates

博客列表 >PHP 第课 ：手写Demo5.php 12月4日

PHP 第课 ：手写Demo5.php 12月4日

孤忆寻昔R
孤忆寻昔R原创
2019年12月15日 22:38:13812浏览

作业一

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门面 使用将常用的操作方法封装成静态，然后用子类调用

上一条：030-12月06日-MVC小框架下一条：tp5 验证码刷新和二次刷新验证失败
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多