Erweiterungen verwenden

Zum Einsatz einer Erweiterung (engl.: Extension) sind in der Regel folgende drei Schritte erforderlich:

1. Die Erweiterung aus dem Extension repository von Yii herunterladen
2. Die Erweiterung im Stammverzeichnis der Anwendung in ein Unterverzeichnis extensions/xyz entpacken, wobei xyz der Name der Erweiterung ist.
3. Importieren, Konfigurieren und Verwenden der Erweiterung

Jede Erweiterung hat einen eindeutigen Namen, um sie klar von anderen Erweiterungen zu unterscheiden. Im Falle der Erweiterung namens xyz können wir überall den Pfad-Alias ext.xyz verwenden, um das Basisverzeichnis mit allen Dateien von xyz anzusprechen.

Hinweis: Der RootAlias ext steht seit Version 1.0.8 zur Verfügung. Vorher mussten wir ext für das Erweiterungsverzeichnis verwenden. Im folgenden gehen wir davon aus, dass ext zur Verfügung steht. Sie müssen es durch ext ersetzen, falls Sie Version 1.0.7 oder kleiner verwenden.

Jede Erweiterung stellt andere Anforderungen an die Art und Weise wie sie importiert, konfiguriert und angewendet wird. Entsprechend den bereits in der Übersicht beschriebenen Kategorien bieten wir im folgenden einen Überblick der gängigsten Anwendungsszenarien von Erweiterungen.

1. Anwendungskomponente ¶

Um eine Komponente zu verwenden, müssen wir erst die Konfiguration der Anwendung anpassen. Dazu fügen wir einen neuen Eintrag zu deren Eigenschaft components wie folgt hinzu:

return array(
    // 'preload'=>array('xyz',...),
    'components'=>array(
        'xyz'=>array(
            'class'=>'ext.xyz.XyzClass',
            'property1'=>'value1',
            'property2'=>'value2',
        ),
        // Andere Konfigurationen für Komponenten
    ),
);

Danach können wir von jeder Stelle aus über Yii::app()->xyz auf die Komponente zugreifen. Die Komponente wird lazy (faul) erzeugt, also erst dann, wenn zum ersten mal auf sie zugegriffen wird), außer, wir führen sie in der Eigenschaft preload auf.

2. Behavior ¶

Behavior können mit allen möglichen Komponenten verwendet werden. Dies erfordert zwei Schritte. Zunächst wird das Behavior an die gewünschte Komponente angebunden. Danach wird eine Behaviormethode über die Komponente aufgerufen. Zum Beispiel:

// $name ist ein eindeutiger Bezeichner des Behaviors in der Komponente
$component->attachBehavior($name,$behavior);
// test() ist eine Methode des Behaviors
$component->test();

Statt über die attachBehavior-Methode wird ein Behavior in der Regel meist per Konfiguration an eine Komponente angebunden. Der folgende Konfigurationsausschnitt würde z.B. ein Behavior an eine Applikationskomponente anbinden:

return array(
    'components'=>array(
        'db'=>array(
            'class'=>'CDbConnection',
            'behaviors'=>array(
                'xyz'=>array(
                    'class'=>'ext.xyz.XyzBehavior',
                    'property1'=>'value1',
                    'property2'=>'value2',
                ),
            ),
        ),
        //....
    ),
);

Dieser Code bindet das Behavoir xyz and die db-Komponente der Anwendung an. Dies wird durch die in CApplicationComponent definierte Eigenschaft behaviors ermöglicht. Indem wir in dieser Eigenschaft eine Liste von Behaviorkonfigurationen übergeben, bindet die Komponente die entsprechenden Behaviors beim Initialisieren an.

Bei CController-, CFormModel- and CActiveModel-Klassen, die in der Regel erweitert werden, werden Behavior durch Überschreiben der behaviors()-Methode angebunden. Zum Beispiel:

public function behaviors()
{
    return array(
        'xyz'=>array(
            'class'=>'ext.xyz.XyzBehavior',
            'property1'=>'value1',
            'property2'=>'value2',
        ),
    );
}

3. Widget ¶

Widgets werden hauptsächlich in Views verwendet. Eine Widget-Klasse XyzClass aus der xyz-Erweiterung kann im View wie folgt verwendet werden:

// Widget ohne eingebetteten Inhalt
<?php $this->widget('ext.xyz.XyzClass', array(
    'property1'=>'value1',
    'property2'=>'value2')); ?>
 
// Widget, das eingebetteten Inhalt enthalten kann
<?php $this->beginWidget('ext.xyz.XyzClass', array(
    'property1'=>'value1',
    'property2'=>'value2')); ?>
 
