Yii2 理解di

最新推荐文章于 2025-05-30 16:18:05 发布

转载最新推荐文章于 2025-05-30 16:18:05 发布 · 190 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://yq.aliyun.com/articles/206275

文章标签：

#php

0 链接

http://alex-my.xyz/web/Yii2-理解di

1 版本

// yii\BaseYii\getVersion
public static function getVersion()
{
    return '2.0.10';
}

2 简述

简单的说就是di把类的构造函数分析好存储起来，配上给定的参数，创建实例。

// 类名给定后通过php的反射机制获取构造函数信息
// set的第二个参数是构造函数需要使用的参数值
$container->set('yii\db\Connection', [
        'dsn' => 'mysql:host=127.0.0.1;dbname=demo',
        'username' => 'root',
        'password' => '123456',
        'charset' => 'utf8',
    ]);

3 Container

\yii\di\Container

$_singletons, 保存单例
键: 类名，接口名，别名
值: 类的示例, null表示未初始化

$_definitions, 保存依赖定义
键：类名，接口名，别名
值：函数, 数组(一定要含有class元素)

$_params, 保存构造函数的参数
键：类名，接口名，别名
值：数组

$_reflections, 缓存类反射实例
键：类名，接口名，别名
值：类反射实例

$_dependencies, 缓存依赖信息
键：类名，接口名，别名
值：

normalizeDefinition处理依赖定义, 这里的$definition会影响到$class的构造函数参数值
返回一个数组，且数组中必须含有class元素
示例说明见set, setSingleton的后面

protected function normalizeDefinition($class, $definition)
{
    // 则直接返回，$class构造函数没有参数
    if (empty($definition)) 
    {
        return ['class' => $class];
    }
    // 如果是字符串，则认为$definition是所依赖的类名，接口名，或者别名
    elseif (is_string($definition)) 
    {
        return ['class' => $definition];
    } 
    // 认为$class是别名，$definition能得到一个对象实例
    elseif (is_callable($definition, true) || is_object($definition)) 
    {
        return $definition;
    } 
    elseif (is_array($definition)) 
    {
        // $definition除了class元素外，都是$class类构造函数的参数值
        if (!isset($definition['class'])) 
        {
            // 如果没有包含'class'元素，则$class一定是一个完整路径的类名/接口名
            // 比如$class为yii\db\Connection
            if (strpos($class, '\\') !== false) 
            {
                $definition['class'] = $class;
            } 
            else 
            {
                throw new InvalidConfigException("A class definition requires a \"class\" member.");
            }
        }
        return $definition;
    } 
    else 
    {
        throw new InvalidConfigException("Unsupported definition type for \"$class\": " . gettype($definition));
    }
}

set, setSingleton,注册依赖
前者注册的之后每次get都会得到新的实例
后者注册的之后每次get都是得到第一次实例化的对象
二者的区别将在get函数中体现

public function set($class, $definition = [], array $params = [])
{
    $this->_definitions[$class] = $this->normalizeDefinition($class, $definition);
    $this->_params[$class] = $params;
    unset($this->_singletons[$class]);
    return $this;
}
public function setSingleton($class, $definition = [], array $params = [])
{
    $this->_definitions[$class] = $this->normalizeDefinition($class, $definition);
    $this->_params[$class] = $params;
    $this->_singletons[$class] = null;
    return $this;
}

使用示例, set, setSingleton, normalizeDefinition相关
函数原型:
normalizeDefinition($class, $definition)

// 在normalizeDefinition中，$class为真正的类名
$container->set('yii\db\Connection');

// 在normalizeDefinition中, $definition才是真正将来实例化的类
$container->set('yii\mail\MailInterface', 'yii\swiftmailer\Mailer');

// 相当于注册了一个别名foo, 因为$_definitions, $_params, $_singletons都是用$class做为键
// 真正的class信息会存储在$definition['class']中
$container->set('foo', 'yii\db\Connection');

// $_definitions直接保存了$definition这些依赖信息($class构造函数的参数信息)
$container->set('yii\db\Connection', [
    'dsn' => 'mysql:host=127.0.0.1;dbname=demo',
    'username' => 'root',
    'password' => '123456',
    'charset' => 'utf8',
    ]);

// 前面一个不方便使用，可以定义别名，可以使用$container->get('db')
$container->set('db', [
    'class' => 'yii\db\Connection',
    'dsn' => 'mysql:host=127.0.0.1;dbname=demo',
    'username' => 'root',
    'password' => '123456',
    'charset' => 'utf8',
    ]);

// $definition可以是函数，每次使用的时候都会调用这个函数生成新的实例
$container->set('db', function ($container, $params, $config) {
        return new \yii\db\Connection($config);
    });

// $definition可以是实例，每次调用都会使用这个实例, 相当于setSingleton
$container->set('db', new \yii\db\Connection($config))

getDependencies($class)解析依赖信息，主要是获取类的构造函数的信息，这样才能调用构造函数创建实例
参数$class是类名

