Components¶

Einleitung¶

Komponenten (Components) sind Klassen, deren Funktionalität in mehreren Kontrollklassen (Controllers) genutzt werden kann. Wenn du dich dabei erwischt, wie du Funktionalität duplizierst, um sie in mehreren Kontrollklassen verwenden zu können, ist es vielleicht sinnvoller, diese Funktionalität in eine Komponente auszulagern.

CakePHP bietet außerdem eine fantastische Sammlung an Kern-Komponenten:

• Security

• Sessions

• Access control lists

• Emails

• Cookies

• Authentication

• Request handling

Die Nutzung dieser Kern-Komponenten wird in eigenen Kapiteln erklärt. Zunächst gehen wir aber darauf ein, wie man eigene Komponenten erstellt. Eigene Komponenten helfen dabei, den Code der Kontrollklassen sauber zu halten und oft verwendete Funktionalität wiederverwenden zu können.

Konfiguration von Komponenten¶

Viele der Kern-Komponenten müssen konfiguriert werden. Beispiele für Komponenten die konfiguriert werden müssen sind Auth, Cookie und Email. Die Konfiguration dieser und anderer Komponenten erfolgt meist in der beforeFilter() Methode deiner Kontrollklasse (Controller).

function beforeFilter() {
    $this->Auth->authorize = 'controller';
    $this->Auth->loginAction = array('controller' => 'users', 'action' => 'login');

    $this->Cookie->name = 'CookieMonster';
}

Der Code dient als Beispiel zur Konfiguration von Variablen der verwendeten Komponenten in der beforeFilter()> Methode einer Kontrollklasse.

Es ist jedoch möglich, dass eine Komponente bestimmte Konfigurationsoptionen benötigt bevor der beforeFilter-Callback des Controllers ausgeführt wird. Zu diesem zweck erlauben es einige Komponenten solche Optionen im $components-Array zu definieren.

var $components = array('DebugKit.toolbar' => array('panels' => array('history', 'session'));

Um herauszufinden welche Optionen eine Komponente bietet solltest du die jeweilige Dokumentation zu Rate ziehen.

Die Komponenten können beforeRender- und beforeRedirect-Callbacks besitzen, die vor dem Rendering bzw. vor einem Redirect (Weiterleitung) ausgeführt werden.

Man kann das Auslösen der Callbacks deaktivieren indem man die enabled-Eigenschaft der Komponente auf false setzt.

Component callbacks¶

Während Komponenten einerseits eine Möglichkeit bieten wiederverwendbaren Controller-Code, der bestimmte Aufgaben erfüllt zu erstellen bieten sie ausserdem noch eine Möglichkeit in den normalen Anwendungsablauf einzugreifen. Es gibt fünf fest eingebaute sogenannte Callbacks und es können auch weitere definiert werden indem man Component::triggerCallback verwendet.

Die Kern-Callbacks sind:

• initialize() wird vor beforeFilter des Controllers ausgeführt, aber nachdem das Model erstellt worden ist.

• startup() wird nach beforeFilter, aber vor der angeforderten action des Controllers ausgeführt.

• beforeRender() wird vor dem rendern des Views ausgeführt.

• beforeRedirect() wird vor einer Weiterleitung die vom Controller ausgelöst wird ausgeführt. Der Rückgabewert kann dazu verwendet werden um die URL zu der weitergeleitet werden soll zu ändern.

• shutdown() wird nach dem Rendern des Views und bevor die Antwort an den User zurückgegeben wird ausgeführt.

Man kann zusätzliche Methoden zu den Komponenten hinzufügen und diese jederzeit aufrufen indem man Component::triggerCallback() benutzt. Falls man zum Beispiel einen onAccess-Callback zu seinen Komponenten hinzugefügt hat, kann man diesen im Controller auslösen indem man $this->Component->triggerCallback('onAccess', $this); aufruft.

Das Auslösen der Callbacks kann verhindert werden indem man die enabled-Eigenschaft der Komponente auf false setzt.

Erstellen von eigenen Komponenten¶

Nehmen wir an, dass unsere Anwendung eine komplizierte Mathematische Berechnung in mehreren ganz unterschiedlichen Kontrollklassen (Controllers) durchführen muss. In einem solchen Fall ist es sinnvoll, diese Funktionalität in eine Komponente (Component) auszulagern, anstatt sie zu duplizieren.

Im ersten Schritt erstellen wir die Komponente. Die entsprechende Datei erstellen wir in /app/controllers/components/math.php. Die Klasse würde im einfachsten Fall wie folgt aussehen:

<?php

class MathComponent extends Object {
    function doComplexOperation($amount1, $amount2) {
        return $amount1 + $amount2;
    }
}

?>

/* Einbindung einer neuen "Math"-Komponente ($this->Math),
sowie der Kern-Methode "Session" ($this->Session) */
var $components = array('Math', 'Session');

var $components = array(
    'Math' => array(
            'precision' => 2,
            'randomGenerator' => 'srand'
        ),
    'Session', 'Auth'
);

<?php
    class CheckComponent extends Object {
        // Wird vor Controller::beforeFilter() ausgeführt
        function initialize(&$controller) {
            // Speichern der Referenz auf die Kontrollklasse
            $this->controller =& $controller;
        }

        // Wird nach Controller::beforeFilter() ausgeführt
        function startup(&$controller) {
        }

        function redirectSomewhere($value) {
            // Aufruf einer Kontrollklassen-Methode
            $this->controller->redirect($value);
        }
    }
?>

<?php
    class MyComponent extends Object {

        // Diese Komponente nutzt andere Komponenten
        var $components = array('Session', 'Math');

        function doStuff() {
            $result = $this->Math->doComplexOperation(1, 2);
            $this->Session->write('stuff', $result);
        }

    }
?>

<?php
    class MathComponent extends Object {
        function doComplexOperation($amount1, $amount2) {
            return $amount1 + $amount2;
        }

        function doUberComplexOperation ($amount1, $amount2) {
            $userInstance = ClassRegistry::init('User');
            $totalUsers = $userInstance->find('count');
            return ($amount1 + $amount2) / $totalUsers;
        }
    }
?>

<?php
class CustomComponent extends Object {
    var $name = 'Custom'; // the name of your component
    var $components = array('Existing'); // the other component your component uses

    function initialize(&$controller) {
        $this->Existing->foo();
    }

    function bar() {
        // ...
   }
}
?>

<?php
class ExistingComponent extends Object {
    var $name = 'Existing';

    function initialize(&$controller) {
        $this->Parent->bar();
    }

    function foo() {
        // ...
   }
}
?>