search

博客列表 >12月5日_设计模式、单例、工厂、服务容器、面向接口编程 - 九期线上班

12月5日_设计模式、单例、工厂、服务容器、面向接口编程 - 九期线上班

只猫
只猫原创
2019年12月06日 19:23:02717浏览

设计模式 单例、工厂、容器、面向接口

单例模式 demo1
  1. <?php
  2. namespace _1205;
  3. //设计模式 - 单例模式
  4. //单例：类的唯一实例
  5. //这个类只允许new一个对象。重复new还是那同一个对象
  6. //举例Temp
  7. class Temp
  8. {
  10. }
  12. $obj1 = new Temp();    //object(_1205\Temp)#1 (0) { }
  13. $obj2 = new Temp();    //object(_1205\Temp)#2 (0) { }
  14. var_dump($obj1, $obj2);
  15. echo '<br>';
  16. var_dump($obj1 === $obj2);    //bool(false)
  17. echo '<hr>';
  19. //比如单例模式用于数据库连接 (数据库连接数量有上限)
  20. //单例Demo1
  21. class Demo1
  22. {
  23.     //1.new类的时候会自动调用类的构造方法
  24.     //那么将构造方法私有，这个类在外部将无法访问
  25.     private function __construct(){
  26.         //私有的构造方法 禁止外部new
  27.     }
  28.     //这个时候这个类一个实例都没有
  29.     //类中成员只能用类本身来访问 静态成员$instance
  30.     public static $instance = null;
  32.     //2.在类的内部写一个创建自己的实例的方法
  33.     //全球限量唯一发售
  34.     public static function getInstance(){
  35.         //先判断自己是否已经实例化过
  36.         if(is_null(self::$instance)){
  37.             self::$instance = new self();
  38.         }
  39.         return self::$instance;
  40.         //已创建过，返回自己的唯一对象
  41.     }
  42.     //3.禁止克隆这个类
  43.     private function __clone(){
  44.         //__clone方法在类被克隆时自动调用，用于重写克隆体的成员。
  45.         //把这个禁止就像禁用了构造方法无法new一样无法被克隆。
  46.     }
  47. }
  48. //调用
  49. $obj1 = Demo1::getInstance();    //object(_1205\Demo1)#3 (0) { }
  50. $obj2 = Demo1::getInstance();    //object(_1205\Demo1)#3 (0) { }
  51. var_dump($obj1,$obj2);    
  52. echo '<br>';
  53. var_dump($obj1===$obj2);    //bool(true)
案例：数据库连接
  1. <?php
  2. namespace _1205;
  3. use PDO;
  4. //单例模式连接数据库
  5. class Db
  6. {
  7.     private function __construct(...$connectParams){
  8.         $dsn = $connectParams[0];
  9.         $username = $connectParams[1];
  10.         $password = $connectParams[2];
  12.         self::$pdo = new PDO($dsn,$username,$password);
  13.     }
  14.     public static $pdo = null;
  16.     //2.方法接收参数
  17.     public static function getInstance(...$connectParams){
  18.         //先判断自己是否已经实例化过
  19.         if(is_null(self::$pdo)){
  20.             //构造函数不需要返回值
  21.             new self(...$connectParams);
  22.         }
  23.         return self::$pdo;
  24.         //已创建过，返回自己的唯一对象
  25.     }
  26.     private function __clone(){
  28.     }
  29. }
  30. //设置参数
  31. $connectParams = [
  32.         'mysql:host=localhost;dbname=php_2019',
  33.         'root',
  34.         12341234
  35.         ];
  36. //获取对象
  37. $pdo = Db::getInstance(...$connectParams);
  38. //打印数据
  39. echo '<pre>';
  40. print_r($pdo->query('SELECT * FROM `user`')->fetchAll());
  41. echo '</pre>';
demo2 工厂模式
  1. <?php
  2. namespace _1205;
  3. //工厂模式
  4. class Demo2
  5. {
  6.     //...
  7. }
  8. //不同的file都要创建Demo2的实例
  9. $obj = new Demo2();
  10. $obj = new Demo2();
  11. /******************************************/
  12. class Test1
  13. {
  14.     public function __construct($arg1)
  15.     {
  16.         echo '对象创建成功，参数为'.$arg1.'<br>';
  17.     }
  18. }
  19. class Test2
  20. {
  21.     public function __construct($arg1,$arg2)
  22.     {
  23.         echo '对象创建成功，参数为'.implode(',', [$arg1,$arg2]).'<br>';
  24.     }
  25. }
  26. class Test3
  27. {
  28.     public function __construct($arg1,$arg2,$arg3)
  29.     {
  30.         echo '对象创建成功，参数为'.implode(',', [$arg1,$arg2,$arg3]).'<br>';
  31.     }
  32. }
  34. //工厂 来生产类的实例
  35. class Factory
  36. {
  37.     public static function create($className,...$args){
  38.         return new $className(...$args);
  39.     }
  40. }
  42. //生产
  43. //Test1::class 等于 _1205\Test1
  44. Factory::create(Test1::class,100);
  45. Factory::create(Test2::class,100,200);
  46. Factory::create(Test3::class,100,200,300);

