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

单例模式

<?php
namespace _120502;
// 单例模式
class Db
{
    // 构造方法私有化
    private function __construct(...$connectParams)
    {
        $dsn = $connectParams[0];
        $username = $connectParams[1];
        $password = $connectParams[2];
        self::$pdo = new \PDO($dsn, $username, $password);
    }
    // 目前 只能在类中的内部将类实例化
    // 当前类的实例
    public static $pdo = null;
    // 实例化当前类的方法
    public static function getInstance(...$connectParams)
    {
        // 实例化当前类,并返回类实例/对象
        // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
        if (is_null(self::$pdo)) {
            // 构造函数不需要返回
            new self(...$connectParams);
        }
        return self::$pdo;
    }
    // 禁用克隆魔术方法
    private function __clone()
    {
        // ...
    }
}
$connectParams = ['mysql:host=localhost;dbname=tj_ys', 'root', '123123'];
$pdo = Db::getInstance(...$connectParams);
$use=$pdo->query('SELECT * FROM `user`')->fetchAll();
echo '<pre>'  . print_r($use, true) . '</pre>';

工厂模式

<?php
// 工厂模式: 用于批量创建类的实例/对象
class Test1
{
    public function __construct($arg1)
    {
        echo '对象创建成功, 参数是: ' . $arg1;
    }
}
class Test2
{
    public function __construct($arg1, $arg2)
    {
        echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2]);
    }
}
class Test3
{
    public function __construct($arg1, $arg2, $arg3)
    {
        echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2, $arg3]);
    }
}
// 工厂类, 专用于创建类实例
class Factory
{
    public static function create($className, ...$argments)
    {
        return new $className(...$argments);
    }
}
// 用工厂类来创建类实例/对象
Factory::create(Test1::class, 100);
echo '<br>';
Factory::create(Test2::class, 100, 200);
echo '<br>';
Factory::create(Test3::class, 100, 200, 300);

依赖注入

<?php
// 依赖注入: 解决对象调用之间耦合
// 工作类
class Person
{
    // 要依赖的外部对象
    private $car = null;
    // 在构造方法中将依赖的外部对象全部实例化
    // 注入点放到构造方法中
    public function __construct(Car $car)
    {
        $this->car = $car;
    }
    // 外部对象执行一个动作
    public function work()
    {
        return $this->car->drive();
    }
}
// 依赖的外部类
class Car
{
    public function drive()
    {
        return '开车去上班';
    }
}
// 实例化类
$car = new Car();
$person = new Person($car);
echo $person->work();

mvc案例

base\inc1\Car.php

<?php
namespace base\inc1;
class Car
{
    public function drive()
    {
        return '开汽车';
    }
}

base\inc1\Plane.php

<?php
namespace base\inc1;
class Plane
{
    public function drive()
    {
        return '乘飞机';
    }
}

base\inc1\Train.php

<?php
namespace base\inc1;
class Train
{
    public function drive()
    {
        return '坐火车';
    }
}

base\autoload.php

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

base\Travel1.php

<?php
// 旅行类: 使用最传统的方式
namespace base;
// 设置引用的外部类名的别名
use base\inc1\Car;
use base\inc1\Train;
use base\inc1\Plane;
require __DIR__ . '/autoload.php';
class Travel1
{
    // 交通工具
    private $vehicle;
    // 构造方法
    public function __construct($vehicle)
    {
        switch (strtolower($vehicle)) {
            case 'car':
                $this->vehicle = new Car();
                break;
            case 'train':
                $this->vehicle = new Train();
                break;
            case 'plane':
                $this->vehicle = new Plane();
        }
    }
    // 调用外部一个依赖对象
    public function travelModel()
    {
        return $this->vehicle->drive() . ' : 去旅行';
    }
}
// 客户端调用
echo  (new Travel1('car'))->travelModel(), '<br>';
echo  (new Travel1('train'))->travelModel(), '<br>';
echo  (new Travel1('plane'))->travelModel(), '<br>';

base\Travel2.php

<?php
// 旅行类: 使用最传统的方式
namespace base;
// 设置引用的外部类名的别名
use base\inc1\Car;
use base\inc1\Train;
use base\inc1\Plane;
require __DIR__ . '/autoload.php';
// 工厂类, 专用于创建类实例
class Factory
{
   protected static $instance = null;
   public static function getInstance($vehicle)
   {
       switch (strtolower($vehicle)) {
           case 'car':
               self::$instance = new Car();
               break;
           case 'train':
               self::$instance = new Train();
               break;
           case 'plane':
               self::$instance = new Plane();
       }
       // 返回当前具体的交通工具
       return self::$instance;
   }
}
class Travel2
{
    // 交通工具
    private $vehicle;
    // 构造方法
    public function __construct($vehicle)
    {
        $this->vehicle = Factory::getInstance($vehicle);
    }
    // 调用外部一个依赖对象
    public function travelModel()
    {
        return $this->vehicle->drive() . ' : 去旅行';
    }
}
// 客户端调用
echo  (new Travel2('car'))->travelModel(), '<br>';
echo  (new Travel2('train'))->travelModel(), '<br>';
echo  (new Travel2('plane'))->travelModel(), '<br>';

base\inc2\Car.php

<?php
namespace base\inc2;
class Car implements iVehicle
{
    public function drive()
    {
        return '开汽车';
    }
}

base\inc2\iVehicle.php

<?php
namespace base\inc2;
// 交通工具的接口
interface iVehicle
{
    public function drive();
}

base\inc2\Plane.php

<?php
namespace base\inc2;
class Plane implements iVehicle
{
    public function drive()
    {
        return '乘飞机';
    }
}

base\inc2\Ship.php

<?php
namespace base\inc2;
class Ship implements iVehicle
{
    public function drive()
    {
        return '坐轮船';
    }
}

base\inc2\Train.php

<?php
namespace base\inc2;
class Train implements iVehicle
{
    public function drive()
    {
        return '坐火车';
    }
}

base\Travel3.php

<?php
// 旅行类: 
namespace base;
// 设置引用的外部类名的别名
use base\inc2\Car;
use base\inc2\Train;
use base\inc2\Plane;
use base\inc2\Ship;
use base\inc2\iVehicle;
require __DIR__ . '/autoload.php';
class Travel3
{
    // 交通工具
    private $vehicle;
    // 构造方法
    public function __construct(iVehicle $vehicle)
    {
        $this->vehicle = $vehicle;
    }
   // 调用外部一个依赖对象
    public function travelModel()
    {
        return $this->vehicle->drive() . ' : 去旅行';
    }
}
// 客户端调用
$car = new Car();
echo  (new Travel3($car))->travelModel(), '<br>';
echo  (new Travel3(new Train()))->travelModel(), '<br>';
echo  (new Travel3(new Plane()))->travelModel(), '<br>';
echo  (new Travel3(new Ship()))->travelModel(), '<br>';

总结：

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