欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

单例模式，工厂模式，MVC初学

程序员文章站 2022-03-11 13:41:10
...

单例模式

单例模式就是实现一个类只能实例化一次，不允许实例化多次

    

  1. <?php
    2. 

  2. class Demo
    3. 

  3. {
    4. 

  4.     private static $instance = null; // 用这个属性保存实例化后的对象
    5. 

    6. 

  6.     // 禁止外部用 new 实例化类，只需要将构造方法私有化即可
    7. 

  7.     private function __construct(...$args)
    8. 

  8.     {
    9. 

  9.         print_r($args); // 将参数打印出来看看
    10. 

  10.     }
    11. 

    12. 

  12.     // 禁止外部克隆出对象，将clone方法私有化
    13. 

  13.     private function __clone()
    14. 

  14.     {
    15. 

  15.     }
    16. 

  16.     // 用这个方法来实例化
    17. 

  17.     public static function getInstance(...$args)
    18. 

  18.     {
    19. 

  19.         if (is_null(self::$instance)) {
    20. 

  20.             return self::$instance = new self(...$args);
    21. 

  21.         }
    22. 

  22.         return self::$instance;
    23. 

  23.     }
    24. 

  24. }
    25. 

    26. 

  26. // 这里执行多次实例化，会发现每次执行返回的都是同一个对象,
    27. 

  27. // 而参数也只会被打印一次，因为第一次实例化后，后面的实例化其实都不会执行
    28. 

  28. var_dump(Demo::getInstance(1,2));
    29. 

  29. var_dump(Demo::getInstance(3,4));
    30. 

  30. var_dump(Demo::getInstance(5,6));
    31.

工厂模式

就是用一个类将实例化过程给独立出来
即在一个类中实现 实例化一个类并返回实例对象 的方法 

    

  1. namespace day1011;
    2. 

    3. 

  3. class Test1 {
    4. 

  4.     public function __construct(...$args)
    5. 

  5.     {
    6. 

  6.         echo '这是'.__CLASS__.'实例化的对象,参数为'***plode(', ',$args).'<br/>';
    7. 

  7.     }
    8. 

  8. }
    9. 

    10. 

  10. class Test2 {
    11. 

  11.     public function __construct(...$args)
    12. 

  12.     {
    13. 

  13.         echo '这是'.__CLASS__.'实例化的对象,参数为'***plode(', ',$args).'<br/>';
    14. 

  14.     }
    15. 

  15. }
    16. 

    17. 

  17. class Test3 {
    18. 

  18.     public function __construct(...$args)
    19. 

  19.     {
    20. 

  20.         echo '这是'.__CLASS__.'实例化的对象,参数为'***plode(', ',$args).'<br/>';
    21. 

  21.     }
    22. 

  22. }
    23. 

    24. 

  24. class Test4 {
    25. 

  25.     public function __construct(...$args)
    26. 

  26.     {
    27. 

  27.         echo '这是'.__CLASS__.'实例化的对象,参数为'***plode(', ',$args).'<br/>';
    28. 

  28.     }
    29. 

  29. }
    30. 

    31. 

  31. // 将工厂设计成接口类
    32. 

  32. interface iFactory {
    33. 

  33.     public static function make($className, ...$args);
    34. 

  34. }
    35. 

    36. 

  36. // 将工厂设计成抽象类
    37. 

  37. abstract class aFactory
    38. 

  38. {
    39. 

  39.     abstract static function make($className, ...$args);
    40. 

  40. }
    41. 

    42. 

  42. // class Factory extends aFactory {
    43. 

  43. //     public static function make($className, ...$args) {
    44. 

  44. //         return new $className(...$args);
    45. 

  45. //     }
    46. 

  46. // }
    47. 

    48. 

  48. class Factory implements iFactory {
    49. 

  49.     public static function make($className, ...$args) {
    50. 

  50.         return new $className(...$args);
    51. 

  51.     }
    52. 

  52. }
    53. 

  53. Factory::make(Test1::class,1,2);
    54. 

  54. Factory::make(Test2::class,3,4);
    55. 

  55. Factory::make(Test3::class,5,6);
    56.

MVC—依赖注入

MVC模式是很常见的一种设计思想：即将数据，视图与控制器分开
M: Model, 模型, 数据, 主要针对的是数据库的操作, CURD
V: View, 视图, html文档,浏览器用户看到内容/页面
C: Controller, 控制器, 模型和视图都必须在控制器中调用

这里来建立一个简单 MVC 案例

