search

博客列表 >12月04日_PHP类中静态成员和MVC（依赖注入、服务容器和Facade门面）

12月04日_PHP类中静态成员和MVC（依赖注入、服务容器和Facade门面）

fkkf467
fkkf467原创
2019年12月06日 14:08:46920浏览

一、类中静态成员

1. 声明静态成员

  1. <?php
  3. // 定义命名空间
  4. namespace _1204;
  6. // 为全局空间中的PDO类导入空间别名
  7. use PDO;
  9. // 1. 创建类
  10. class Db1
  11. {
  12.     // 2. 添加类成员
  13.     // 添加静态属性
  14.     protected static $pdo;
  15.     protected static $dsn = 'mysql:host=localhost;dbname=test';
  16.     protected static $username = 'root';
  17.     protected static $password = 'root';
  19.     // 添加静态方法
  20.     public static function connect()
  21.     {
  22.         // 在类中访问当前类的静态成员用 self::
  23.         self::$pdo = new PDO(self::$dsn, self::$username, self::$password);
  24.     }
  26.     // 测试方法
  27.     public static function select()
  28.     {
  29.         // 数据库连接
  30.         self::connect();
  31.         // 将查询结果以关联数组形式返回
  32.         return self::$pdo->query('SELECT * FROM `computer`', PDO::FETCH_ASSOC);
  33.     }
  34. }
  36. // 3. 访问类成员
  37. // 在类的外部，访问类中的静态成员，直接用类名进行访问
  38. $result = Db1::select();
  39. foreach ($result as $row) {
  40.     echo '<pre>' . print_r($row, true) . '</pre>';
  41. }
  42. ?>

2. 后期静态绑定

  1. <?php
  2. // 定义命名空间
  3. namespace _1204;
  5. // 后期静态绑定使用场景：静态继承的上下文环境中
  6. // 后期静态绑定就是在类成员被调用的时候再动态的绑定，也叫：延迟绑定
  8. use PDO;
  10. // 1. 创建类
  11. class Db2
  12. {
  13.     // 2. 添加类成员
  14.     // 静态属性
  15.     protected static $pdo;
  16.     protected static $dsn = 'mysql:host=localhost;dbname=test';
  17.     protected static $username = 'root';
  18.     protected static $password = 'root';
  20.     // 静态方法
  21.     public static function connect()
  22.     {
  23.         // 后期静态绑定就是将需要绑定的静态成员的访问由 self:: ,改为 static::
  24.         static::$pdo = new PDO(static::$dsn, static::$username, static::$password);
  25.     }
  27.     public static function select()
  28.     {
  29.         // 数据库连接
  30.         static::connect();
  31.         // 将查询结果以关联数组形式返回
  32.         return self::$pdo->query('SELECT * FROM `computer`', PDO::FETCH_ASSOC);
  33.     }
  34. }
  36. class Sub extends Db2
  37. {
  38.     protected static $username = 'root';
  39.     protected static $password = 'root';
  41.     // 重写父类中的connect()方法
  42.     public static function connect()
  43.     {
  44.         self::$pdo = new PDO(self::$dsn, self::$username, self::$password);
  45.     }
  46. }
  48. // 3. 访问类成员
  49. // 在类的外部,访问类中的静态成员, 直接用类名
  50. // 由于在父类中的select()方法中调用connect()方法时使用了后期静态绑定，
  51. //又由于子类对connect()方法进行了重写，所以这时，用的就是子类中的 connect() 方法
  52. $result = Sub::select();
  53. foreach ($result as $row) {
  54.     echo '<pre>' . print_r($row, true) . '</pre>';
  55. }
  56. ?>

二、MVC

1. 模型类 Model.php

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

