微信公众号 讲师中心
首页
文章
后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 自媒体 新闻
专题
后端开发 web前端 数据库 开发工具 php框架 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 新闻
AI工具
AI 聊天问答 Agent智能体 AI 文本写作 AI 绘画作图 AI 设计工具 AI 视频创作 AI 音频制作 AI 办公学习 AI 编程开发 Prompt指令
学习
大前端 后端开发 数据库 移动端 运维开发 计算机基础
编程手册
大前端 后端开发 数据库 移动端 运维开发 计算机基础
下载
js特效 网站源码 工具下载 类库下载 网站素材 学习资源 插件扩展 手机/移动开发 手机游戏
搜索
后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程
自媒体 新闻
首页 > 博客列表 > PHP 24 MVC与设计模式（依赖注入-服务容器-Facade）（0804tue）
博主信息
博文 62
粉丝 2
评论 1
访问量 58175
专题推荐
更多>
相关推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
PHP 24 MVC与设计模式（依赖注入-服务容器-Facade）（0804tue）
老黑
原创
710人浏览过

主要内容：

  1. MVC的主要思想
    （model模型、view视图、controller控制 - 程序员主要是在折腾控制）

  2. 三种主要设计模式：
    a-“依赖注入”，通过class去构建Model、view，然后通过controller去控制
    b- 服务容器：将对外部的依赖放到容器中，让依赖更加简单、抽象。
    c- Facade门面技术：在服务容器和控制器之间生成一个静态过渡类，让后续的控制器访问进一步抽象。

    《盗梦空间》—— 不得不服老外在编程技术上的积累和精进。国内还有太多路要走。
    后面的层层嵌套、深入，类似《盗梦空间》，开始觉得还精巧，到后面把握不住火候的话，就感觉玩大了，兜不住了 —— 这个时候就需要不断地提升认知。
    每一层class的延伸，包括facade门面技术，都类似从一层梦境进入另外一层梦境。越来越抽象，越来越牵一发而动全身。

. 1. MVC的主要思想

  • M: Model, 模型, 数据库的操作
  • V: View, 视图, 页面, html
  • C: Controller, 控制器
  1. <?php
  2. // -----模型部分: 当前页面要显示的数据
  3. $pdo = new PDO('mysql:host=localhost;dbname=phpedu', 'root', 'root');
  4. $users = $pdo->query('select * from users limit 10')->fetchAll(PDO::FETCH_ASSOC);
  5. ?>
  7. <!-- 视图部分 -->
  8. <!DOCTYPE html>
  9. <html lang="en">
  10. <head>
  11.     <meta charset="UTF-8">
  12.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  13.     <title>用户列表</title>
  14. </head>
  15. <body>
  16.     <table border="1" width="60%">
  17.         <caption>用户表</caption>
  18.         <tr>
  19.             <th>id</th>
  20.             <th>name</th>
  21.             <th>email</th>
  22.         </tr>
  23.         <?php foreach ($users as $user): ?>
  24.         <tr>
  25.             <td><?=$user['id']?></td>
  26.             <td><?=$user['name']?></td>
  27.             <td><?=$user['email']?></td>
  28.         </tr>
  29.         <?php endforeach ?>
  30.     </table>
  31. </body>
  32. </html>

  • 不同的项目切入点不同。

    • 仿站: V - M - C（模仿别人的网站，自然是从view开始）
    • 自主: M - V - C（但自主研发，则是从数据开始）

  • 几种设计模式
    ① 依赖注入
    ② 服务容器
    ③ Facade