Model.php

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * 数据库模型类
    4. 

  4.  */
    5. 

    6. 

  6. class Model
    7. 

  7. {
    8. 

  8.     protected $pdo = null;
    9. 

  9.     protected $where;
    10. 

    11. 

  11.     public function __construct()
    12. 

  12.     {
    13. 

  13.         $this->pdo = new \PDO('mysql:host=127.0.0.1;dbname=zmx','root','root');
    14. 

  14.     }
    15. 

    16. 

  16.     // 获取数据
    17. 

  17.     public function getData($where){
    18. 

  18.         $this->where = empty($where) ? '' : ' WHERE '.$where;
    19. 

  19.         $sql = 'SELECT * FROM `staff`'.$this->where;
    20. 

  20.         $stmt = $this->pdo->prepare($sql);
    21. 

  21.         if($stmt->execute()){
    22. 

  22.             return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    23. 

  23.         }else {
    24. 

  24.             print_r('呵呵');
    25. 

  25.             die($stmt->errorInfo());
    26. 

  26.         }
    27. 

  27.     }
    28. 

  28. }
    29.

View.php

    

  1. <!DOCTYPE html>
    2. 

  2. <html lang="en">
    3. 

  3. <head>
    4. 

  4.     <meta charset="UTF-8">
    5. 

  5.     <link rel="stylesheet" href="table.css">
    6. 

  6. </head>
    7. 

  7. <body>
    8. 

  8. <div>
    9. 

  9. <?php
    10. 

  10. /**
    11. 

  11.  * 视图
    12. 

  12.  */
    13. 

  13. class View {
    14. 

  14.     // 定义一个渲染表格方法
    15. 

  15.     public function render($data){
    16. 

  16.         $table = '<table border="1" cellpadding="0" cellspacing="0" width="400">';
    17. 

  17.         $table .= '<caption>人员表</caption>';
    18. 

  18.         $table .= '<tr><th>ID</th><th>姓名</th><th>年龄</th><th>性别</th><th>职位</th></tr>';
    19. 

    20. 

  20.         foreach ($data as $person) {
    21. 

  21.             $table .= '<tr>';
    22. 

  22.             $table .= '<td>' . $person['staff_id'] . '</td>';
    23. 

  23.             $table .= '<td>' . $person['name'] . '</td>';
    24. 

  24.             $table .= '<td>' . $person['age'] . '</td>';
    25. 

  25.             $table .= '<td>' . ($person['sex'] == 1 ? '男' : '女') . '</td>';
    26. 

  26.             $table .= '<td>' . $person['position'] . '</td>';
    27. 

  27.             $table .= '</tr>';
    28. 

  28.         }
    29. 

  29.         $table .= '</table>';
    30. 

  30.         return $table;
    31. 

  31.     }
    32. 

  32. }
    33.

Controller.php

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * 控制类
    4. 

  4.  * 依赖注入
    5. 

  5.  */
    6. 

    7. 

  7. require 'Model.php';
    8. 

  8. require 'View.php';
    9. 

    10. 

  10. class Controller {
    11. 

    12. 

  12.     public function renderIndex($model, $view){
    13. 

  13.         $data = $model->getData('age >40');
    14. 

  14.         return $view->render($data);
    15. 

  15.     }
    16. 

  16. }
    17. 

  17. $model = new Model();
    18. 

  18. $view = new View();
    19. 

  19. $controller = new Controller();
    20. 

  20. // 依赖注入
    21. 

  21. // 将模型对象和视图对象作为参数传入
    22. 

  22. echo $controller->renderIndex($model, $view);
    23.

这样就简单实现了一个mvc模型
单例模式，工厂模式，MVC初学

