Komponente

Yii-Anwendungen bestehen aus Komponenten. Eine Komponente ist ein Objekt vom Typ CComponent (oder einere davon abgeleitete Klasse), das eine ganz bestimmte Aufgabe übernimmt. Meist greift man nur auf Eigenschaften von Komponenten zu oder reagiert auf deren Events bzw. löst diese aus. Die Basisklasse CComponent legt fest, wie man Eigenschaften und Events definiert.

1. Definieren und Verwenden von Eigenschaft ¶

Eine Eigenschaft einer Komponente verhält sich wie eine öffentliche Klassenvariable. Man kann Ihren Wert lesen oder ihr einen Wert zuweisen. Zum Beispiel:

$width=$component->textWidth;     // Liest die Eigenschaft textWidth
$component->enableCaching=true;   // Setzt die Eigenschaft enableCaching

Eine Eigenschaft kann daher einfach eine öffentliche Variable in der Klasse sein, die wie folgt definiert ist:

class Document extends CComponent
{
    public $textWidth;
}

Alternativ kann man aber auch, wesentlich flexiblere, Getter- und Setter-Methoden verwenden. Damit ist es möglich Eigenschaften zu erzeugen, die nur lesbar oder nur schreibbar sind. Wie das funktioniert sehen wir an folgendem Beispiel:

class Document extends CComponent
{
    private $_textWidth;
    protected $_completed=false;
 
    public function getTextWidth()
    {
        return $this->_textWidth;
    }
 
    public function setTextWidth($value)
    {
        $this->_textWidth=$value;
    }
 
    public function getTextHeight()
    {
        // berechnet die Texthöhe und gibt anschließend das Ergebnis zurück
    }
 
    public function setCompleted($value)
    {
        $this->_completed=$value;
    }
}

Die oben gezeigte Klasse kann nun wie folgt verwendet werden:

$document=new Document();
 
// Wir können die Eigenschaft textWidth lesen und schreiben
$document->textWidth=100;
echo $document->textWidth;
 
// Wir können textHeight nur lesend verwenden
echo $document->textHeight;
 
// Wir können auf die Eigenschaft completed nur schreibend zugreifen
$document->completed=true;

Beim Lesen einer Eigenschaft, die nicht als öffentliche Variable definiert ist, wird Yii versuchen eine Getter-Methode zu finden. Im Beispiel mit textWidth ist die zugehörige Getter-Methode getTextWidth. Als Wert der Eigenschaft gilt dann der Rückgabewert der Methode. Analog funktioniert das auch, wenn wir schreibend zugreifen wollen. In diesem Fall würde dann die Setter-Methode setTextWidth aufgerufen, der als Parameter der zu setzende Wert übergeben wird.

Wenn die Setter-Methode nicht definiert ist, ist die Eigenschaft nur lesbar und beim Schreiben würde eine Exception ausgelöst. Der Einsatz von Getter-/Setter-Methoden zum Definieren einer Eigenschaft hat den Vorteil, das beim Lesen und Schreiben zusätzliche Logik ausgeführt werden kann (z.B. Gültigkeitsprüfung durchführen, Events auslösen).

Hinweis: Es gibt einen kleinen Unterschied zwischen einer Eigenschaft, die durch Getter-/Setter-Methoden definiert wurde und einer Klassenvariable. Bei der ersteren spielt die Groß-/Kleinschreibung keine Rolle, bei letzerer schon.

2. Event ¶

Events (Ereignisse) sind spezielle Komponenteneigenschaften, die sog. Eventhandler-Methoden (sinngem.: Ereignisbearbeiter) als Wert erwarten. Hängt man eine Methode an ein Event an (engl.: attach), wird diese aufgerufen, sobald das Event ausgelöst wird. Auf diese Weise kann man das Verhalten einer Komponente nachträglich noch anpassen.

Ein Event wird definiert, indem man in einer Komponente eine Methode anlegt, deren Name mit on beginnt. Auch bei Eventnamen wird die Schreibweise (groß/klein) ignoriert. Das Event onClicked wird z.B. wie folgt definiert:

public function onClicked($event)
{
    $this->raiseEvent('onClicked', $event);
}