2. “依赖注入”，通过class去构建Model、view，然后通过controller去控制

  • 第一步，先建立model和view文件，里面包含了model和view的class
    • Model.php
  1. <?php
  2. namespace mvc_demo;
  3. use PDO;
  5. // 模型类: 数据库操作
  6. class Model
  7. {
  8.     // 获取数据
  9.     public function getData()
  10.     {
  11.         return   (new PDO('mysql:host=localhost;dbname=phpedu', 'root', 'root'))
  12.                 ->query('select * from users limit 10')->fetchAll(PDO::FETCH_ASSOC);
  13.                 // 通过链式方式得到数据
  14.     }
  15. }
  17. // 测试模型
  18. // print_r((new Model)->getData());
  • View.php文件
  1. <?php
  2. namespace mvc_demo;
  4. // 视图: 数据展示
  5. class View
  6. {
  7.     // 数据展示
  8.     public function fetch($data)
  9.     {
  10.         // 表格方式展示,使用字符串拼接实现table的html代码
  11.         // $table .= 相当于 $table = $table. + ...用来拼接语句）
  12.         $table = '<table>';
  13.         $table .= '<caption>用户信息表</caption>';
  14.         $table .= '<tr><th>ID</th><th>用户名</th><th>邮箱</th></tr>';
  15.         // 遍历用户表
  16.         foreach ($data as $user){
  17.             $table .= '<tr>';
  18.             $table .= '<td>'.$user['id'].'</td>';
  19.             $table .= '<td>'.$user['name'].'</td>';
  20.             $table .= '<td>'.$user['email'].'</td>';
  21.             $table .= '</tr>';
  22.         }
  23.         $table .= '</table>';
  24.         //这块的table跟之前有一些区别，去掉了php等标识，可以了解下。
  26.         return $table;
  27.     }
  28. }
  30. echo '<style>
  31.     table {border-collapse: collapse; border: 1px solid;text-align: center; width: 500px;height: 150px;width: 600px;}
  32.     caption {font-size: 1.2rem; margin-bottom: 10px;}
  33.     tr:first-of-type { background-color:yellow;}
  34.     td,th {border: 1px solid; padding:5px}
  35. </style>';
  37. // 视图测试
  38. // require 'Model.php';
  39. // echo (new View)->fetch((new Model)->getData());

3. 第二步，通过控制器来加载MV

3-1. 第一种，直接类内进行model、view的实例化

    1. Model, View 类的实例都是在Controller内完成的。会带来“代码耦合度过高”的问题
    1. 控制器知道的太多了, 造成了当前的控制器严重依赖外部的某些对象
    1. 这种现象就是大家常常听说过的: 代码的耦合度过高
  • 需要使用外部对象的 “依赖注入”解决”代码的耦合度过高的问题”
  1. <?php
  2. // 控制器1
  3. namespace mvc_demo;
  5. // 加载模型类
  6. require 'Model.php';
  8. // 加载视图类
  9. require 'View.php';
  11. class Controller1
  12. {
  13.     // 获取数据,并展示出来
  14.     public function index()
  15.     {
  16.         // 1. 获取数据
  17.         $model = new Model();
  18.         $data = $model->getData();
  20.         // 2. 渲染模板
  21.         $view = new View();
  22.         return $view->fetch($data);
  23.     }
  24. }
  26. // 客户端调用(测试)
  27. // 创建控制器实例/对象
  28. $controller = new Controller1();
  29. echo $controller->index();
  30. //

3-2. 第二种：外部实例化Model、View，然后以参数形式注入到Controller中

  • 将类/对象依赖的外部的对象,以控制器方法的参数形式注入到当前的控制器中
  • 此时, 控制器依赖的外部对象的实例化过程,就可以在控制器类的外部完成,一般在客户端完成
  • 但controller这个类中不同的方法要去调用m、v的时候需要反复以方法传参的方式来进行。这边不够好。
  1. <?php
  2. // 控制器2: 使用依赖注入解决类/对象之间的耦合度过高的问题
  3. namespace mvc_demo;
  5. // 加载模型类
  6. require 'Model.php';
  8. // 加载视图类
  9. require 'View.php';
  11. class Controller2
  12. {
  13.     // 获取数据,并展示出来
  14.     public function index($model, $view)
  15.     {
  16.         // 1. 获取数据
  17.         $data = $model->getData();
  19.         // 2. 渲染模板（也就是数据展示）
  20.         return $view->fetch($data);
  21.     }
  22.     /* 问题又来了: 控制器依赖的外部对象,尽管已经通过依赖注入进行了当前类中,
  23.     但是没有办法实现外部对象的复用。例如下面调用的时候又需要重新new？*/ 
  24.     public function edit($model)
  25.     {
  27.     }
  28. }
  30. // 客户端调用(测试)
  31. // 创建控制器实例/对象
  32. $model = new Model();
  33. $view = new View();
  35. $controller = new Controller2();
  36. echo $controller->index($model, $view);
  37. $controller->edit($model);

