Grundkonzepte der Yii2-Konfiguration

Konfiguration wird häufig verwendet, um neue Objekte zu erstellen oder vorhandene Objekte in Yii zu initialisieren. Die Konfiguration enthält normalerweise den Klassennamen des erstellten Objekts und eine Reihe von Eigenschaften, denen es zugewiesen werden soll Das Objekt ist der Anfangswert, das Attribut ist hier das Attribut von Yii2. Sie können Ereignishandler auch an Ereignisse eines Objekts binden oder Verhaltensweisen an das Objekt anhängen. Somit werden bei der Definition des Anfangswerts des Objekts die dynamischen Eigenschaften der Laufzeit des Objekts vollständig spezifiziert.

Die Konfiguration im folgenden Code wird zum Erstellen und Initialisieren einer Datenbankverbindung verwendet:

$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() ist die am häufigsten verwendete Methode zum Erstellen von Objekten in Yii2 Der Inhalt ist das Objekt aus dem DI-Container, über das wir in den folgenden Kapiteln sprechen werden. Diese Methode akzeptiert ein Konfigurationsarray und erstellt ein Objekt basierend auf dem im Array angegebenen Klassennamen. Nachdem das Objekt instanziiert wurde, werden die verbleibenden Parameter zum Initialisieren der Eigenschaften, Ereignisse und Verhaltensweisen des Objekts verwendet.

Erinnerung des Herausgebers: In Yii2.1 hat sich der Schlüsselwert, der zur Darstellung des Klassennamens im Konfigurationsarray verwendet wird, von class in __class geändert, das Konfigurationsprinzip bleibt jedoch unverändert.

Für ein vorhandenes Objekt können Sie die Methode Yii::configure() verwenden, um seine Eigenschaften entsprechend der Konfiguration zu initialisieren, wie folgt:

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

Bitte beachten Sie, dass if Sie konfigurieren ein Wenn das Objekt bereits vorhanden ist, sollte das Konfigurationsarray kein Klassenelement mit dem angegebenen Klassennamen enthalten.

Konfiguration ist eine Funktion von Yii2

In der Programmierung gibt es ein sehr wichtiges Konzept namens „Löschen“, das heißt, ein Objekt A kann sich auf ein anderes Objekt B verlassen, um eine bestimmte Funktion auszuführen. Typischerweise ist die Anwendung das Strategiemuster. Um eine „Delegierung“ zu implementieren, muss es einen solchen Prozess geben: Wenn Objekt A instanziiert wird, wird ein anderes Objekt B injiziert; Objekt A delegiert Objekt B, um eine bestimmte Funktion auszuführen. „Inject“, „hold“ und „delegate“ sind allesamt hochfrequente Wörter in Entwurfsmustern. Durch diese Operationen können die Funktionen einer Klasse erweitert werden.

Werfen wir einen Blick auf die Methoden, die häufig in anderen objektorientierten Sprachen wie Java oder PHP und anderen Frameworks verwendet werden:

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();
    }
}

Beim Instanziieren oder Initialisieren ist dies wahrscheinlich der Fall Es wird verwendet:

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

Person ist eine Person, die reisen möchte, sie besitzt eine bestimmte Transportmittelklasse $strategy und die endgültige Reise wird diesem Transportmittel $strategy anvertraut - es ist Autofahren, selbstfahrende Tour oder Fliegen. Wenn Sie es verwenden, erstellen Sie zunächst ein neues Objekt und fügen Sie eine Transportmethode in den Konstruktor ein, um die Reisemethode zu initialisieren. Sie können die Reisemethode auch vorübergehend über Person::setTravelStrategy ändern - dies ist das Anwendungsszenario des Strategiemusters.

Schauen wir uns diese Zeile an:

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

Jeder kennt diese Schreibweise, oder? Tatsächlich ist damit ein zweistufiger Vorgang abgeschlossen:

• instanziiert das Objekt Person, indem mit new

• eine externe Instanz new TrainStrategy() eingefügt wird und zur $personInitialisierung. Was injiziert wird, kann eine Instanz oder eine Konstante sein.

Aber gemäß dem Stil von Yii2 sollte es so sein:

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();
    }
}

Die Verwendung ist ungefähr so:

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

Das obige Beispiel soll jedem helfen, die Rolle und Verwendung der Yii2-Konfiguration zu verstehen. Die Methode zum Erstellen von Objekten erfolgt nicht über das neue Schlüsselwort, sondern über den Abhängigkeitsinjektionscontainer (DI-Container), über den wir später sprechen werden.

Das Yii2-Framework scheint keine „universellen“ Instanziierungs- und Initialisierungsmethoden zu verwenden. Innerhalb des Yii2-Frameworks werden Objektinstanziierung und -initialisierung fast immer durch Konfiguration implementiert. Dies ist ein Stil von Yii2. Natürlich sieht dieser Stil einfacher aus (vorausgesetzt, Sie sind bereits damit vertraut) und ist bequemer zu verwenden. Obwohl es anders aussieht, ist es im Wesentlichen immer noch dasselbe, es gibt jedoch einige Unterschiede in der Art der Injektion.

Format der Konfiguration

Das Format einer Konfiguration kann wie folgt beschrieben werden:

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

wobei

• class-Element Gibt den vollständigen Klassennamen des zu erstellenden Objekts an (dies kann mit Object::class erreicht werden). Das

• propertyName-Element gibt den Anfangswert des beschreibbare Eigenschaft

on eventName-Element gibt den Handler an, der dem Objektereignis zugeordnet ist. Bitte beachten Sie, dass der Schlüsselname des Arrays aus dem On-Präfix und dem Ereignisnamen besteht. Zwischen on und dem Ereignisnamen
darf nur ein Leerzeichen stehen, da das BehaviorName-Element das mit dem Objekt verbundene Verhalten angibt. Beachten Sie, dass der Array-Schlüsselname aus dem Präfix as gefolgt vom Zeilennamen besteht. Zwischen as und dem Aktionsnamen darf nur ein Leerzeichen stehen. Der
• -Wert stellt die Konfigurationsinformationen für das Erstellungsverhalten im gleichen Format wie das zuvor beschriebene Konfigurationsformat dar.

  $behaviorConfig

Das Folgende ist ein Beispiel, das Initialisierungseigenschaftswerte, Ereignishandler und Verhaltensweisen konfiguriert:

Prinzip der Konfigurationsimplementierung

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

Wir folgen With Mit dieser Vereinbarung können Sie Objekte über das Konfigurationsarray instanziieren und initialisieren:

implementiert die konfigurierbare Schnittstelle. Solange Sie BaseObject oder Component erben, ist dies alles erfüllt – kein Grund zur Sorge

• 子类重载__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;

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

Das obige ist der detaillierte Inhalt vonGrundkonzepte der Yii2-Konfiguration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!