search

博客列表 >12月5号作业，例模式、工厂模式、依赖注入，MVC小案例

12月5号作业，例模式、工厂模式、依赖注入，MVC小案例

遗忘了寂寞
遗忘了寂寞原创
2019年12月07日 19:43:161143浏览

单例模式

  1. <?php
  2. namespace _120502;
  4. // 单例模式
  5. class Db
  6. {
  7.     // 构造方法私有化
  8.     private function __construct(...$connectParams)
  9.     {
  10.         $dsn = $connectParams[0];
  11.         $username = $connectParams[1];
  12.         $password = $connectParams[2];
  14.         self::$pdo = new \PDO($dsn, $username, $password);
  15.     }
  16.     // 目前 只能在类中的内部将类实例化
  17.     // 当前类的实例
  18.     public static $pdo = null;
  19.     // 实例化当前类的方法
  20.     public static function getInstance(...$connectParams)
  21.     {
  22.         // 实例化当前类,并返回类实例/对象
  23.         // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
  24.         if (is_null(self::$pdo)) {
  25.             // 构造函数不需要返回
  26.             new self(...$connectParams);
  27.         }
  28.         return self::$pdo;
  29.     }
  30.     // 禁用克隆魔术方法
  31.     private function __clone()
  32.     {
  33.         // ...
  34.     }
  35. }
  36. $connectParams = ['mysql:host=localhost;dbname=tj_ys', 'root', '123123'];
  37. $pdo = Db::getInstance(...$connectParams);
  38. $use=$pdo->query('SELECT * FROM `user`')->fetchAll();
  39. echo '<pre>'  . print_r($use, true) . '</pre>';

工厂模式

  1. <?php
  2. // 工厂模式: 用于批量创建类的实例/对象
  3. class Test1
  4. {
  5.     public function __construct($arg1)
  6.     {
  7.         echo '对象创建成功, 参数是: ' . $arg1;
  8.     }
  9. }
  10. class Test2
  11. {
  12.     public function __construct($arg1, $arg2)
  13.     {
  14.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2]);
  15.     }
  16. }
  17. class Test3
  18. {
  19.     public function __construct($arg1, $arg2, $arg3)
  20.     {
  21.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2, $arg3]);
  22.     }
  23. }
  24. // 工厂类, 专用于创建类实例
  25. class Factory
  26. {
  27.     public static function create($className, ...$argments)
  28.     {
  29.         return new $className(...$argments);
  30.     }
  31. }
  32. // 用工厂类来创建类实例/对象
  33. Factory::create(Test1::class, 100);
  34. echo '<br>';
  35. Factory::create(Test2::class, 100, 200);
  36. echo '<br>';
  37. Factory::create(Test3::class, 100, 200, 300);

依赖注入

  1. <?php
  2. // 依赖注入: 解决对象调用之间耦合
  3. // 工作类
  4. class Person
  5. {
  6.     // 要依赖的外部对象
  7.     private $car = null;
  8.     // 在构造方法中将依赖的外部对象全部实例化
  9.     // 注入点放到构造方法中
  10.     public function __construct(Car $car)
  11.     {
  12.         $this->car = $car;
  13.     }
  14.     // 外部对象执行一个动作
  15.     public function work()
  16.     {
  17.         return $this->car->drive();
  18.     }
  19. }
  20. // 依赖的外部类
  21. class Car
  22. {
  23.     public function drive()
  24.     {
  25.         return '开车去上班';
  26.     }
  27. }
  28. // 实例化类
  29. $car = new Car();
  30. $person = new Person($car);
  31. echo $person->work();

mvc案例

base\inc1\Car.php

  1. <?php
  2. namespace base\inc1;
  3. class Car
  4. {
  5.     public function drive()
  6.     {
  7.         return '开汽车';
  8.     }
  9. }

base\inc1\Plane.php

  1. <?php
  2. namespace base\inc1;
  3. class Plane
  4. {
  5.     public function drive()
  6.     {
  7.         return '乘飞机';
  8.     }
  9. }

base\inc1\Train.php

  1. <?php
  2. namespace base\inc1;
  3. class Train
  4. {
  5.     public function drive()
  6.     {
  7.         return '坐火车';
  8.     }
  9. }

base\autoload.php

  1. <?php
  3. spl_autoload_register(function ($className){
  4.     $path = str_replace('\\', '/', $className);
  5.     require dirname(__DIR__) . DIRECTORY_SEPARATOR . $path . '.php';
  6. });

