search

博客列表 >1204_静态成员及MVC 第28课

1204_静态成员及MVC 第28课

叮叮当当
叮叮当当原创
2019年12月06日 00:26:33729浏览

1. 将课堂源代码, 全部写一遍

静态方法与属性：demo1.php

  1. # static 声明类中的静态成员
  3. namespace _1204;
  4. # 用use可以起别名，如use PDO as P;
  5. use PDO;
  7. # 创建类
  8. class Db1{
  10.     # 添加类成员
  11.     # 添加静态成员：属性，方法
  13.     # 静态属性
  14.     protected static $pdo;
  15.     protected static $dsn = 'mysql:host=127.0.0.1;dbname=SqlTest;charset=utf8';
  16.     protected static $name = 'root';
  17.     protected static $pwd = 'root';
  19.     # 静态方法
  20.     public static function connect(){
  21.         # 在类中访问当前类的静态成员
  22.         self::$pdo = new PDO( self::$dsn, self::$name, self::$pwd );
  23.     }
  25.     # 测试方法
  26.     public static function select(){
  27.         # 连接数据库
  28.         self::connect();
  29.         return self::$pdo->query('SELECT * FROM `zsgc`',PDO::FETCH_ASSOC);
  30.     }
  31. }
  33. # 访问类成员
  34. # 在类的外部访问类中的静态成员，直接用类名
  35. $result = Db1::select();
  36. foreach( $result as $row ){
  37.     echo '<pre>' .print_r($row,true). '</pre>';
  38. }

后期静态绑定：demo2.php

  1. # static 后期静态绑定
  2. # 使用场景：静态继承的上下文环境
  3. # 类成员绑定时间：在声明时绑定，在调用时绑定，
  4. # 后期绑定即被调用时再动态的绑定
  6. class Db2{
  8.     # 添加类成员
  9.     # 添加静态成员：属性，方法
  10.     protected static $pdo;
  11.     protected static $dsn = 'mysql:host=127.0.0.1;dbname=SqlTest;charset=utf8';
  12.     protected static $name = 'root';
  13.     protected static $pwd = '123456';
  15.     # 静态方法
  16.     public static function connect(){
  17.         # 在类中访问当前类的静态成员
  18.         //self::$pdo = new PDO( self::$dsn, self::$name, self::$pwd );
  19.         static::$pdo = new PDO( static::$dsn, static::$name, static::$pwd );
  21.     }
  23.     # 测试方法
  24.     public static function select(){
  25.         # 连接数据库
  26.         static::connect(); # 不能用self::connect(),否则永远绑定的是Db2，当子类调用时，调用的永远是父类connect
  27.         return self::$pdo->query('SELECT * FROM `zsgc`',PDO::FETCH_ASSOC);
  28.     }
  29. }
  31. class Sub extends Db2{
  33.     protected static $name = 'root';
  34.     protected static $pwd = 'root';
  36.     # 静态方法
  37.     public static function connect(){
  38.         # 在类中访问当前类的静态成员
  39.         self::$pdo = new PDO( self::$dsn, self::$name, self::$pwd );
  40.     }
  41. }
  43. # 访问类成员
  44. # 在类的外部访问类中的静态成员，直接用类名
  45. # 谁调用connect,就用谁类里的connect,子类Sub调用就用子类的，父类Db2调用就用父类的
  46. //$result = Db2::select();
  47. $result = Sub::select();
  48. foreach( $result as $row ){
  49.     echo '<pre>'.print_r($row,true).'</pre>';
  50. }

MVC之模版：Model.php

  1. namespace mvc;
  3. # 模型类：用于数据表的操作
  4. class Model{
  6.     public function getData(){
  8.         return [
  9.             ['id' => 1, 'name' => '单反相机', 'model' => '佳能', 'price' => 9799],
  10.             ['id' => 2, 'name' => '时尚腕表', 'model' => '丹尼尔惠灵顿', 'price' => 1290],
  11.             ['id' => 3, 'name' => '积木拼装', 'model' => '乐高科技系列', 'price' => 3799],
  13.         ];
  14.     }
  15. }

