12月05日- 设计模式与依赖注入

一、单例模式

单例模式：创建类的唯一实例

class Db{
    // 1、静态成员私有化
    private static $instance = null;
    // 2、构造方法私有化
    public function __construct()
    {
    }
    // 3、提供一个外部访问的静态公有接口
    public static function getInstance(){
        if (self::$instance instanceof self){
            self::$instance = new self();
        }
        return self::$instance;
    }
    // 4、私有化克隆方法
    public function __clone()
    {
    }
}
$obj1 = Db::getInstance();
$obj2 = Db::getInstance();
var_dump($obj1 === $obj2); //bool(true)

使用场景：连接数据库，获取PDO实例

class Db{
    // 1、静态成员私有化
    private static $pdo = null;
    // 2、构造方法私有化
    public function __construct(...$config)
    {
        list($dsn,$username,$password) = $config;
        try {
            self::$pdo = new PDO($dsn, $username, $password);
        } catch (Exception $e) {
            die('数据库连接失败：'.$e->getMessage());
        }
    }
    // 3、提供一个外部访问的静态公有接口
    public static function getInstance(...$config){
        if (is_null(self::$pdo)){
            //self::$pdo = new self(...$config); 这里表示把Db类的实例赋值给pdo对象
            new self(...$config);
        }
        return self::$pdo;
    }
    // 4、私有化克隆方法
    public function __clone()
    {
    }
}
$config = ['mysql:host=demo.com;dbname=demo','root','root'];
$pdo = Db::getInstance(...$config);
$sql = 'select * from `user`';
print_r($pdo->query($sql)->fetchAll(2));

代码效果：

二、工厂模式

工厂模式：批量创建类实例/对象

class Demo1
{
    public function __construct($agr1)
    {
        echo '对象创建成功，参数是' . $agr1;
    }
}
class Demo2
{
    public function __construct($agr1, $arg2)
    {
        echo '对象创建成功，参数是' . $agr1 .'--'. $arg2;
    }
}
class Demo3
{
    public function __construct($agr1, $arg2, $arg3)
    {
        echo '对象创建成功，参数是' . $agr1 .'--'. $arg2 .'--'. $arg3;
    }
}
class Factory
{
    public static function create($className, ...$args)
    {
        return new $className(...$args);
    }
}
Factory::create(Demo1::class,'100');
echo '<hr>';
Factory::create(Demo2::class,'100','200');
echo '<hr>';
Factory::create(Demo3::class,'100','200','300');

代码效果：

三、依赖注入

依赖注入：解决对象调用之间的耦合问题
实现方法：通过类的方法和构造函数以参数的形式将外部对象注入到类中

class Marker{
    public function info(){
        return '苹果';
    }
}
class Product{
    //Marker类注入到 get()方法中
    public function get(Marker $marker){
        return 'iPhone X手机是由 '.$marker->info().' 生产的';
    }
}
class Client{
    //Marker类、Product类注入到 show()方法中
    public function show(Product $product, Marker $marker)
    {
        return $product->get($marker);
    }
}
$product = new Product();
$marker = new Marker();
$client = new Client();
echo $client->show($product, $marker); //iPhone X手机是由 苹果 生产的

四、服务容器

服务容器：将类的 “实例” 与 “实例化” 的过程统一管理
容器实现：容器必须具有类的实例过程的绑定与执行功能

class Marker{
    public function info(){
        return '苹果';
    }
}
class Product{
    //Marker类注入到 get()方法中
    public function get(Marker $marker){
        return 'iPhone X手机是由 '.$marker->info().' 生产的';
    }
}
class Container{
    //类似实例的容器
    protected $instance = [];
    //将类的实例化过程绑定到容器中
    public function bind($alias, Closure $closure){
        $this->instance[$alias] = $closure;
    }
    //将类的实例化过程从容器中取出来,执行
    public function make($alias, $params=[]){
        return call_user_func_array($this->instance[$alias], $params);
    }
}
class Client{
    //Marker类、Product类注入到 show()方法中
    public function show(Product $product, Marker $marker)
    {
        return $product->get($marker);
    }
}
$container = new Container();
//将实例化过程绑定到容器中
$container->bind('product', function (){return new Product();});
$container->bind('marker', function (){return new Marker();});
//将实例化过程取出并返回
$product = $container->make('product');
$marker = $container->make('marker');
$client = new Client();
echo $client->show($product, $marker);

五、工厂方法实例

class Car{
    public function drive(){
        return '开汽车';
    }
}
class Plane{
    public function drive(){
        return '乘飞机';
    }
}
class Train{
    public function drive(){
        return '坐火车';
    }
}
//工厂模式
class Factory{
    //类实例对象
    private static $instance = null;
    /**
     * 返回类的实例
     * @param $vehicle
     * @return Car|Plane|Train|null
     */
    public static function getInstance($vehicle){
        switch (strtolower($vehicle)){
            case 'car':
                self::$instance = new Car();
                break;
            case 'plane':
                self::$instance = new Plane();
                break;
            case 'train':
                self::$instance = new Train();
                break;
        }
        return self::$instance;
    }
}
class Demo{
    private $vehicle;
    //将类的实例注入到构造方法中
    public function __construct($vehicle)
    {
        $this->vehicle = Factory::getInstance($vehicle);
    }
    public function travel(){
        return $this->vehicle->drive().'---去旅行';
    }
}
$car = new Demo('car');
echo $car->travel();
$plane = new Demo('plane');
echo $plane->travel();
$train = new Demo('train');
echo $train->travel();

六、面向接口编程

interface iVehicle{
    public function drive();
}
class Car implements iVehicle {
    public function drive(){
        return '开汽车';
    }
}
class Plane implements iVehicle {
    public function drive(){
        return '乘飞机';
    }
}
class Train implements iVehicle {
    public function drive(){
        return '坐火车';
    }
}
class Demo{
    private $vehicle;
    //将接口注入到构造方法中
    public function __construct(iVehicle $vehicle)
    {
        $this->vehicle = $vehicle;
    }
    //直接使用接口的方法
    public function travel(){
        return $this->vehicle->drive().'---去旅行---接口实现';
    }
}
//Car类相当于是接口的子类
$car = new Demo(new Car());
echo $car->travel();
//Plane类相当于是接口的子类
$plane = new Demo(new Plane());
echo $plane->travel();
//Train类相当于是接口的子类
$train = new Demo(new Train());
echo $train->travel();

手写：

课堂总结：

1、单例模式创建唯一实例
2、工厂模式创建批量实例
3、依赖注入主要实现是将外部对象注入到工作类的构造函数或方法中，降低代码耦合度
4、容器统一管理类的对象和实例化过程，并在类中提供绑定方法和执行方法
5、面向接口编程：相当于把实现接口类注入到类中，降低耦合度

THE END !