base\Travel1.php

  1. <?php
  2. // 旅行类: 使用最传统的方式
  3. namespace base;
  4. // 设置引用的外部类名的别名
  5. use base\inc1\Car;
  6. use base\inc1\Train;
  7. use base\inc1\Plane;
  8. require __DIR__ . '/autoload.php';
  9. class Travel1
  10. {
  11.     // 交通工具
  12.     private $vehicle;
  13.     // 构造方法
  14.     public function __construct($vehicle)
  15.     {
  16.         switch (strtolower($vehicle)) {
  17.             case 'car':
  18.                 $this->vehicle = new Car();
  19.                 break;
  20.             case 'train':
  21.                 $this->vehicle = new Train();
  22.                 break;
  23.             case 'plane':
  24.                 $this->vehicle = new Plane();
  25.         }
  26.     }
  27.     // 调用外部一个依赖对象
  28.     public function travelModel()
  29.     {
  30.         return $this->vehicle->drive() . ' : 去旅行';
  31.     }
  32. }
  33. // 客户端调用
  34. echo  (new Travel1('car'))->travelModel(), '<br>';
  35. echo  (new Travel1('train'))->travelModel(), '<br>';
  36. echo  (new Travel1('plane'))->travelModel(), '<br>';

base\Travel2.php

  1. <?php
  2. // 旅行类: 使用最传统的方式
  4. namespace base;
  6. // 设置引用的外部类名的别名
  7. use base\inc1\Car;
  8. use base\inc1\Train;
  9. use base\inc1\Plane;
  11. require __DIR__ . '/autoload.php';
  13. // 工厂类, 专用于创建类实例
  14. class Factory
  15. {
  16.    protected static $instance = null;
  18.    public static function getInstance($vehicle)
  19.    {
  20.        switch (strtolower($vehicle)) {
  21.            case 'car':
  22.                self::$instance = new Car();
  23.                break;
  24.            case 'train':
  25.                self::$instance = new Train();
  26.                break;
  27.            case 'plane':
  28.                self::$instance = new Plane();
  29.        }
  31.        // 返回当前具体的交通工具
  32.        return self::$instance;
  33.    }
  34. }
  37. class Travel2
  38. {
  39.     // 交通工具
  40.     private $vehicle;
  42.     // 构造方法
  43.     public function __construct($vehicle)
  44.     {
  45.         $this->vehicle = Factory::getInstance($vehicle);
  46.     }
  48.     // 调用外部一个依赖对象
  49.     public function travelModel()
  50.     {
  51.         return $this->vehicle->drive() . ' : 去旅行';
  52.     }
  53. }
  55. // 客户端调用
  56. echo  (new Travel2('car'))->travelModel(), '<br>';
  57. echo  (new Travel2('train'))->travelModel(), '<br>';
  58. echo  (new Travel2('plane'))->travelModel(), '<br>';

base\inc2\Car.php

  1. <?php
  2. namespace base\inc2;
  3. class Car implements iVehicle
  4. {
  5.     public function drive()
  6.     {
  7.         return '开汽车';
  8.     }
  9. }

base\inc2\iVehicle.php

  1. <?php
  2. namespace base\inc2;
  3. // 交通工具的接口
  4. interface iVehicle
  5. {
  6.     public function drive();
  7. }

base\inc2\Plane.php

  1. <?php
  2. namespace base\inc2;
  3. class Plane implements iVehicle
  4. {
  5.     public function drive()
  6.     {
  7.         return '乘飞机';
  8.     }
  9. }

base\inc2\Ship.php

  1. <?php
  2. namespace base\inc2;
  3. class Ship implements iVehicle
  4. {
  5.     public function drive()
  6.     {
  7.         return '坐轮船';
  8.     }
  9. }

base\inc2\Train.php

  1. <?php
  2. namespace base\inc2;
  3. class Train implements iVehicle
  4. {
  5.     public function drive()
  6.     {
  7.         return '坐火车';
  8.     }
  9. }

base\Travel3.php

  1. <?php
  2. // 旅行类: 
  3. namespace base;
  4. // 设置引用的外部类名的别名
  5. use base\inc2\Car;
  6. use base\inc2\Train;
  7. use base\inc2\Plane;
  8. use base\inc2\Ship;
  9. use base\inc2\iVehicle;
  10. require __DIR__ . '/autoload.php';
  11. class Travel3
  12. {
  13.     // 交通工具
  14.     private $vehicle;
  16.     // 构造方法
  17.     public function __construct(iVehicle $vehicle)
  18.     {
  19.         $this->vehicle = $vehicle;
  20.     }
  21.    // 调用外部一个依赖对象
  22.     public function travelModel()
  23.     {
  24.         return $this->vehicle->drive() . ' : 去旅行';
  25.     }
  26. }
  27. // 客户端调用
  28. $car = new Car();
  29. echo  (new Travel3($car))->travelModel(), '<br>';
  30. echo  (new Travel3(new Train()))->travelModel(), '<br>';
  31. echo  (new Travel3(new Plane()))->travelModel(), '<br>';
  32. echo  (new Travel3(new Ship()))->travelModel(), '<br>';

总结：

学习了什么是单例模式、工厂模式
学习了使用依赖注入来解决对象调用之间耦合

上一条：PHP类和对象的基础学习——php线上第九期下一条：微信域名检测接口（含PHP、Python调用演示步骤）
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多