$event ist dabei eine Instanz vom Typ CEvent bzw. einer Kindklasse und stellt den Eventparameter dar.

Eine Methode kann wie folgt an ein Event angehägt werden:

$component->onClicked=$callback;

$callback muss eine gültige PHP-Callbackfunktion sein. Also entweder eine globale Funktion oder auch eine Klassenmethode. In letzterem Fall wird die Callbackfunktion als Array array($objekt,'methodenName') angegeben.

Die Signatur eines solchen Eventhandlers (also einer Funktion, die bei einem Event aufgerufen werden soll), muss wie folgt aussehen:

function methodenName($event)
{
    ......
}

wobei $event ein Parameter ist, der das Event näher beschreibt. Er stammt aus dem Aufruf von raiseEvent(). Der Eventparameter ist eine Instanz vom Typ CEvent oder einer Kindklasse. Er enthält mindestens die Information, wer das Event ausgelöst hat.

Ein Eventhandler kann auch eine anonyme Funktion sein, wie sie seit PHP 5.3 unterstützt werden. Zum Beispiel:

$component->onClicked=function($event) {
    ......
}

Ruft man nun onClicked() auf, wird darin das Event onClicked ausgelöst und der angehängte Eventhandler wird automatisch aufgerufen.

An ein Event können auch mehrere Handlermethoden angehängt sein. Beim Auslösen des Events werden die Handler in der selben Reihenfolge aufgerufen, in der sie an das Event angehängt wurden. Sollte in einer Handlermethode entschieden werden, dass die verbleibenden Handler für dieses Event nicht mehr ausgeführt werden sollen, kann darin $event->handled auf true gesetzt werden.

3. Behavior ¶

Seit Version 1.0.2 unterstützen Komponenten auch Mixins. An eine Komponente können damit ein oder mehrere Behaviors (Verhalten) angehägt werden. Die Komponente 'erbt' dann die Methoden des Behavior-Objekts. Allerdings nicht als Spezialisierung (normale Klassenvererbung) sondern im Sinne einer Ansammlung weiterer Funktionalitäten.

Behaviorklassen müssen das IBehavior-Interface implementieren. Die meisten Behaviors können von der Basisklasse CBehavior abgeleitet werden. Behaviors für ein Model können auch von den Klassen CFormBehavior oder CActiveRecordBehavior abgeleitet werden, die zusätzliche Features speziell für diese Models beinhalten.

Möchte man ein Behavior mit einer Komponente verwenden, muss es zunächst mit der attach()-Methode angehängt werden. Danach können die Behaviormethoden direkt über die Komponente aufgerufen werden.

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

Auf ein angehängtes Behavior kann wie auf eine normale Komponenteneigenschaft zugegriffen weden. Wurde z.B. ein Behavior namens tree mit einer Komponente verbunden, kann man das Behaviorobjekt wie folgt ansprechen:

$behavior=$component->tree;
// gleichbedeutend zu:
// $behavior=$component->asa('tree');

Ein Behavior kann vorübergehend deaktiviert werden, so dass seine Methoden nicht weiter über die Komponente zur Verfügung stehen. Zum Beispiel:

$component->disableBehavior($name);
// Die folgende Anweisung löst eine Exception aus
$component->test();
$component->enableBehavior($name);
// Jetzt funktioniert es wieder
$component->test();

Sollte eine Methode aufgerufen werden, die in zwei angehängten Behaviors vorhanden ist, wird die Methode des zuerst angehängten Behaviors aufgerufen.

Im Zusammenhang mit Events sind Behaviors noch wesentlich leistungsfähiger. Wenn ein Behavior an eine Komponente gehängt wird, kann es eine oder mehrere seiner Methoden an Events dieser Komponente anhängen. Dadurch kann kann das Behavior den normalen Prozessablauf innerhalb einer Komponente überwachen oder verändern.

Die Eigenschaften eines Behaviors können auch über die Komponente, an der es hängt, erreicht werden. Zugänglich sind alle öffentlichen Variablen bzw. Eigenschaften die mit Getter-/Setter-Methoden im Behavior definiert wurden. Falls ein Behavior zum Beispiel eine Eigenschaft namens xyz besitzt und an eine Komponente $a angebunden wurde, kann mit $a->xyz darauf zugegriffen werden.