search

博客列表 >12月4号作业 静态成员及初识MVC

12月4号作业 静态成员及初识MVC

遗忘了寂寞
遗忘了寂寞原创
2019年12月05日 17:31:26636浏览

static: 声明类中的静态成员

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

static: 后期静态绑定

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

简单MVC

model.php

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

view.php

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

控制器: 将商品信息表展示出来

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

依赖注入

  1. <?php
  2. // 依赖注入
  3. namespace mvc;
  4. // 1. 加载模型
  5. use BaconQrCode\Common\Mode;
  6. require 'Model.php';
  7. // 2. 加载视图
  8. require 'View.php';
  9. // 3. 创建控制器
  10. class Controller2
  11. {
  12.    public function index(Model $model, View $view)
  13.    {
  14.        // 3.1 获取数据
  15.         $data = $model->getData();
  16.        // 3.2 渲染模板
  17.        return $view->fetch($data);
  18.    }
  19. }
  20. // 4. 客户端调用
  21. // 将模型与视图的实例化代码从控制器分离出来, 放到了客户端
  22. $model = new Model();
  23. $view = new View();
  24. // 将模型对象与视图对象,以参数的方式再次注入到控制器的方法
  25. $controller = new Controller2();
  26. echo $controller->index($model, $view);

依赖注入: 将注入点改到了控制器的构造方法中

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

添加服务容器层

  1. <?php
  2. namespace mvc;
  3. // 1. 加载模型
  4. use BaconQrCode\Common\Mode;
  5. require 'Model.php';
  6. // 2. 加载视图
  7. require 'View.php';
  8. //添加服务容器层
  9. class Container
  10. {
  11.     // 容器属性, 就是一个数组,里面全是创建对象的方法
  12.     protected $instance = [];
  14.     // 1. 放进去: 将类的实例化过程绑定到容器中
  15.     // $alias: 类实例的别名,
  16.     public function bind($alias, \Closure $process)
  17.     {
  18.         // 将类实例化的方法绑定/ 存储到服务容器中
  19.         $this->instance[$alias] = $process;
  20.     }
  21.     // 2. 取出来: 执行容器中的实例方法
  22.     public function make($alias, $params=[])
  23.     {
  24.        return call_user_func_array($this->instance[$alias], []);
  25.     }
  26. }
  28. // 实例化容器
  29. $container = new Container();
  30. // 用到模型对象, 视图对象,将它们绑定到容器中
  31. $container->bind('model', function () {return new Model();});
  32. $container->bind('view', function () {return new View();});
  34. // 3. 创建控制器
  35. class Controller4
  36. {
  37.     public function index(Container $container)
  38.    {
  39.        // 3.1 获取数据
  40.         $data = $container->make('model')->getData();
  42.        // 3.2 渲染模板
  43.        return $container->make('view')->fetch($data);
  44.    }
  45. }
  46. // 4. 客户端调用
  47. // 将模型对象与视图对象,以参数的方式再次注入到控制器的方法
  48. $controller = new Controller4();
  49. echo $controller->index($container);

Facade技术

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





总结：

学习了如何用static: 声明类中的静态成员
了解了static: 后期静态绑定及使用场景
初步了解了mvc设计模式及设计思想

上一条：12月02日- php基础复习下一条：12月4日作业 php mvc 容器 门面类
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多