3-3. 通过构造方法将外部对象初始化,实现了外部对象在当前类的共享/复用

  • 这种直接相当于将m、v通过类构造传参的方式让类内所有的方法都可以使用了，相对就方便了很多。
  • 可以看出，从controller1到controller3的过程是逐渐抽象化、提升使用方便度的过程。
  1. <?php
  2. // 控制器3: 实现外部依赖注入的对象在类内部的共享/复用
  3. namespace mvc_demo;
  5. // 加载模型类
  6. require 'Model.php';
  8. // 加载视图类
  9. require 'View.php';
  11. class Controller3
  12. {
  13.     // 外部依赖的对象
  14.     private $model = null;//后面的null也可以不写
  15.     private $view = null;
  17.     // 通过构造方法将外部对象初始化,实现了外部对象在当前类的共享/复用
  18.     public function __construct($model, $view)
  19.     {
  20.         $this->model = $model;
  21.         $this->view = $view;
  22.     }
  24.     // 获取数据,并展示出来
  25.     public function index()
  26.     {
  27.         // 1. 获取数据
  28.         $data = $this->model->getData();
  30.         // 2. 渲染模板
  31.         return $this->view->fetch($data);
  32.     }
  33.     // 外部对象的复用
  34.     public function edit()
  35.     {
  36.         // $this->model;
  37.     }
  38. }
  40. // 客户端调用(测试)
  41. // 创建控制器实例/对象
  42. $model = new Model();
  43. $view = new View();
  45. // 将外部对象的注入点从普通方法,改到了构造方法中
  46. $controller = new Controller3($model, $view);
  47. echo $controller->index();//之前的参数是方法级别的，现在则提升到了类级别。
  48. $controller->edit();
  49. // o：这种情况下class内的每个方法就要相对简单，因为无法在括号中传参。
  50. // 当然也有可能方法本身就应该相对简单，一个方法一个非常独立的返回。当然这默认所有的类中的参数方法都是可以使用的了。

3-4. 通过服务容器来接管对外部对象的依赖

  • 上面的3是依赖外部对象，但如果外部对象很多，例如m、v等，这种情况下可以用容器，对象容器或服务容器，来进行接管。
  1. <?php
  2. // 控制器4: 将当前依赖的外部对象,放到一个"服务容器"中进行统一管理
  3. namespace mvc_demo;
  4. use Closure; // 后面使用闭包类型的时候前面就不用加/了。
  6. // 加载模型类
  7. require 'Model.php';
  9. // 加载视图类
  10. require 'View.php';
  12. // -----------------------------------------
  13. // 服务容器
  14. class Container1
  15. {
  16.     // 1. 对象容器
  17.     protected $instances = [];
  19.     // 2. 向对象容器中添加对象
  20.     // 参数1: 是外部对象在当前对象容器数组中的键名/别名
  21.     // 参数2: 是当前需要绑定到容器的对象的实例化过程(函数)
  22.     public function bind($alias, Closure $process) 
  23.     //第二个参数是一个函数，使用闭包类型
  24.     {
  25.         $this->instances[$alias] = $process;
  26.     }
  28.     // 3. 从对象容器中取出对象, 调用它
  29.     public function make($alias, $params=[] ) {
  30.         return call_user_func_array($this->instances[$alias], []);
  31.     }
  32. }
  34. // 将外部对象: Model, View的实例绑定到服务容器中
  35. $container = new Container1;
  36. // 绑定模型类实例绑定到服务容器中
  37. $container->bind('model', function(){
  38.     return new Model();
  39. });
  40. // 绑定视图类实例绑定到服务容器中
  41. $container->bind('view', function(){
  42.     return new View();
  43. });
  45. // ------------------------------------------
  47. class Controller4
  48. {
  49.     // 获取数据,并展示出来
  50.     public function index(Container1 $container)
  51.     {
  52.         // 1. 获取数据
  53.         $data = $container->make('model')->getData();
  55.         // 2. 渲染模板
  56.         return $container->make('view')->fetch($data);
  57.     }
  58. }
  60. // 客户端调用(测试)
  61. $controller = new Controller4();
  62. echo $controller->index($container);
  64. // 为什么要用服务容器?
  65. // 将当前类对许多外部对象的依赖, 转为对一个服务容器的依赖
  66. // 将外部对象的依赖,使用服务容器进行了接管
  67. // 这样下来后面的地方就简化了很多。