protected function getDependencies($class)
{
    // 如果已有缓存的依赖信息，则直接使用
    if (isset($this->_reflections[$class])) 
    {
        return [$this->_reflections[$class], $this->_dependencies[$class]];
    }

    $dependencies = [];
    // 使用PHP5的反射来获取类的信息
    // 通过ReflectionClass，可以获取$class的以下信息:
    // 属性，函数，常量，静态属性，命名空间等
    $reflection = new ReflectionClass($class);
    // 获得$class这个类的构造函数信息
    $constructor = $reflection->getConstructor();
    if ($constructor !== null) 
    {
        // 解析构造函数的参数
        foreach ($constructor->getParameters() as $param) 
        {
            // 如果参数有默认值，则直接使用该默认值
            if ($param->isDefaultValueAvailable()) 
            {
                $dependencies[] = $param->getDefaultValue();
            } 
            // 用Instance封装参数, Instance::id存储着类名，在build中会进行实例化
            else 
            {
                $c = $param->getClass();
                $dependencies[] = Instance::of($c === null ? null : $c->getName());
            }
        }
    }
    // 缓存起来，供下次使用
    $this->_reflections[$class] = $reflection;
    $this->_dependencies[$class] = $dependencies;

    return [$reflection, $dependencies];
}

resolveDependencies实例化依赖，也就是创建构造函数的参数对象

protected function resolveDependencies($dependencies, $reflection = null)
{
    foreach ($dependencies as $index => $dependency) 
    {
        // 在解析依赖信息的getDependencies中，有部分参数没有默认值，而是创建了Instance对象
        // 这里会将这些Instance对象实例化对真正的构造函数的参数对象
        if ($dependency instanceof Instance) 
        {
            if ($dependency->id !== null) 
            {
                // 从di中获取真正的示例对象
                $dependencies[$index] = $this->get($dependency->id);
            } 
            ...
        }
    }
    return $dependencies;
}

真正创建对象的是通过build, $class是类名，而不是别名，接口名

protected function build($class, $params, $config)
{
    // 类的信息$reflection
    // 类的构造函数信息
    list ($reflection, $dependencies) = $this->getDependencies($class);
    // 用$params的内容补充，覆盖到构造函数信息中
    foreach ($params as $index => $param) 
    {
        $dependencies[$index] = $param;
    }
    // 实例化构造函数中的参数
    $dependencies = $this->resolveDependencies($dependencies, $reflection);
    // 不能实例化的类(为何不放前面...)
    if (!$reflection->isInstantiable()) 
    {
        throw new NotInstantiableException($reflection->name);
    }
    // 没有构造函数，则直接实例化
    if (empty($config))
    {
        return $reflection->newInstanceArgs($dependencies);
    }
    // 如果是实现了接口Configurable，需要将配置放到构造函数参数列表的最后一个
    if (!empty($dependencies) && $reflection->implementsInterface('yii\base\Configurable')) 
    {
        $dependencies[count($dependencies) - 1] = $config;
        return $reflection->newInstanceArgs($dependencies);
    } 
    else 
    {
        $object = $reflection->newInstanceArgs($dependencies);
        foreach ($config as $name => $value) 
        {
            $object->$name = $value;
        }
        return $object;
    }
}

我们最终会用到的是get函数

public function get($class, $params = [], $config = [])
{
    // 单例，且存在，则直接使用
    if (isset($this->_singletons[$class])) 
    {
        return $this->_singletons[$class];
    } 
    // 没有使用set/setSingleton注册的，直接创建实例
    elseif (!isset($this->_definitions[$class])) 
    {
        return $this->build($class, $params, $config);
    }
    $definition = $this->_definitions[$class];

    if (is_callable($definition, true)) 
    {
        // 将传入的参数和注册时填的参数合并，获取最终的构造函数的参数
        $params = $this->resolveDependencies($this->mergeParams($class, $params));
        // 调用函数获得实例
        $object = call_user_func($definition, $this, $params, $config);
    } 
    elseif (is_array($definition)) 
    {
        // $class可能是类名，也可能是别名
        // $concrete只能是类名
        $concrete = $definition['class'];
        unset($definition['class']);

        $config = array_merge($definition, $config);
        $params = $this->mergeParams($class, $params);

        if ($concrete === $class) 
        {
            // 如果二者相同，则直接创建实例
            $object = $this->build($class, $params, $config);
        } 
        else 
        {
            // 如果$class是别名，则传入类名递归
            $object = $this->get($concrete, $params, $config);
        }
    }
    // 如果直接给的是实例，则存为单例
    elseif (is_object($definition)) 
    {
        return $this->_singletons[$class] = $definition;
    } 
    else 
    {
        throw new InvalidConfigException('Unexpected object definition type: ' . gettype($definition));
    }
    // 存为单例
    if (array_key_exists($class, $this->_singletons)) 
    {
        $this->_singletons[$class] = $object;
    }

    return $object;
}

3 Instance TOP

\yii\di\Instance
用于存储Container中$class构造函数的参数，延迟实例化

$id, 组件id, 可以是类名，接口名，或者别名。

4 示例说明 TOP

该示例位于\yii\di\Container中

namespace app\models;

use yii\base\Object;
use yii\db\Connection;
use yii\di\Container;

interface UserFinderInterface
{
 function findUser();
}

class UserFinder extends Object implements UserFinderInterface
{
 public $db;

 public function __construct(Connection $db, $config = [])
 {
     $this->db = $db;
     parent::__construct($config);
 }

 public function findUser()
 {
 }
}

class UserLister extends Object
{
 public $finder;

 public function __construct(UserFinderInterface $finder, $config = [])
 {
     $this->finder = $finder;
     parent::__construct($config);
 }
}

$container = new Container;
// 注册方法1，类名+参数
$container->set('yii\db\Connection', [
 'dsn' => '...',
]);
// 注册方法2，接口名+类名
$container->set('app\models\UserFinderInterface', [
 'class' => 'app\models\UserFinder',
]);
// 注册方法3，别名+类名
$container->set('userLister', 'app\models\UserLister');
// 使用
$lister = $container->get('userLister');

TOP