demo3 依赖注入
  1. <?php
  2. namespace _1205;
  3. //依赖注入
  4. //一般情况下
  5. //工作类
  6. class Person1
  7. {
  8.     //人依赖汽车去上班
  9.     private $car = null;
  11.     //构造方法中将依赖的外部对象全部实例化
  12.     public function __construct(){
  13.         //类方法中出现了new 代表耦合很高
  14.         $this->car = new Car1();
  15.     }
  17.     public function toWork(){
  18.         return $this->car->drive();
  19.     }
  20. }
  21. //依赖类
  22. class Car1
  23. {
  24.     public function drive(){
  25.         return '开车去上班';
  26.     }
  27. }
  29. //客户端调用
  30. //实例化
  31. $p1 = new Person1();
  32. echo $p1->toWork();
  33. echo '<hr>';
  35. /*************************************/
  36. //将依赖注入 解决在类中使用new的情况
  37. class Person2
  38. {
  39.     //人依赖汽车去上班
  40.     private $car = null;
  42.     //构造方法中将依赖的外部对象全部实例化
  43.     //把$car2传入到构造方法
  44.     public function __construct(Car2 $car2){
  45.         //消除了new 用外部创建的$car2代替
  46.         $this->car = $car2;
  47.     }
  49.     public function toWork(){
  50.         return $this->car->drive();
  51.     }
  52. }
  53. //依赖类
  54. class Car2
  55. {
  56.     public function drive(){
  57.         return '开车去上班';
  58.     }
  59. }
  61. //客户端调用
  62. //Car类在外部实例化 再将得到的$car注入到Person的构造方法中
  63. $car2 = new Car2();
  64. //这里记得new时候给类传参，因为构造方法需要参数
  65. $p2 = new Person2($car2);
  66. echo $p2->toWork();
  67. echo '<hr>';
lesson1 容器

1.Maker

  1. <?php
  2. namespace _1205;
  4. //制造商类
  5. class Maker
  6. {
  7.     public function get(){
  8.         return '华为';
  9.     }
  10. }

2.Product

  1. <?php
  2. namespace _1205;
  3. //产品类
  4. class Product
  5. {
  6.     //$maker Maker类的一个实例
  7.     public function get(Maker $maker){
  8.         return '该手机是由：<span style="color:red;font-weight:bolder">'. $maker->get() .'</span>生产的';
  9.     }
  10. }

3.demo1 不使用容器的类调用

  1. <?php
  2. namespace _1205;
  3. //客户端调用
  4. require 'Product.php';
  5. require 'Maker.php';
  6. //不使用容器 对两个类进行调用
  7. class Client1
  8. {
  9.     public function show(){
  11.         //创建产品实例
  12.         $product = new Product();
  14.         //制造商实例
  15.         $maker = new Maker();
  17.         //制造商注入到产品类里
  18.         return $product->get($maker);
  19.     }
  20. }
  21. //客户端调用
  22. //节省了一个对象
  23. echo (new Client1())->show();

4.Container 写个容器

  1. <?php
  2. namespace _1205;
  3. //引入闭包别名
  4. use Closure;
  6. class Container
  7. {
  8.     //容器数组
  9.     protected $instance = [];
  10.     //类实例化过程绑定到容器中
  11.     public function bind($alias,Closure $process){
  12.         //类的实例化代码绑定到类名
  13.         $this->instance[$alias] = $process;
  14.     }
  15.     //取出保存在容器中的类实例化闭包 并执行它
  16.     public function make($alias){
  17.         //return $this->instance[$alias]();
  18.         return call_user_func_array($this->instance[$alias] , []);
  19.     }
  20. }

5.demo 使用容器的类调用

  1. <?php
  2. namespace _1205;
  3. //客户端调用
  4. require 'Product.php';
  5. require 'Maker.php';
  6. require 'Container.php';
  7. //使用容器 对两个类进行调用
  8. class Client2
  9. {
  10.     public function show(Product $product, Maker $maker){
  12.         //制造商注入到产品类里
  13.         return $product->get($maker);
  14.     }
  15. }
  17. //实例化Container
  18. $container = new Container();
  19. //开始绑定
  20. //将产品类与实例化代码绑定到容器中
  21. //这里别名随便取
  22. $container->bind('product',function(){return new Product();});
  23. //将制造商类与实例化代码绑定到容器中
  24. $container->bind('maker',function(){return new Maker();});
  25. //创建产品实例并返回给一个变量 
  26. //这里make传入的类名就是之前起的别名
  27. $product = $container->make('product');
  28. //创建制造商实例并返回给一个变量
  29. $maker = $container->make('maker');
  31. //客户端调用
  32. echo (new Client2())->show($product,$maker);

