Concepts de base de la configuration Yii2

La configuration est largement utilisée pour créer de nouveaux objets ou initialiser des objets existants dans Yii. La configuration contient généralement le nom de classe de l'objet créé et un ensemble de propriétés à attribuer. l'objet. La valeur initiale, l'attribut ici est l'attribut de Yii2. Vous pouvez également lier des gestionnaires d'événements à des événements sur un objet ou attacher des comportements à l'objet. Ainsi, tout en définissant la valeur initiale de l'objet, les caractéristiques dynamiques de l'exécution de l'objet sont entièrement spécifiées.

La configuration dans le code suivant est utilisée pour créer et initialiser une connexion à une base de données :

$config = [    'class' => 'yii\db\Connection',    'dsn' => 'mysql:host=127.0.0.1;dbname=demo',   
 'username' => 'root',    'password' => '',    'charset' => 'utf8',
];$db = Yii::createObject($config);

Yii::createObject() est la méthode la plus couramment utilisée pour créer des objets dans Yii2. Le contenu est l'objet extrait du conteneur DI, dont nous parlerons dans les chapitres suivants. Cette méthode accepte un tableau de configuration et crée un objet basé sur le nom de classe spécifié dans le tableau. Une fois l'objet instancié, les paramètres restants sont utilisés pour initialiser les propriétés, les événements et les comportements de l'objet.

Rappel de l'éditeur : Dans Yii2.1, la valeur clé utilisée pour représenter le nom de la classe dans le tableau de configuration est passée de class à __class, mais le principe de configuration reste inchangé.

Pour un objet existant, vous pouvez utiliser la méthode Yii::configure() pour initialiser ses propriétés en fonction de la configuration, comme ceci :

Yii::configure($object, $config);

Veuillez noter que si vous configurez un Si l'objet existe déjà, le tableau de configuration ne doit pas contenir d'élément de classe avec le nom de classe spécifié.

La configuration est une fonctionnalité de Yii2

En programmation, il existe un concept très important appelé "suppression", c'est-à-dire qu'un objet A peut s'appuyer sur un autre objet B pour remplir une fonction spécifique. L'application typique est le modèle de stratégie. Pour implémenter la « délégation », il doit y avoir un tel processus : lorsque l'objet A est instancié, un autre objet B est injecté ; l'objet A délègue l'objet B pour accomplir une fonction spécifique ; « Injecter », « hold » et « déléguer » sont tous des mots très fréquents dans les modèles de conception. Grâce à ces opérations, les fonctions d'une classe peuvent être étendues.

Jetons un coup d'œil aux méthodes souvent utilisées dans d'autres langages orientés objet tels que Java ou PHP et d'autres frameworks :

class Person
{    private $strategy = null;    public function __construct(TravelStrategy $travel)
    {
        $this->strategy = $travel;
    }    /**
     * 设置旅行的方式.
     */
    public function setTravelStrategy(TravelStrategy $travel)
    {
        $this->strategy = $travel;
    }    /**
     * 旅行.
     */
    public function travel()
    {        //这里实现了“委托”，委托给$this->strategy来实现旅行的具体方式
        return $this->strategy->travelAlgorithm();
    }
}

Lors de l'instanciation ou de l'initialisation, c'est probablement ainsi il est utilisé :

class Test{
    public function run($argument)
    {
        // 乘坐火车旅行
        $person = new Person(new TrainStrategy());        $person->travel();        // 改骑自行车
        $person->setTravelStrategy(new BicycleStrategy());        $person->travel();
    }
}

Person est une personne qui souhaite voyager, il est titulaire d'une classe de mode de transport spécifique $strategy, et le voyage final est confié à ce mode de transport $strategy pour compléter - il s'agit d'une voiture, d'une visite autonome ou d'un vol. Lorsque vous l'utilisez, créez d'abord un nouvel objet et injectez un mode de transport dans le constructeur pour initialiser la méthode de déplacement, et je peux aussi temporairement décider de changer la méthode de déplacement via Person::setTravelStrategy - c'est le scénario d'application du modèle de stratégie.

Jetons un coup d'oeil à cette ligne :

$person = new Person(new TrainStrategy());

Tout le monde connaît cette façon d'écrire, n'est-ce pas ? En fait, cela complète une opération en deux étapes :

• instancie l'objet Person en utilisant new

• pour injecter une instance externe new TrainStrategy() et à $personInitialisation. Ce qui est injecté peut être une instance ou une constante.

Mais selon le style de Yii2, cela devrait être comme ceci :

class Person extends Component{    private $strategy = null;    /**
     * 旅行.
     */
    public function setTravelStrategy($travel)
    {        if (!($travel instanceof TravelStrategy)) {
            $travel = Yii::createObject($travel);
        }
        $this->strategy = $travel;
    }    /**
     * 旅行.
     */
    public function travel()
    {        
        return $this->strategy->travelAlgorithm();
    }
}

