search

博客列表 >1204作业MVC与框架基础PHP培训第九期线上班

1204作业MVC与框架基础PHP培训第九期线上班

淡月
淡月原创
2019年12月06日 12:49:481561浏览

1.类静态成员

  1. <?php
  3. namespace _1204;
  5. use PDO;
  6. // static: 声明类中的静态成员
  8. // 1. 创建类
  9. class Db1
  10. {
  11.     // 2. 添加类成员
  12.     // 添加的静态成员: 属性, 方法
  13.     // 静态属性
  14.     protected static $pdo;
  15.     protected static $dsn = 'mysql:host=127.0.0.1;dbname=mydb';
  16.     protected static $username = 'peter';
  17.     protected static $password = '123456';
  20.     // 静态方法
  21.     public static function connect()
  22.     {
  23.         // 在类中访问当前类的静态成员: self::
  24.         self::$pdo = new PDO(self::$dsn, self::$username, self::$password);
  25.     }
  27.     // 测试方法
  28.     public static function select()
  29.     {
  30.         // 连接数据库
  31.         self::connect();
  32.         return self::$pdo->query('select * from `users`', PDO::FETCH_ASSOC);
  33.     }
  35. }
  37. // 3. 访问类成员
  38. // 在类的外部,访问类中的静态成员, 直接用类名
  39. $result = Db1::select();
  40. foreach ($result as $row) {
  41.     echo '<pre>'  . print_r($row, true) . '</pre>';
  42. }

2.后期静态绑定

  1. <?php
  3. namespace _1204;
  5. // static: 后期静态绑定
  6. // 使用场景 : 静态继承的上下文环境中
  7. // 类成员访问绑定时间: 在声明的时候绑定, 在调用的时候绑定
  8. // 后期绑定就是在类成员被调用的时候再动态的绑定, 也叫:延迟绑定
  10. use PDO;
  11. // static: 声明类中的静态成员
  13. // 1. 创建类
  14. class Db2
  15. {
  16.     // 2. 添加类成员
  17.     // 添加的静态成员: 属性, 方法
  18.     // 静态属性
  19.     protected static $pdo;
  20.     protected static $dsn = 'mysql:host=127.0.0.1;dbname=mydb';
  21.     protected static $username = 'peter';
  22.     protected static $password = '123456';
  25.     // 静态方法
  26.     public static function connect()
  27.     {
  28.         // 在类中访问当前类的静态成员: self::
  29.         static::$pdo = new PDO(static::$dsn, static::$username, static::$password);
  30.     }
  32.     // 测试方法
  33.     public static function select()
  34.     {
  35.         // 连接数据库
  36.         static::connect();
  37.         return self::$pdo->query('select * from `users`', PDO::FETCH_ASSOC);
  38.     }
  40. }
  42. class Sub extends Db2
  43. {
  44.     protected static $username = 'peter';
  45.     protected static $password = '123456';
  46.     public static function connect()
  47.     {
  48.         self::$pdo = new PDO(self::$dsn, self::$username, self::$password);
  49.     }
  50. }
  52. // 3. 访问类成员
  53. // 在类的外部,访问类中的静态成员, 直接用类名
  54. $result = Sub::select();
  55. //本意是想用子类中的connect();
  56. foreach ($result as $row) {
  57.     echo '<pre>'  . print_r($row, true) . '</pre>';
  58. }

3.MODEL 模型类

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

4.view视图

  1. <?php
  3. namespace mvc;
  5. // 视图类:渲染数据
  6. class View
  7. {
  8.     public function fetch($data)
  9.     {
  10.         $table = '<table>';
  11.         $table .= '<caption>商品信息表</caption>';
  12.         $table .= '<tr><th>ID</th><th>品名</th><th>型号</th><th>价格</th></tr>';
  14.         foreach ($data as $product) {
  15.             $table .= '<tr>';
  16.             $table .= '<td>' . $product['id'] . '</td>';
  17.             $table .= '<td>' . $product['name'] . '</td>';
  18.             $table .= '<td>' . $product['model'] . '</td>';
  19.             $table .= '<td>' . $product['price'] . '</td>';
  20.             $table .= '</tr>';
  21.         }
  22.         $table .= '</table>';
  23.         return $table;
  24.     }
  25. }
  27. echo '<style>
  28. table {border-collapse: collapse; border: 1px solid; width: 500px;height: 150px}
  29. caption {font-size: 1.2rem; margin-bottom: 10px;}
  30. tr:first-of-type { background-color:lightblue;}
  31. td,th {border: 1px solid}
  32. td:first-of-type {text-align: center}
  33. </style>';