结果：

base 面向接口编程

autoload.php

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

inc1
Car.php

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

Train.php

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

Plane.php

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

Travel1

  1. <?php
  2. namespace base;
  3. use base\inc1\Car;
  4. use base\inc1\Train;
  5. use base\inc1\Plane;
  6. require __DIR__.'/autoload.php';
  8. //最原始
  10. class Travel1
  11. {
  12.     private $vehicle;
  14.     //构造方法
  15.     public function __construct($vehicle){
  16.         //传入不同参数 实例化不同类
  17.         //严重依赖
  18.         switch (strtolower($vehicle)){
  19.             case 'car':
  20.             $this->vehicle = new Car();
  21.             break;
  22.             case 'train':
  23.             $this->vehicle = new Train();
  24.             break;
  25.             case 'plane':
  26.             $this->vehicle = new Plane();
  27.         }
  28.     }
  30.     public function travelModel(){
  31.         return $this->vehicle->drive().'去旅行';
  32.     }
  33. }
  35. //客户端调用
  37. echo (new Travel1('car'))->travelModel().'<br>';
  38. echo (new Travel1('plane'))->travelModel().'<br>';
  39. echo (new Travel1('train'))->travelModel().'<br>';

Travel2

  1. <?php
  2. namespace base;
  3. use base\inc1\Car;
  4. use base\inc1\Train;
  5. use base\inc1\Plane;
  6. require __DIR__.'/autoload.php';
  8. //用工厂
  9. class Factory
  10. {
  11.     protected static $instance = null;
  13.     public static function getInstance($vehicle){
  14.         //传入不同参数 实例化不同类
  15.         switch (strtolower($vehicle)){
  16.             case 'car':
  17.             static::$instance = new Car();
  18.             break;
  19.             case 'train':
  20.             static::$instance = new Train();
  21.             break;
  22.             case 'plane':
  23.             static::$instance = new Plane();
  24.         }
  25.     //返回
  26.     return self::$instance;
  27.     }
  28. }
  29. class Travel2
  30. {
  31.     private $vehicle;
  33.     //构造方法
  34.     public function __construct($vehicle){
  35.         //一句代码从工厂获取实例对象
  36.         //依赖一个工厂。。
  37.         $this->vehicle = Factory::getInstance($vehicle);
  38.     }
  39.     public function travelModel(){
  40.         return $this->vehicle->drive().'===去旅行';
  41.     }
  42. }
  44. //客户端调用
  46. echo (new Travel2('car'))->travelModel().'<br>';
  47. echo (new Travel2('plane'))->travelModel().'<br>';
  48. echo (new Travel2('train'))->travelModel().'<br>';

inc2
Car.php、Train.php、Plane.php 外添加一个 Ship.php 都实现了iVehicle接口

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

接口 iVehicle.php

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

Travel3

  1. <?php
  2. namespace base;
  3. use base\inc2\Car;
  4. use base\inc2\Train;
  5. use base\inc2\Plane;
  6. use base\inc2\Ship;
  7. use base\inc2\iVehicle;
  8. //自动加载
  9. require __DIR__.'/autoload.php';
  11. //用接口
  12. class Travel3
  13. {
  14.     private $vehicle;
  16.     //构造方法 这里需要接收一个对象，就是实现了vehicle接口的对象
  17.     public function __construct(iVehicle $vehicle){
  19.         $this->vehicle = $vehicle;
  20.     }
  22.     public function travelModel(){
  23.         return $this->vehicle->drive().'@@@去旅行';
  24.     }
  25. }
  27. //客户端调用
  28. //这里new 的时候 传入一个对象
  29. echo (new Travel3(new Car()))->travelModel().'<br>';
  30. echo (new Travel3(new Plane()))->travelModel().'<br>';
  31. echo (new Travel3(new Train()))->travelModel().'<br>';
  32. echo (new Travel3(new Ship()))->travelModel().'<br>';


手写：

总结：类里面的方法调用相互传参的步骤还是会晕。一步一步看好像又明白了。。其实没啥难的。。。吧。。设计模式这种东西真的蛮烧脑的。很耐人寻味。老师讲课真的很认真也特别用心。作为听讲者也要好好学啊。

上一条：12月05日设计模式与服务容器-九期线上班下一条：静态类方法与MVC设计模式的依赖注入方法，容器绑定与Facade门面 - 第九期线上班 20191206
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多