MVC之视图：View.php

  1. namespace mvc;
  3. # 视图类:渲染数据
  4. class View{
  6.     public function fetch( $data ){
  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>';

MVC之控制器1：demo1.php

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

MVC之控制器2 (依赖注入)：demo2.php

  1. # 控制器：将商品信息表显示出来
  2. # 将类中对其它类的实例化（模型/视图）分离出来，降低耦合
  3. # 依赖注入
  5. namespace mvc;
  7. # 1 加载模型
  8. require 'Model.php';
  10. # 2 加载视图
  11. require 'View.php';
  13. # 3 创建控制器
  14. class Controller2{
  16.     public function index( Model $model, View $view ){
  18.         # 获取数据
  19.         $data = $model->getData();
  21.         # 渲染模版
  22.         return $view->fetch( $data );
  23.     }
  24. }
  26. $model = new Model();
  27. $view = new View();
  29. # 4 客户端调用/访问类成员, 将对象以参数方式注入到控制器的方法
  30. $controller = new Controller2();
  31. echo $controller->index( $model, $view);

MVC之控制器3 (依赖注入，更改注入点到构造方法中)：demo3.php

  1. # 控制器：将商品信息表显示出来
  2. # 将类中对其它类的实例化（模型/视图）分离出来，降低耦合
  3. # 依赖注入，将注入点改到构造方法中
  5. namespace mvc;
  7. # 1 加载模型
  8. require 'Model.php';
  10. # 2 加载视图
  11. require 'View.php';
  13. # 3 创建控制器
  14. class Controller3{
  16.     protected $model;
  17.     protected $view;
  19.     # 将注入点改到构造方法中，实现模型与视图对象的共享
  20.     public function __construct( Model $model, View $view  ){
  21.         $this->model = $model;
  22.         $this->view = $view;
  23.     }
  25.     public function index(){
  27.         # 获取数据
  28.         $data = $this->model->getData();
  30.         # 渲染模版
  31.         return $this->view->fetch( $data );
  32.     }
  33. }
  35. $model = new Model();
  36. $view = new View();
  38. # 4 客户端调用/访问类成员, 将对象以参数方式注入到控制器的方法
  39. $controller = new Controller3( $model, $view );
  40. echo $controller->index();

MVC之控制器4 (依赖注入，加入服务容器层)：demo4.php

  1. # 控制器：将商品信息表显示出来
  2. # 将类中对其它类的实例化（模型/视图）分离出来，降低耦合
  3. # 依赖注入，加入服务容器层
  5. namespace mvc;
  7. # 1 加载模型
  8. require 'Model.php';
  10. # 2 加载视图
  11. require 'View.php';
  13. # 服务容器层
  14. class Container{
  16.     # 容器属性, 即数组, 全是创建对象的方法
  17.     protected $instance = [];
  19.     # 放进去: 将类的实例化过程绑定到容器中（类实例的别名）
  20.     # $alia：类实例的别名，作为键     $process: 方法, 闭包类的实例，作为值
  21.     public function bind( $alias, \Closure $process){
  23.         # 将类实例化的方法绑定 / 存储到服务容器中
  24.         $this->instance[$alias] = $process;
  25.     }
  27.     # 取出来: 执行容器中的实例方法
  28.     public function make($alias, $params=[] ){
  30.         # 以回调方式执行函数/方法，参数以数组形式提供，不可省，没有参数放空数组
  31.         return call_user_func_array( $this->instance[$alias],[] );
  32.     }
  34. }
  36. # 实例化容器，将模型/视图对象 绑定 到容器中
  37. $container = new Container();
  38. $container->bind('model',function(){ return new Model(); });
  39. $container->bind('view',function(){ return new View(); });
  42. # 3 创建控制器
  43. class Controller4{
  45.     public function index( Container $container ){
  47.         # 获取数据
  48.         $data = $container->make('model')->getData();
  50.         # 渲染模版
  51.         return $container->make('view')->fetch( $data );
  52.     }
  53. }
  55. # 4 客户端调用/访问类成员, 将对象以参数方式注入到控制器的方法
  56. $controller = new Controller4();
  57. echo $controller->index( $container );

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

MVC之控制器5 (Facade技术)：demo5.php

  1. # 控制器：将商品信息表显示出来
  2. # facade技术：门面技术，规范/统一了对外部对象的调用方式, 全部改为静态调用, 不管之前方法什么类型
  3. # laravel, thinkphp
  5. namespace mvc;
  7. # 1 加载模型
  8. require 'Model.php';
  10. # 2 加载视图
  11. require 'View.php';
  13. # 服务容器层
  14. class Container1{
  16.     # 容器属性, 即数组, 全是创建对象的方法
  17.     protected $instance = [];
  19.     # 放进去: 将类的实例化过程绑定到容器中（类实例的别名）
  20.     # $alia：类实例的别名，作为键     $process: 方法, 闭包类的实例，作为值
  21.     public function bind( $alias, \Closure $process){
  23.         # 将类实例化的方法绑定 / 存储到服务容器中
  24.         $this->instance[$alias] = $process;
  25.     }
  27.     # 取出来: 执行容器中的实例方法
  28.     public function make($alias, $params=[] ){
  30.         # 以回调方式执行函数/方法，参数以数组形式提供，不可省，没有参数放空数组
  31.         return call_user_func_array( $this->instance[$alias],[] );
  32.     }
  34. }
  36. # 实例化容器，将模型/视图对象 绑定 到容器中
  37. $container = new Container1();
  38. $container->bind('model',function(){ return new Model(); });
  39. $container->bind('view',function(){ return new View(); });
  42. # 添加Facade门面类
  43. class Facade{
  45.     protected static $container = null;
  46.     protected static $data = [];
  48.     # 用服务容器给它初始化
  49.     public static function initialize( Container1  $container ){
  50.         static::$container = $container;
  51.     }
  53.     # 用静态代理方式将模型中的getData()静态化
  54.     public static function getData(){
  55.         static::$data = static::$container->make('model')->getData();
  56.     }
  58.     # 用静态代理方式将视图中的fetch()静态化
  59.     public static function fetch(){
  60.         return static::$container->make('view')->fetch( static::$data );
  61.     }
  62. }
  64. # 声明一个子类
  65. class Student extends Facade{
  66.     # 针对一些自定义需要的业务逻辑处理，如学生的增删改查，都可以将之静态化处理，供其他类调用
  67. }
  70. # 3 创建控制器
  71. class Controller5{
  73.     public function __construct( Container1 $container ){
  75.         #调用Faceda里面的初始化方法
  76.         Facade::initialize( $container );
  77.     }
  79.     public function index(){
  81.         # 获取数据
  82.         Student::getData();
  84.         # 渲染模版
  85.         return Student::fetch();
  86.     }
  87. }
  89. # 4 客户端调用/访问类成员, 将对象以参数方式注入到控制器的方法
  90. $controller = new Controller5($container);
  91. echo $controller->index();


总结：

  • 1 static，除了用于静态方法，属性，还可以用于后期静态绑定，调用时增加了灵活性
  • 2 MVC, 除了最基础的模型，视图，控制器，还有依赖注入，服务容器，Facade门面；
  • 3 依赖注入可降低耦合，注入点改到构造函数中，实现模型与视图对象的共享
  • 4 服务容器，将类的实例化过程绑定到容器中，通过注入该容器对象，由容器对象执行实例方法，而不是直接注入类对象，进一步降低了耦合
  • 5 Facade门面，将类对象里动态方法静态化，统一外部对象的调用方式为静态调用
上一条：MVC与框架基础-九期PHP线上班下一条：12-5mvc
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多