...Eingebetteter Inhalt des Widgets...
 
<?php $this->endWidget(); ?>

4. Action ¶

Actions werden von einem Controller verwendet, um auf spezifische Benutzer-Requests zu antworten. Eine Action-Klasse XyzClass aus der xyz-Erweiterung kann in unserer Controller-Klasse verwendet werden, indem wir dort die Methode CController::actions überschreiben:

class TestController extends CController
{
    public function actions()
    {
        return array(
            'xyz'=>array(
                'class'=>'ext.xyz.XyzClass',
                'property1'=>'value1',
                'property2'=>'value2',
            ),
            // Andere Actions
        );
    }
}

Die Action kann dann über die Route test/xyz aufgerufen werden.

5. Filter ¶

Filter werden ebenfalls von einem Controller verwendet. Sie übernehmen hauptsächlich die Vor- und Nachbearbeitung eines User-Requests, wenn dieser von einer Action bearbeitet wird. Eine Filter-Klasse XyzClass aus der Erweiterung xyz könnnen wir in unserer Controller-Klasse verwenden, indem wir deren Methode CController::filters überschreiben:

class TestController extends CController
{
    public function filters()
    {
        return array(
            array(
                'ext.xyz.XyzClass',
                'property1'=>'value1',
                'property2'=>'value2',
            ),
            // Andere Filter
        );
    }
}

In obigem Beispiel können wir beim ersten Arrayelement Plus- und Minusoperatoren verwenden, um den Filter nur auf bestimmte Actions anzuwenden. Nähere Informationen hierzu finden Sie in der Dokumentation von CController.

6. Controller ¶

Ein Controller stellt eine Reihe von Actions bereit, die von einem Benutzer aufgerufen werden können. Um eine Controller-Erweiterung zu verwenden, müssen wir in der Anwendungskonfiguration die Eigenschaft CWebApplication::controllerMap anpassen:

return array(
    'controllerMap'=>array(
        'xyz'=>array(
            'class'=>'ext.xyz.XyzClass',
            'property1'=>'value1',
            'property2'=>'value2',
        ),
        // Andere Controller
    ),
);

Eine Action a in diesem Controller kann dann über die Route xyz/a aufgerufen werden.

7. Validator ¶

Ein Validator wird hauptsächlich in einer Model-Klasse (also einer von CFormModel oder CActiveRecord abgeleiteten Klasse) verwendet. Um einen Validator XyzClass aus der Erweiterung xyz einzusetzen, überschreiben wir in unserer Model-Klasse die Methode CModel::rules:

class MyModel extends CActiveRecord // oder CFormModel
{
    public function rules()
    {
        return array(
            array(
                'attr1, attr2',
                'ext.xyz.XyzClass',
                'property1'=>'value1',
                'property2'=>'value2',
            ),
            // Andere Prüfregeln
        );
    }
}

8. Konsolenbefehl ¶

Eine Erweiterung mit einem Konsolenbefehl fügt in der Regel dem yiic-Befehl ein weiteres Kommando hinzu. Den Konsolenbefehl XyzClass aus der Erweiterung xyz können wir über die Anpassung der Konfiguration für Konsolenanwendungen verwenden:

return array(
    'commandMap'=>array(
        'xyz'=>array(
            'class'=>'ext.xyz.XyzClass',
            'property1'=>'value1',
            'property2'=>'value2',
        ),
        // Andere Kommandos
    ),
);

Damit haben wir den yiic-Befehl mit einem weiteren Kommando xyz ausgestattet.

Hinweis: Eine Konsolenanwendung verwendet normalerweise eine andere Konfigurationsdatei als die Webanwendung. Wenn eine Applikation mit dem Befehl yiic webapp erstellt wurde, liegt die Konfigurationsdatei für die Konsolenanwendung protected/yiic in protected/config/console.php, während die Konfigurationsdatei für die Webanwendung in protected/config/main.php liegt.

9. Module ¶

Bitte beachten Sie das Kapitel über Module, um mehr über den Einsatz von Modulen zu erfahren.

10. Allgemeine Komponenten ¶

Um eine allgemeine Komponente einzusetzen, müssen wir zunächst deren Klassendatei wie folgt einbinden:

Yii::import('ext.xyz.XyzClass');

Wir können dann entweder eine Instanz von dieser Klasse erzeugen, ihre Eigenschaften konfigurieren oder ihre Methoden aufrufen. Möglicherweise möchten wir sie auch erweitern, um neue Kindklassen zu erstellen.