5

5.Controller控制器

demo1

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

demo2

  1. <?php
  3. // 控制器: 将商品信息表展示出来
  5. // 将类中对其它类的实例化, 模型/视图分离出来, 降低耦合度
  7. // 依赖注入
  9. namespace mvc;
  11. // 1. 加载模型
  12. use BaconQrCode\Common\Mode;
  14. require 'Model.php';
  16. // 2. 加载视图
  17. require 'View.php';
  19. // 3. 创建控制器
  20. class Controller2
  21. {
  22.     public function index(Model $model, View $view)
  23.     {
  24.         // 3.1 获取数据
  25.         $data = $model->getData();
  27.         // 3.2 渲染模板
  28.         return $view->fetch($data);
  29.     }
  30. }
  32. // 4. 客户端调用/访问类成员
  33. // 将模型与视图的实例化代码从控制器分离出来, 放到了客户端
  34. $model = new Model();
  35. $view = new View();
  37. // 将模型对象与视图对象,以参数的方式再次注入到控制器的方法
  38. $controller = new Controller2();
  39. echo $controller->index($model, $view);

demo3

  1. <?php
  3. // 控制器: 将商品信息表展示出来
  6. // 依赖注入: 将注入点改到了控制器的构造方法中
  8. namespace mvc;
  10. // 1. 加载模型
  11. use BaconQrCode\Common\Mode;
  13. require 'Model.php';
  15. // 2. 加载视图
  16. require 'View.php';
  18. // 3. 创建控制器
  19. class Controller3
  20. {
  21.     protected $model;
  22.     protected $view;
  23.     // 构造方法, 注入点改到了构造方法中, 实现了模型与视图对象的共享
  24.     public function __construct(Model $model, View $view)
  25.     {
  26.         $this->model = $model;
  27.         $this->view = $view;
  28.     }
  30.     public function index()
  31.     {
  32.         // 3.1 获取数据
  33.         $data = $this->model->getData();
  35.         // 3.2 渲染模板
  36.         return $this->view->fetch($data);
  37.     }
  38. }
  40. // 4. 客户端调用/访问类成员
  41. // 将模型与视图的实例化代码从控制器分离出来, 放到了客户端
  42. $model = new Model();
  43. $view = new View();
  45. // 将模型对象与视图对象,以参数的方式再次注入到控制器的方法
  46. $controller = new Controller3($model, $view);
  47. echo $controller->index();

demo4

  1. <?php
  3. // 控制器: 将商品信息表展示出来
  6. // 依赖注入: 将注入点改到了控制器的构造方法中
  8. namespace mvc;
  10. // 1. 加载模型
  11. use BaconQrCode\Common\Mode;
  13. require 'Model.php';
  15. // 2. 加载视图
  16. require 'View.php';
  18. /**************************************************/
  19. //添加服务容器层
  20. class Container
  21. {
  22.     // 容器属性, 就是一个数组,里面全是创建对象的方法
  23.     protected $instance = [];
  25.     // 1. 放进去: 将类的实例化过程绑定到容器中
  26.     // $alias: 类实例的别名,
  27.     public function bind($alias, \Closure $process)
  28.     {
  29.         // 将类实例化的方法绑定/ 存储到服务容器中
  30.         $this->instance[$alias] = $process;
  31.     }
  32.     // 2. 取出来: 执行容器中的实例方法
  33.     public function make($alias, $params=[])
  34.     {
  35.         return call_user_func_array($this->instance[$alias], []);
  36.     }
  37. }
  39. // 实例化容器
  40. $container = new Container();
  41. // 用到模型对象, 视图对象,将它们绑定到容器中
  42. $container->bind('model', function () {return new Model();});
  43. $container->bind('view', function () {return new View();});
  45. /**************************************************/
  47. // 3. 创建控制器
  48. class Controller4
  49. {
  50.     public function index(Container $container)
  51.     {
  52.         // 3.1 获取数据
  53.         $data = $container->make('model')->getData();
  55.         // 3.2 渲染模板
  56.         return $container->make('view')->fetch($data);
  57.     }
  58. }
  60. // 4. 客户端调用/访问类成员
  62. // 将模型对象与视图对象,以参数的方式再次注入到控制器的方法
  63. $controller = new Controller4();
  64. echo $controller->index($container);

