Verwenden von Erweiterungen

Um eine Erweiterung (engl.: Extension) einzusetzen, sind normalerweise folgende Schritte erforderlich:

1. Erweiterung aus dem Extension repository von Yii herunterladen
2. Ins Unterverzeichnis extensions/xyz des Anwendungsverzeichnisses entpacken, wobei xyz für den Namen der Erweiterung steht.
3. Importieren, Konfigurieren und Verwenden der Erweiterung

Jede Erweiterung hat einen eindeutigen Namen, um sie klar von anderen Erweiterungen zu unterscheiden. Heißt eine Erweiterung xyz, kann man über den Pfadalias ext.xyz von überallher auf Dateien dieser Erweiterung zugreifen.

Jede Erweiterung muss anders importiert, konfiguriert bzw. angewendet werden. Wir zeigen hier einige typische Anwendungsfälle für die in der Übersicht beschriebenen Kategorien.

1. Zii Erweiterungen ¶

Bevor wir auf andere Erweiterungen eingehen, möchten wir an dieser Stelle kurz die Zii-Erweiterungsbibliothek vorstellen. Dabei handelt es sich um eine Reihe von Erweiterungen, die vom Yii-Entwicklerteam erstellt wurden und die seit Version 1.1.0 in jedem Release enthalten sind.

Um eine Zii-Erweiterung zu verwenden, muss die entsprechende Klasse mit einem Pfadalias der Form zii.pfad.zur.Klasse referenziert werden. Der Rootalias zii wird hierbei von Yii bereits vorbelegt. Er bezieht sich auf das Basisverzeichnis der Zii-Bibliothek. Ein CGridView würde man z.B. so einsetzen:

$this->widget('zii.widgets.grid.CGridView', array(
    'dataProvider'=>$dataProvider,
));

2. Anwendungskomponente ¶

Um eine Anwendungskomponente zu verwenden, muss in der Konfiguration ein Eintrag in der components-Eigenschaft hinzugefügt werden:

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

Nun kann in der gesamten Anwendung mit Yii::app()->xyz auf die Komponente zugegriffen werden. Sie wird lazy ("faul", also beim ersten Zugriff darauf) erzeugt, es sei denn, sie wird in der Eigenschaft preload aufgeführt.

3. Behavior ¶

Behavior können mit allen möglichen Komponenten verwendet werden. Dazu muss das Behavior zunächst an die gewünschte Komponente angebunden werden. Danach kann man Behaviormethoden über die Komponente aufrufen:

// $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, wie hier am Beispiel einer Anwendungskomponente gezeigt:

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

Damit wird das Behavoir xyz and die db-Komponente angebunden. Dies wird durch Eigenschaft behaviors mögliche, die in CApplicationComponent definiert ist. Übergibt man in dieser Eigenschaft eine Liste von Behaviorkonfigurationen, bindet die Komponente die entsprechenden Behaviors beim Initialisieren an.

Da CController-, CFormModel- und CActiveModel-Klassen in der Regel erweitert werden müssen, können Behavior dort durch Überschreiben der behaviors()-Methode angebunden werden. Beim Initialisieren hängt die Klasse dann die darin definierten Behaviors automatisch an:

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

4. 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 mit eingebettetem Inhalt:
<?php $this->beginWidget('ext.xyz.XyzClass', array(
    'property1'=>'value1',
    'property2'=>'value2')); ?>
 
...Eingebetteter Inhalt des Widgets...
 
<?php $this->endWidget(); ?>

5. Action ¶

Mit Actions reagiert ein Controller auf Requests. Um eine Actionklasse XyzClass aus der Erweiterung xyz in einem Controller zu verwenden, überschreibt man in diesem die Methode CController::actions:

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.

6. Filter ¶

Filter werden ebenfalls von einem Controller verwendet. Sie übernehmen hauptsächlich die Vor- und Nachbearbeitung eines User-Requests, wenn dieser von einer Action behandelt wird. Um eine Filterklasse XyzClass aus der Erweiterung xyz in einem Controller zu verwenden, überschreibt man die Methode CController::filters:

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

Man kann hierbei auch Plus- und Minusoperatoren verwenden, um den Filter nur auf bestimmte Actions anzuwenden. Näheres hierzu finden Sie in der Dokumentation von CController.

7. Controller ¶

Ein Controller stellt eine Reihe von Actions bereit, die von Benutzern aufgerufen werden können. Um eine Controllererweiterung zu verwenden, muss man 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.

8. Validator ¶

Validatoren werden hauptsächlich in Modelklassen (also Ablegern von CFormModel oder CActiveRecord) verwendet. Um einen Validator XyzClass aus der Erweiterung xyz einzusetzen, überschreibt man in der abgeleiteten Modelklasse 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
        );
    }
}

9. Konsolenbefehl ¶

Eine Konsolenerweiterung fügt dem yiic-Befehl in der Regel ein weiteres Kommando hinzu. Indem man die Konfiguration der Konslenanwendung anpasst, kann man dann z.B. den Befehl XyzClass aus der Erweiterung xyz verwenden:

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

Für den yiic-Befehl steht nun das Kommand xyz zur Verfügung.

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 in protected/yiic in protected/config/console.php, die der Webanwendung in protected/config/main.php.

10. Module ¶

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

11. Allgemeine Komponenten ¶

Um eine allgemeine Komponente einzusetzen, muss zunächst die Klassendatei eingebunden werden:

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

Danach kann man entweder eine Instanz dieser Klasse erzeugen, Eigenschaften belegen und Methoden aufrufen. Oder man kann die Klasse erweitern und neue Kindklassen davon erstellen.