简体中文（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

博客列表 >028-12月04日-PHP第18节-静态类、MVC框架、依赖注入等

028-12月04日-PHP第18节-静态类、MVC框架、依赖注入等

冇忉丼
冇忉丼原创
2019年12月09日 00:03:47625浏览

1. 将课堂源代码, 全部写一遍, 在编辑器中写就可, 必须全部运行正确, 并加上自己理解的注释,不用手写

1.静态类

所谓静态，指以static关键字修饰的，包括类，方法。
静态类访问方法：

1、静态方法不需要实例化对象，可以通过类名直接调用，操作符为双冒号::

2、外部访问公共属性或方法(与普通类一样)：

  1.  $car->speed;$car->speedUp();

3、内部访问公共属性和方法（与普通类一样）：

  1.  $this->speed;$this->speedUp();

4、外部访问静态属性或方法：

  1.  Car::getName();Car::$price;

5、内部访问静态属性：（可用延迟调用—static代替self）

  1.  self::$price;

6、继承类时，子类内部调用父类静态属性：

  1.  parent::$price;
  3. class Controller_article extends Controller_basepage {
  5.       function __construct() {
  7.             parent::__construct();
  9.       }
  11. }

静态类的需求：

  1. 静态的变量或者是函数是保存的静态内存中的，只有到程序结束时才会被释放，那他是什么时候赋值的呢：是在编译的时候，动态类是在程序运行的时候动态分配的。如果类中调用一次，静态类在编译的时候需要多做工作，动态类在执行的时候需要多做工作，然而php是动态语言，每一次这两步都不掉,所以对于只运行一次的类，无所谓谁快谁慢。
  2. 但是如果一个类在程序当中要**多次调用**就不一样了，静态类是编译的时候就赋值了，程序之后的运行都可以直接调用过来，而不用动态的分配内存了，就节约了时间，这就是为什么静态类比动态类快的原因（前提是调用多次）。
  1. <?php
  2. //demo1
  3. namespace _1204;
  4. use PDO; //静态类，全局
  6. class Db1{
  7.     protected static $pdo;//static使方法属性等不用实例化就可用类调用，既然如此，一般声明为
  8.     //protected
  9.     protected static $dsn = 'mysql:host=localhost;dbname=anguoguo';
  10.     protected static $username = 'root';
  11.     protected static $password = 'root';
  13.     //静态方法
  14.     public static function connect(){
  15.     //类中访问当前类的静态成员：self::
  16.     self::$pdo = new PDO(self::$dsn,self::$username,self::$password);
  17.     }
  19.     //测试方法
  20.     public static function select(){
  21.     self::connect();
  22.     return self::$pdo->query('select * from `users`',PDO::FETCH_ASSOC);
  23.     }
  24. }
  26. $result = Db1::select();
  27. foreach($result as $r){
  28.     echo '<pre>' . print_r($r,true) . '</pre>';
  29. }
  1. <?php
  2. //demo2延迟调用
  3. namespace _1204;
  4. use PDO;
  5. class Db2{
  6.     protected static $pdo;
  7.     protected static $dsn = 'mysql:host=localhost;dbname=anguoguo';
  8.     protected static $username = 'root';
  9.     protected static $password = 'root';
  11.     public static function connect(){
  12.         static ::$pdo = new PDO(static::$dsn,static::$username,static::$password);
  13.         //延迟绑定，动态绑定
  14.     }
  15.     public static function select(){
  16.         static ::connect();
  17.         return self::$pdo->query('select * from `users`',PDO::FETCH_ASSOC);
  18.     }
  19. }
  20. class Sub extends Db2{
  21.     protected static $username = 'root';
  22.     protected static $password = '123';
  23.     public static function connect(){
  24.         self ::$pdo = new PDO(self::$dsn,self::$username,self::$password);
  25.         //alt+j选择所有后面相同的单词
  26.     }
  27. }
  29. $result = Db1::select();
  30. foreach($result as $r){
  31.     echo '<pre>' . print_r($r,true) . '</pre>';
  32. }

mvc框架

mvc是一种常见设计模式，包括:model(模型)，view(视图)，controller(控制器)
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. }

View: 渲染数据，向用户显示模型的数据。视图知道如何访问模型的数据，但它不知道这些数据意味着什么，也不知道用户可以做什么来操作它。

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

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();

demo1类中实例化外部类，耦合度太高
所以以下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.将多个类实例绑定别名，多个类方法绑定到闭包，自然这些参数就需要放到数组里；2.取出来: 执行容器中的实例方法（使用了回调函数）

  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: 此例使用了Facade技术，其规范/统一了对外部对象的调用方式, 全部改为了静态调用, 不管之前的方法是什么类型

  1. <?php
  3. // 控制器: 将商品信息表展示出来
  6. // Facade技术: 规范/统一了对外部对象的调用方式, 全部改为了静态调用, 不管之前的方法是什么类型
  8. namespace mvc;
  10. // 1. 加载模型
  11. use BaconQrCode\Common\Mode;
  13. require 'Model.php';
  15. // 2. 加载视图
  16. require 'View.php';
  18. /**************************************************/
  19. //添加服务容器层
  20. class Container1
  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 Container1();
  41. // 用到模型对象, 视图对象,将它们绑定到容器中
  42. $container->bind('model', function () {return new Model();});
  43. $container->bind('view', function () {return new View();});
  45. /**************************************************/
  46. // 添加Facade门面类
  47. class Facade
  48. {
  49.     protected static $container = null;
  50.     protected static $data = [];
  52.     // 用服务容器给它初始化
  53.     public static function initialize(Container1 $container)
  54.     {
  55.         static::$container = $container;
  56.     }
  58.     // 用静态代理方式将模型中的getData()静态化
  59.     public static function getData()
  60.     {
  61.         static::$data = static::$container->make('model')->getData();
  62.     }
  64.     // 用静态代理方式将视图中的fetch()静态化
  65.     public static function fetch()
  66.     {
  67.         return static::$container->make('view')->fetch(static::$data);
  68.     }
  69. }
  71. // 声明一学生类
  72. class Son extends Facade
  73. {
  74.     //
  75. }
  77. /**************************************************/
  78. // 3. 创建控制器
  79. class Controller5
  80. {
  81.     public function __construct(Container1 $container)
  82.     {
  83.         // 调用Faceda里面的初始化方法
  84.         Son::initialize($container);
  85.     }
  87.     public function index()
  88.    {
  89.        // 3.1 获取数据
  90.         Son::getData();
  92.        // 3.2 渲染模板
  93.        return Son::fetch();
  94.    }
  95. }
  97. // 4. 客户端调用/访问类成员
  99. // 将模型对象与视图对象,以参数的方式再次注入到控制器的方法
  100. $controller = new Controller5($container);
  101. echo $controller->index();

2. 将最后一个demo5.php中的代码, 手写提交


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

相关文章

查看更多