3-5. Facade门面技术: 将对服务容器中的对象的访问进行静态接管

  1. <?php
  2. // 控制器5: Facade门面技术, 静态接管服务容器中的成员的访问
  3. namespace mvc_demo;
  4. use Closure;
  6. require 'Model.php';
  8. require 'View.php';
  10. // -----------------------------------------
  11. // 服务容器
  12. class Container2
  13. {
  14.     // 1. 对象容器
  15.     protected $instances = [];
  17.     public function bind($alias, Closure $process)
  18.     {
  19.         $this->instances[$alias] = $process;
  20.     }
  22.     // 3. 从对象容器中取出对象, 调用它
  23.     public function make($alias, $params=[] ) {
  24.         return call_user_func_array($this->instances[$alias], []);
  25.     }
  26. }
  28. // 将外部对象: Model, View的实例绑定到服务容器中
  29. $container = new Container2;
  30. // 绑定模型类实例绑定到服务容器中
  31. $container->bind('model', function(){
  32.     return new Model();
  33. });
  34. // 绑定视图类实例绑定到服务容器中
  35. $container->bind('view', function(){
  36.     return new View();
  37. });
  39. // ------------------------------------------
  41. // 在服务容器与工作的控制器之间再添加一个中间层: Facade
  42. class Facade
  43. {
  44.     // 服务容器
  45.     protected static $container = null;
  47.     // 初始化方法: 就是给当前的Facade类中的$container属性赋值
  48.     // 理解为Facade的构造方法(但不是)
  49.     // 将外部的服务容器注入到当前的facade中
  50.     public static function initialize(Container2 $container) 
  51.     {
  52.         static::$container = $container;
  53.         // 给本类中的静态属性赋值，其实就是将前面的容器初始化。
  54.     }
  55. }
  57. // 模型类成员访问静态化(给成员套一个静态访问的马甲)
  58. class UserModel extends Facade
  59. {
  60.     public static function getData()
  61.     {
  62.         return static::$container->make('model')->getData();
  63.     }
  64. }
  67. // 视图类成员访问静态化(给成员套一个静态访问的马甲)
  68. class UserView extends Facade
  69. {
  70.     public static function fetch($data)
  71.     {
  72.         return static::$container->make('view')->fetch($data);
  73.     }
  74. }
  76. // ------------------------------------------
  78. class Controller5
  79. {
  80.     // 构造方法,初始化facade
  81.     public function __construct(Container2 $container)
  82.     {
  83.         Facade::initialize($container);
  84.     }
  86.     // 用Facade方式类成员
  87.     public function index()
  88.     {
  89.         // 1. 获取数据
  90.         $data = UserModel::getData();
  92.         // 2. 渲染模板
  93.         return UserView::fetch($data);
  94.     }
  95. }
  97. // 客户端调用(测试)
  98. $controller = new Controller5($container);
  99. echo $controller->index();