2. 视图类 View.php

  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>';
  13.         foreach ($data as $product) {
  14.             $table .= '<tr>';
  15.             $table .= '<td>' . $product['id'] . '</td>';
  16.             $table .= '<td>' . $product['name'] . '</td>';
  17.             $table .= '<td>' . $product['model'] . '</td>';
  18.             $table .= '<td>' . $product['price'] . '</td>';
  19.             $table .= '</tr>';
  20.         }
  21.         $table .= '</table>';
  22.         return $table;
  23.     }
  24. }
  26. echo '<style>
  27. table {border-collapse: collapse; border: 1px solid; width: 500px;height: 150px}
  28. caption {font-size: 1.2rem; margin-bottom: 10px;}
  29. tr:first-of-type { background-color:lightblue;}
  30. td,th {border: 1px solid}
  31. td:first-of-type {text-align: center}
  32. </style>';

3. MVC简单实现

  1. <?php
  3. namespace mvc;
  5. // 1. 加载模型
  6. require 'Model.php';
  8. // 2. 加载视图
  9. require 'View.php';
  11. // 3. 创建控制器
  12. // 控制器：将商品信息表展示出来
  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();
  30. ?>

4. 通过依赖注入，降低耦合度

a. 将注入点改到控制器的普通方法中

  1. <?php
  3. // 依赖注入
  4. // 将类中对其它类的实例化，分离出来, 降低耦合度
  5. //例如：下面将模型/视图类的实例化分离出来
  7. namespace mvc;
  9. // 1. 加载模型
  10. require 'Model.php';
  12. // 2. 加载视图
  13. require 'View.php';
  15. // 3. 创建控制器
  16. class Controller2
  17. {
  18.     public function index(Model $model, View $view)
  19.     {
  20.         // 获取数据
  21.         $data = $model->getData();
  22.         // 渲染模板
  23.         return $view->fetch($data);
  24.     }
  25. }
  27. // 4.客户端访问类成员
  28. // 将模型与视图的实例化从控制器分离出来，放到客户端
  29. $model = new Model();
  30. $view = new View();
  32. // 将模型对象与视图对象，以参数的形式再次注入到控制器的方法中
  33. $controller = new Controller2();
  34. echo $controller->index($model, $view);

b. 将注入点改到控制器的构造方法中

  1. <?php
  3. // 依赖注入：将注入点改到控制器的构造方法中
  5. namespace mvc;
  7. // 1. 加载模型
  8. require 'Model.php';
  9. // 2. 加载视图
  10. require 'View.php';
  12. // 3. 创建控制器
  13. class Controller3
  14. {
  15.     protected $model;
  16.     protected $view;
  18.     // 将注入点改到构造方法中，实现了模型与视图对象的共享
  19.     public function __construct(Model $model, View $view)
  20.     {
  21.         $this->model = $model;
  22.         $this->view = $view;
  23.     }
  25.     public function index()
  26.     {
  27.         // 获取数据
  28.         $data = $this->model->getData();
  29.         // 渲染模板
  30.         return $this->view->fetch($data);
  31.     }
  32. }
  34. // 4. 客户端访问类成员
  35. // 将模型与视图的实例化从控制器分离出来，放到客户端
  36. $model = new Model();
  37. $view = new View();
  39. // 将模型对象和视图对象，以参数的形式注入到控制器的构造方法
  40. $controller = new Controller3($model,$view);
  41. echo $controller->index();
  42. ?>

5. 添加服务容器层

  1. <?php
  3. namespace mvc;
  5. // 1. 加载模型
  6. require 'Model.php';
  7. // 2. 加载视图
  8. require 'View.php';
  10. // 添加服务容器层
  11. class Container
  12. {
  13.     // 容器属性，就是一个数组，保存着创建对象的方法
  14.     protected $instance = [];
  16.     // 1. 放进去：将类的实例化过程绑定到容器中
  17.     // 就是将类实例化的方法存入到容器属性$instance数组中
  18.     // $alias: 类实例的别名，Closure 闭包类
  19.     public function bind($alias, \Closure $process)
  20.     {
  21.         // 将类实例化的方法绑定/存储到服务容器中
  22.         $this->instance[$alias] = $process;
  23.     }
  25.     // 2. 取出来：执行容器中的实例化方法
  26.     public function make($alias, $params = [])
  27.     {
  28.         // 调用回调函数，本实例即返回实例化方法的结果
  29.         return call_user_func_array($this->instance[$alias], []);
  30.     }
  31. }
  33. // 实例化容器
  34. $container = new Container();
  36. // 将模型对象和视图对象绑定到容器中
  37. $container->bind('model', function () {
  38.     return new Model();
  39. });
  40. $container->bind('view', function () {
  41.     return new View();
  42. });
  44. // 3. 创建控制器
  45. class Controller4
  46. {
  47.     public function index(Container $container)
  48.     {
  49.         // 获取数据
  50.         $data = $container->make('model')->getData();
  51.         // 渲染模板
  52.         return $container->make('view')->fetch($data);
  53.     }
  54. }
  56. // 4. 客户端调用
  57. $controller = new Controller4();
  58. echo $controller->index($container);
  59. ?>