L'utilisation est à peu près comme ceci :

//用配置创建对象并初始化，选择火车出行
$person = Yii::createObject([    'class' => Person::class,
    'travelStrategy' => [        'class' => TrainStrategy::class
    ]
]);
$person->travel();//用配置重新初始化对象，改骑自行车
$person = Yii::configure($person, [    'travelStrategy' => [        'class' => BicycleStrategy::class
    ]
]);
$person->travel();

L'exemple ci-dessus devrait aider tout le monde à comprendre le rôle et l'utilisation de la configuration Yii2. La façon de créer des objets ne se fait pas via le mot-clé new, mais obtenu à partir du conteneur d'injection de dépendances (DI Container), dont nous parlerons plus tard.

Le framework Yii2 ne semble pas aimer utiliser des méthodes d'instanciation et d'initialisation « universelles ». Dans le framework Yii2, l'instanciation et l'initialisation d'objets sont presque toujours implémentées via la configuration. Il s'agit d'un style de Yii2. Bien sûr, ce style semble plus simple (à condition que vous le connaissiez déjà) et est plus pratique à utiliser. Bien que cela semble différent, c’est essentiellement le même, sauf qu’il existe quelques différences dans la manière d’injection.

Format de configuration

Le format d'une configuration peut être décrit comme la forme suivante :

[    'class' => 'ClassName',    'propertyName' => 'propertyValue',    'on eventName' => $eventHandler,    'as behaviorName' => $behaviorConfig,
]

où,

• élément de classe Spécifie le nom de classe complet de l'objet à créer (cela peut être réalisé en utilisant Object::class L'élément

• propertyName spécifie la valeur initiale du de l'objet). propriété inscriptible

• on L'élément eventName spécifie le gestionnaire attaché à l'événement objet. Veuillez noter que le nom de clé du tableau se compose du préfixe on et du nom de l'événement. Il ne peut y avoir qu'un seul espace entre on et le nom de l'événement

• car l'élément behaviorName spécifie le comportement attaché à l'objet. Notez que le nom de la clé du tableau se compose du préfixe as suivi du nom de la ligne. Il ne peut y avoir qu'un seul espace entre as et le nom de l'action. La valeur $behaviorConfig représente les informations de configuration pour le comportement de création, dans le même format que le format de configuration que nous avons décrit précédemment.

Ce qui suit est un exemple qui configure les valeurs des propriétés d'initialisation, les gestionnaires d'événements et les comportements :

[    'class' => 'app\components\SearchEngine',    'apiKey' => 'xxxxxxxx',    'on search' => function ($event) {
        Yii::info("搜索的关键词： " . $event->keyword);
    },    'as indexer' => [        'class' => 'app\components\IndexerBehavior',
        // ... 初始化属性值 ...
    ],
]

Principe de mise en œuvre de la configuration

Nous suivons Avec Cet accord, vous pouvez instancier et initialiser des objets via le tableau de configuration :

• implémente l'interface Configurable Tant que vous héritez de BaseObject ou Component, tout cela est satisfait - pas besoin de vous inquiéter <.>

• 子类重载__construct方法时，把配置数组放到构造器的最后一个参数：__construct($param1, $param2, ..., $config)

• 子类在自己的__construct最后，必须调用parent::__construct($config)方法

到底是如何实现的呢？这还得从BaseObject中说起，看看BaseObject的构造器：

public function __construct($config = []){
    if (!empty($config)) {
        Yii::configure($this, $config);
    }    $this->init();
}

我们知道Yii::configure是实现配置的。我们如果每个子类的__construct都按照上面的规范写，那么到最后无异会调用BaseObject::__construct,并且将子类的配置数组$config也传递过来，最终被Yii::configure使用。我们再看看这个方法：

// $object就是即将被配置的对象实例，$properties是配置数组public static function configure($object, $properties){
    //遍历每个参数，将其设置为属性，这里可能调用setter等方法
    foreach ($properties as $name => $value) {        $object->$name = $value;
    }    return $object;
}

这一句$object->$name = $value可能会发生很多故事，可能会调用Component::__setter或者BaseObject::__setter(参看我们前面讲属性，行为，事件的章节)

配置的应用

Yii 中的配置可以用在很多场景，除了我们上面举的例子，最常见的莫过于Yii最大的实例Application的配置了。Application堪称最复杂的配置之一了， 因为 Application 类拥有很多可配置的属性和事件。 更重要的是它的 yii\web\Application::components 属性也可以接收配置数组并通过应用注册为组件，配置中还可以有配置。 以下是一个针对基础应用模板的应用配置概要：