demo5

  1. <?php
  3. // 控制器: 将商品信息表展示出来
  6. // Facade技术: 规范/统一了对外部对象的调用方式, 全部改为了静态调用, 不管之前的方法是什么类型
  7. // laravel, thinkphp
  9. namespace mvc;
  11. // 1. 加载模型
  12. use BaconQrCode\Common\Mode;
  14. require 'Model.php';
  16. // 2. 加载视图
  17. require 'View.php';
  19. /**************************************************/
  20. //添加服务容器层
  21. class Container1
  22. {
  23.     // 容器属性, 就是一个数组,里面全是创建对象的方法
  24.     protected $instance = [];
  26.     // 1. 放进去: 将类的实例化过程绑定到容器中
  27.     // $alias: 类实例的别名,
  28.     public function bind($alias, \Closure $process)
  29.     {
  30.         // 将类实例化的方法绑定/ 存储到服务容器中
  31.         $this->instance[$alias] = $process;
  32.     }
  33.     // 2. 取出来: 执行容器中的实例方法
  34.     public function make($alias, $params=[])
  35.     {
  36.         return call_user_func_array($this->instance[$alias], []);
  37.     }
  38. }
  40. // 实例化容器
  41. $container = new Container1();
  42. // 用到模型对象, 视图对象,将它们绑定到容器中
  43. $container->bind('model', function () {return new Model();});
  44. $container->bind('view', function () {return new View();});
  46. /**************************************************/
  47. // 添加Facade门面类
  48. class Facade
  49. {
  50.     protected static $container = null;
  51.     protected static $data = [];
  53.     // 用服务容器给它初始化
  54.     public static function initialize(Container1 $container)
  55.     {
  56.         static::$container = $container;
  57.     }
  59.     // 用静态代理方式将模型中的getData()静态化
  60.     public static function getData()
  61.     {
  62.         static::$data = static::$container->make('model')->getData();
  63.     }
  65.     // 用静态代理方式将视图中的fetch()静态化
  66.     public static function fetch()
  67.     {
  68.         return static::$container->make('view')->fetch(static::$data);
  69.     }
  70. }
  72. // 声明一学生类
  73. class Student extends Facade
  74. {
  75.     //
  76. }
  78. /**************************************************/
  79. // 3. 创建控制器
  80. class Controller5
  81. {
  82.     public function __construct(Container1 $container)
  83.     {
  84.         // 调用Faceda里面的初始化方法
  85.         Student::initialize($container);
  86.     }
  88.     public function index()
  89.     {
  90.         // 3.1 获取数据
  91.         Student::getData();
  93.         // 3.2 渲染模板
  94.         return Student::fetch();
  95.     }
  96. }
  98. // 4. 客户端调用/访问类成员
  100. // 将模型对象与视图对象,以参数的方式再次注入到控制器的方法
  101. $controller = new Controller5($container);
  102. echo $controller->index();

手抄作业




总结

学习了如何使用static：声明类中的静态成员
初步了解了MVC结构与框架基础
M:model，模型，类用于数据表的操作
V:view，视图类:渲染数据
C：Controller，控制器：将商品信息表展示出来

上一条：12月04日_PHP类中静态成员和MVC（依赖注入、服务容器和Facade门面）下一条：小程序获取微信发fa票抬头
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多