6. Facade门面

  1. <?php
  3. namespace mvc;
  5. // 1. 加载模型
  6. require 'Model.php';
  7. // 2. 加载视图
  8. require 'View.php';
  10. // 添加服务容器层
  11. class Container1
  12. {
  13.     // 容器属性，就是一个数组，保存着创建对象的方法
  14.     protected $instance = [];
  16.     // 1. 放进去：将类的实例化过程绑定到容器中
  17.     // 就是将类实例化的方法存入到容器属性$instance数组中
  18.     // $alias: 类实例的别名，Closure 闭包类
  19.     public function bind($alias, \Closure $process)
  20.     {
  21.         // 将类实例化的方法绑定/存储到服务容器中
  22.         $this->instance[$alias] = $process;
  23.     }
  25.     // 2. 取出来：执行容器中的实例化方法
  26.     public function make($alias, $params = [])
  27.     {
  28.         // 调用回调函数，本实例即返回实例化方法的结果
  29.         return call_user_func_array($this->instance[$alias], []);
  30.     }
  31. }
  33. // 实例化容器
  34. $container = new Container1();
  36. // 将模型对象和视图对象绑定到容器中
  37. $container->bind('model', function () {
  38.     return new Model();
  39. });
  40. $container->bind('view', function () {
  41.     return new View();
  42. });
  44. // 添加Facade门面类
  45. class Facade
  46. {
  47.     protected static $container = null;
  48.     protected static $data = [];
  50.     // 用服务容器将静态属性初始化
  51.     public static function initialize(Container1 $container)
  52.     {
  53.         static::$container = $container;
  54.     }
  56.     // 用静态代理方式将模型类中的getData()静态化
  57.     public static function getData()
  58.     {
  59.         static::$data = static::$container->make('model')->getData();
  60.     }
  62.     // 用静态代理方式将视图类中的fetch()静态化
  63.     public static function fetch()
  64.     {
  65.         return static::$container->make('view')->fetch(static::$data);
  66.     }
  67. }
  69. // 声明一个学生类继承门面类
  70. class Student extends Facade
  71. {
  73. }
  75. // 3. 创建控制器
  76. class Controller5
  77. {
  78.     // 使用构造方法，自动调用Facade里面的初始化方法
  79.     public function __construct(Container1 $container)
  80.     {
  81.         Student::initialize($container);
  82.     }
  84.     public function index()
  85.     {
  86.         // 获取数据
  87.         Student::getData();
  88.         // 渲染模板
  89.         return Student::fetch();
  90.     }
  91. }
  93. // 4. 客户端调用
  94. $controller = new Controller5($container);
  95. echo $controller->index();
  96. ?>



三、总结

后期静态绑定是在类成员被调用的时候动态的绑定。
MVC就是控制器接受请求后，调用模型中的数据，通过视图将页面渲染出来。
通过依赖注入可以降低耦合度。
服务容器就是将类的实例化给包装到一个类中，即通过调用类中的方法，将类的实例化方法存进来，再取出去调用。
Facade门面就是通过静态代理方式将要实例化的类中的方法静态化，大大降低了耦合度。

上一条：12月05日- 设计模式与依赖注入下一条：1204作业MVC与框架基础PHP培训第九期线上班
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多