$config = [    'id' => 'basic',    'basePath' => dirname(__DIR__),    'extensions' => require(__DIR__ . '/../vendor/yiisoft/extensions.php'),    'components' => [        'cache' => [            'class' => 'yii\caching\FileCache',
        ],        'mailer' => [            'class' => 'yii\swiftmailer\Mailer',
        ],        'log' => [            'class' => 'yii\log\Dispatcher',            'traceLevel' => YII_DEBUG ? 3 : 0,            'targets' => [
                [                    'class' => 'yii\log\FileTarget',
                ],
            ],
        ],        'db' => [            'class' => 'yii\db\Connection',            'dsn' => 'mysql:host=localhost;dbname=stay2',            'username' => 'root',            'password' => '',            'charset' => 'utf8',
        ],
    ],
];

配置中没有 class 键的原因是这段配置应用在下面的入口脚本中， 类名已经指定了。

(new yii\web\Application($config))->run();

Application的配置中，比较重要的是components属性的配置了。在components里配置了的，都作为一个单例可以通过Yii::$app->component来访问；

另外，自版本 2.0.11 开始，系统配置支持使用 container 属性来配置依赖注入容器 例如：

$config = [    'id' => 'basic',    'basePath' => dirname(__DIR__),    'extensions' => require __DIR__ . '/../vendor/yiisoft/extensions.php',    'container' => [        'definitions' => [            'yii\widgets\LinkPager' => ['maxButtonCount' => 5]
        ],        'singletons' => [            // 依赖注入容器单例配置
        ]
    ]
];

我们这里重点阐述的是配置的原理，并不对Application做过多的配置，只是加深下大家对配置用法的印象而已，关于Application的配置我们以后会有讲到。

配置文件

当配置的内容十分复杂，通用做法是将其存储在一或多个 PHP 文件中， 这些文件被称为配置文件。一个配置文件返回的是 PHP 数组。 例如，像这样把应用配置信息存储在名为 web.php 的文件中：

return [    'id' => 'basic',    'basePath' => dirname(__DIR__),    'extensions' => require(__DIR__ . '/../vendor/yiisoft/extensions.php'),    'components' => require(__DIR__ . '/components.php'),
];

鉴于 components 配置也很复杂，上述代码把它们存储在单独的 components.php 文件中，并且包含在 web.php 里。 components.php 的内容如下：

return [    'cache' => [        'class' => 'yii\caching\FileCache',
    ],    'mailer' => [        'class' => 'yii\swiftmailer\Mailer',
    ],    'log' => [        'class' => 'yii\log\Dispatcher',        'traceLevel' => YII_DEBUG ? 3 : 0,        'targets' => [
            [                'class' => 'yii\log\FileTarget',
            ],
        ],
    ],    'db' => [        'class' => 'yii\db\Connection',        'dsn' => 'mysql:host=localhost;dbname=stay2',        'username' => 'root',        'password' => '',        'charset' => 'utf8',
    ],
];

如果数据库配置复杂了，你也可以单独拿出来——总之，简洁易维护就行。

仅仅需要 “require”，就可以取得一个配置文件的配置内容，像这样：

$config = require('path/to/web.php');(new yii\web\Application($config))->run();

默认配置

Yii::createObject() 方法基于依赖注入容器实现，你可以通过 Yii::creatObject() 创建对象时实现配置，同样也可以直接调用 Yii::$container->set() 来实现：

\Yii::$container->set('yii\widgets\LinkPager', [    'maxButtonCount' => 5,
]);

环境常量

配置经常会随着环境的更改而更改，有哪些环境呢？——生产，开发，测试。不同的环境可能会提供不同的组件，因此我们可以先定义不同的环境变量。

为了便于切换使用环境，Yii 提供了一个定义在入口脚本中的 YII_ENV 常量。 如下：

defined('YII_ENV') or define('YII_ENV', 'dev');

你可以把 YII_ENV 定义成以下任何一种值：

• prod：生产环境。常量 YII_ENV_PROD 将被看作 true，这是 YII_ENV 的默认值。

• dev：开发环境。常量 YII_ENV_DEV 将被看作 true。

• test：测试环境。常量 YII_ENV_TEST 将被看作 true。

有了这些环境常量，你就可以根据当下应用运行环境的不同，进行差异化配置。 例如，应用可以包含下述代码只在开发环境中开启 调试工具。

$config = [...];if (YII_ENV_DEV) {
    // 根据 `dev` 环境进行的配置调整
    $config['bootstrap'][] = 'debug';
    $config['modules']['debug'] = 'yii\debug\Module';
}return $config;

关于配置的东西，大概就是这么多了。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!