4. 作业实战

  • 按照老师的方法自己走了一边，并且用Facade的方法实现了。
  • 但对中间各种class（model、view、container、Facade、controller（o - 能否归纳为 MV-CF-C模式，中间的C-F分别为container和Facade））之间的嵌套关系还是比较懵。估计要后面不断看代码才行。
  • 自己的z1model.php，其中gettdata多加t是为了试验是否可以乱改名字等。
  1. <?php
  2. namespace mvc;
  3. use PDO;
  5. class dataModel{
  6.     public function gettData(){
  7.         return (new PDO('mysql:host=localhost;dbname=liangtest','liang','123456'))
  8.             ->query('SELECT * FROM `shao` LIMIT 8')->fetchAll(PDO::FETCH_ASSOC);
  9.     }
  10. }
  12. print_r((new dataModel)->gettData());
  14. /*
  15. 8月4日作业
  16. 1. 将课堂视频至少看二遍以上,细细品服务容器与facade带来的好处,并写出自己的总结
  17. 2. 试着用mvc实现一个简单的业务逻辑(可仿课堂案例,但不要全照抄)
  18. 3. 可选: 如何优化Facade的调用过程
  19. */
  • z2view.php部分
  1. <?php
  2. namespace mvc;
  4. class shaoView{
  5.     public function fetch($items){
  6.         $table = '<table>';
  7.         $table .= '<caption>内容列表</caption>';
  8.         $table .= '<tr>
  9.                         <th>id</th>
  10.                         <th>date</th>
  11.                         <th>title</th>
  12.                         <th>tags</th>
  13.                         </tr>';
  14.         foreach ($items as $item){
  15.             $table .= '<tr>';
  16.             $table .= '<td>'.$item['id'].'</td>';
  17.             $table .= '<td>'.$item['date'].'</td>';
  18.             $table .= '<td>'.$item['title'].'</td>';
  19.             $table .= '<td>'.$item['label'].'</td>';
  20.             $table .= '</tr>';
  21.         }
  23.         $table .= '/<table>';
  24.         return $table;
  25.     }
  26. }
  28. echo '<style>
  29.     table {border-collapse: collapse; border: 1px solid;text-align: center; width: 500px;height: 150px;width: 600px;}
  30.     caption {font-size: 1.2rem; margin-bottom: 10px;}
  31.     tr:first-of-type { background-color:yellow;}
  32.     td,th {border: 1px solid; padding:5px}
  33.     </style>';
  35. require 'z1model.php';
  36. echo (new shaoView)->fetch((new dataModel)->gettData());
  • z3controller部分
  1. <?php
  3. namespace mvc;
  4. use Closure;
  5. require 'z2view.php';
  7. class objContainer{
  8.     protected $insts = [];
  9.     public function bind($name, Closure $process){
  10.         $this->insts[$name] = $process;
  11.     }
  13.     public function make($name,$params=[]){
  14.         return call_user_func_array($this->insts[$name],[]);
  15.     }
  16. }
  18. $container = new objContainer;
  19. $container->bind('dataModel',function(){
  20.     return new dataModel();
  21. });
  23. $container->bind('shaoView',function(){
  24.     return new shaoView();
  25. });
  28. class Facade{
  29.     protected static $container =null;
  30.     public static function initialize(objContainer $container){
  31.         static::$container = $container;
  32.     }
  33. }
  35. class dataamodel extends Facade{
  36.     public static function gettData(){
  37.         return static::$container->make('dataModel')->gettData();
  38.     }
  39. }
  41. class shaooView extends Facade{
  42.     public static function fetch($data){
  43.         return static::$container->make('shaoView')->fetch($data);
  44.     }
  45. }
  48. class Controller{
  49.     public function __construct(objContainer $container){
  50.         Facade::initialize($container);
  51.     }
  53.     public function index(){
  54.         $data = dataamodel::gettData();
  55.         return shaooView::fetch($data);
  56.     }
  57. } 
  59. $controller = new Controller($container);
  60. echo $controller->index();

最终比较幸运，数据都能读取出来。

批改老师：天蓬老师天蓬老师

批改状态：合格

老师批语：正解的非常透彻, 不少工作几年的程序员, 都不一定有你的高度, 不错
本博文版权归博主所有，转载请注明地址！如有侵权、违法，请联系admin@php.cn举报处理！
全部评论 文明上网理性发言，请遵守新闻评论服务协议
0条评论
作者最新博文
关于我们 免责申明 举报中心 意见反馈 讲师合作 广告合作 最新更新 English
php中文网：公益在线php培训，帮助PHP学习者快速成长！
关注服务号 技术交流群
PHP中文网订阅号
每天精选资源文章推送
PHP中文网APP
随时随地碎片化学习

Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号

  • PHP学习

  • 技术支持

  • 返回顶部
    • 登录PHP中文网，和优秀的人一起学习！
    全站2000+教程免费学
    微信扫码登录