改进一下：加入服务容器和门面模式

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * 控制器
    4. 

  4.  * 服务容器(简称为容器),将对象的创建与使用过程统一管理起来
    5. 

  5.  * 门面模式,又叫外观模式，静态代理，就是将所有调用的代码静态化，就是给调用方法再包一层
    6. 

  6.  */
    7. 

    8. 

  8. require 'Model.php';
    9. 

  9. require 'View.php';
    10. 

    11. 

  11. // 门面模式
    12. 

  12. // 给方法再再套个马甲
    13. 

  13. class  Facade
    14. 

  14. {
    15. 

  15.     protected static $container = null;
    16. 

    17. 

  17.     protected static $data = [];
    18. 

    19. 

  19.     public static function initialize($container)
    20. 

  20.     {
    21. 

  21.         static::$container = $container;
    22. 

  22.     }
    23. 

    24. 

  24.     public static function getData($where)
    25. 

  25.     {
    26. 

  26.         static::$data = static::$container->generate('Model')->getData($where);
    27. 

  27.     }
    28. 

    29. 

  29.     public static function render(){
    30. 

  30.         return static::$container->generate('View')->render(static::$data);
    31. 

  31.     }
    32. 

  32. }
    33. 

    34. 

  34. // 建议一个服务容器类
    35. 

  35. class Container
    36. 

  36. {
    37. 

  37.     // 声明一个数组，存放 类名 => 方法
    38. 

  38.     protected $instance = [];
    39. 

    40. 

  40.     // 向数组中存储数据
    41. 

  41.     public function bind($className, Closure $process)
    42. 

  42.     {
    43. 

  43.         $this->instance[$className] = $process;
    44. 

  44.     }
    45. 

    46. 

  46.     // 执行数组中对应方法
    47. 

  47.     public function generate($className, ...$args)
    48. 

  48.     {
    49. 

  49.         // 采用回调函数执行对应犯法数组中对应的函数
    50. 

  50.         return call_user_func_array($this->instance[$className], $args);
    51. 

  51.     }
    52. 

  52. }
    53. 

    54. 

  54. $container = new Container();
    55. 

  55. $container->bind('Model', function () {
    56. 

  56.     return new Model;
    57. 

  57. });
    58. 

    59. 

  59. $container->bind('View', function () {
    60. 

  60.     return new View;
    61. 

  61. });
    62. 

    63. 

  63. class  Controller
    64. 

  64. {
    65. 

  65.    public function __construct($container)
    66. 

  66.    {
    67. 

  67.        Facade::initialize($container);
    68. 

  68.    }
    69. 

    70. 

  70.     public function renderIndex()
    71. 

  71.     {
    72. 

  72.         Facade::getData('age>20');
    73. 

  73.         return Facade::render();
    74. 

  74.     }
    75. 

  75. }
    76. 

    77. 

  77. $controller = new Controller($container);
    78. 

  78. echo $controller->renderIndex();
    79.

路由

** 路由其实就是解析页面路径，通过解析后的数据来执行不同操作。

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * 路由
    4. 

  4.  */
    5. 

  5. 解析已下路由：规定此路径：大概规则是  .../模块名/控制器名/方法?参数
    6. 

  6. //http://zx.com/day1011/route.php/admin/user/get?id=3&&age=20
    7. 

  7. $url = $_SERVER['REQUEST_URI']; // 获取路由
    8. 

  8. echo $url;
    9. 

  9. $req = explode('/', $url);
    10. 

  10. echo '<pre>'.print_r($req,true);
    11. 

    12. 

  12. // 模块/控制器/方法
    13. 

  13. // 将 url中的方法解析出来，映射到对应的函数上
    14. 

  14. // 取模块
    15. 

  15. $module = array_slice($req, -3,1)[0];
    16. 

  16. // 取控制器
    17. 

  17. $controller = array_slice($req, -2,1)[0];
    18. 

  18. // 取方法
    19. 

  19. $last = array_slice($req, -1,1);
    20. 

  20. $method = explode('?', $last[0])[0];
    21. 

  21. $values = explode('?', $last[0])[1];
    22. 

  22. // 取参数
    23. 

  23. $params = explode('&', $values);
    24. 

  24. $paramsArr = [];
    25. 

  25. foreach($params as $val){
    26. 

  26.    $name = explode('=', $val)[0];
    27. 

  27.    $value = explode('=', $val)[1];
    28. 

  28.    $paramsArr[$name] = $value;
    29. 

  29. }
    30. 

  30. print_r($paramsArr);
    31. 

    32. 

  32. echo '模块：'.$module.'<br/>';
    33. 

  33. echo '控制器：'.$controller.'<br/>';
    34. 

  34. echo '方法：'.$method.'<br/>';
    35. 

  35. echo '参数：<pre>'.print_r($paramsArr,true);
    36. 

    37. 

  37. // 控制器
    38. 

  38. // 路由的目标, 就是将URL中的操作映射到控制器中的方法上
    39. 

  39. class User
    40. 

  40. {
    41. 

  41.     public function get($id, $age)
    42. 

  42.     {
    43. 

  43.        return 'ID为'.$id.'的用户年龄为'.$age;
    44. 

  44.     }
    45. 

  45. }
    46. 

  46. // 将路由解析到的数据进行传入到对应的方法
    47. 

  47. echo call_user_func_array([(new User()), $method], $params);
    48.

最终输出： ID为id=3的用户年龄为age=20

上一篇： cookie与session实现登录验证—2018年8月31日22时00分

下一篇： 异常处理+文件上传+模型类映射

推荐阅读