Hoofdstuk 2. Zend_Controller
Terug |  | Volgende

## Hoofdstuk 2. Zend_Controller

## 2.1. Overzicht

### 2.1.1. Inleiding

De `Zend_Controller` verstrekt de basis om een website te bouwen volgens het Model-View-Controller (MVC) patroon.

Het `Zend_Controller` systeem is ontworpen om licht, moduleerbaar en uitbreidbaar te zijn. Het is een minimalistisch ontwerp om flexibiliteit en vrijheid aan de gebruikers te geven en tevens genoeg structuur te verstrekken zodanig dat alle systemen die rond `Zend_Controller` worden gebouwd dezelfde overeenkomsten en een gelijkaardige code lay-out delen.

Het `Zend_Controller` werkschema wordt door verschillende componenten geïmplementeerd. Hoewel het niet nodig is om volledig de details van al deze componenten te begrijpen om het systeem te gebruiken, kan een praktische kennis van de werkwijze zeer hulpvol zijn.

- `Zend_Controller_Front` orkestreert het gehele werkschema van het `Zend_Controller` systeem. Het is een interpretatie van het FrontController patroon. `Zend_Controller_Front` verwerkt alle door de server ontvangen aanvragen en is uiteindelijk verantwoordelijk voor het doorgeven van de aanvragen aan de ActionControllers (`Zend_Controller_Action`).

- `Zend_Controller_Router` is de router. Routing is het verwerken en opbreken van een URI eindbestemming om vast te stellen welke controller en welke actie van die controller het verzoek moet behandelen. Deze definitie van controller, actie en optionele parameters is verpakt in een waardeobject genaamd `Zend_Controller_Dispatcher_Token`. Dit wordt dan verwerkt door de `Zend_Controller_Dispatcher`. Routing gebeurt slechts één keer: wanneer het verzoek wordt ontvangen en voordat de eerste controller word gedispatched.

- `Zend_Controller_Dispatcher` is de dispatcher. Dispatching is het proces van het ontvangen van het `Zend_Controller_Dispatcher_Token`, het vinden van het toepassende controller bestand, het instantiëren van een controller klasse in dat bestand (moet `Zend_Controller_Action` implementeren), en uiteindelijk de actiemethode uitvoeren in dat controller object. In tegenstelling tot routing, dat maar eenmaal gebeurt, gebeurt dispatching in een lus. `Zend_Controller_Dispatcher` wordt herhaaldelijk opgeroepen door `Zend_Controller_Front` totdat alle acties in binnenkomende volgorde zijn gedispatched.

- `Zend_Controller_Action` is het basiscomponent van de controller. Elke controller is een alleenstaande klasse die de `Zend_Controller_Action class` uitbreidt, en deze klasse heeft actiemethodes.

Het werkschema van `Zend_Controller` is relatief eenvoudig. Een verzoek wordt ontvangen door `Zend_Controller_Front`, die op zijn beurt `Zend_Controller_Router` aanroept om vast te stellen welke controller (en actie in die controller) gedispatched wordt. `Zend_Controller_Router` breekt de URI op in een `Zend_Controller_Dispatcher_Token` object dat beschrijft waar te dispatchen. `Zend_Controller_Front` gaat dan in een dispatch lus. Het roept de `Zend_Controller_Dispatcher` op aan wie hij het token doorgeeft, om aan de uiteindelijke controller en actie te dispatchen. Nadat de controller dat gedaan heeft, gaat de controle terug naar `Zend_Controller_Front`. Indien de controller heeft aangeduid dat een andere controller gedispatched moet worden door een nieuw token terug te sturen gaat de lus verder en een andere dispatch wordt afgewerkt. Zo niet, dan is de verwerking afgelopen.

### 2.1.2. Route Process

Voordat je eerste controller kan gebouwd worden moet je begrijpen hoe het routing process werkt zoals het geïmplementeerd is in `Zend_Controller_Router`. Vergeet niet dat het werkschema opgedeeld is in routing, dat maar één keer gebeurt, en dispatching, dat daarna in een lus voorkomt.

`Zend_Controller_Front` roept `Zend_Controller_Router` aan om een URI naar een controller te mappen -- en een actie binnenin die controller. `Zend_Controller_Router` neemt de URI en breekt die op in een waardeobject, `Zend_Controller_Dispatcher_Token`, dat aan de dispatcher (`Zend_Controller_Dispatcher`) zal worden doorgegeven.

De router gebruikt een zeer eenvoudige mapping om de naam van de controller en de naam van de actie in de controller te determineren:

    http://framework.zend.com/controller/action/

Merk hierboven op dat het eerste segment altijd de naam van de controller is en het tweede segment altijd de naam van de actie is.

Parameters mogen eventueel worden gedefinieerd in de URI die aan de controller wordt doorgegeven. Deze nemen de vorm aan van key/waarde-paren:

    http://framework.zend.com/controller/action/key1/value1/

Indien er niets aanwezig is in het `/controller/` deel van de URI wordt deze "`index`". Indien er niets aanwezig is in het `/action/` deel van de URI, dan wordt dit ook een "`index`". Deze voorbeelden om dit te illustreren:

    http://framework.zend.com/roadmap/future/
    Controller: roadmap
    Action    : future

    http://framework.zend.com/roadmap/
    Controller: roadmap
    Action    : index

    http://framework.zend.com/
    Controller: index
    Action    : index

| Opmerking
Momenteel ontwikkelen we een nieuwe router met een URI herschrijvingsmotor die veel meer flexibiliteit aan de router zal geven dan nu het geval is. De nieuwe router zal aanwezig zijn in een preview versie in de nabije toekomst.

De controller naam, de actienaam binnenin die controller en alle optionele parameters zijn verpakt in een token, `Zend_Controller_Dispatcher_Token`. Dit token wordt teruggekeerd naar `Zend_Controller_Front`, die dan in de dispatch lus gaat. Eenmaal in de dispatch lus wordt het token aan de `Zend_Controller_Dispatcher` gegeven.

### 2.1.3. Dispatch Token

Het Dispatch Token is een eenvoudig waardeobject dat wordt doorgegeven tussen `Zend_Controller_Front` en klassen die de router en dispatcher interfaces implementeren. Het verenigd de definitie van een controller, een actie en de parameters die aan de actie moeten worden doorgegeven.

- De naam van de controller kan verkregen en gezet worden met `getControllerName()` en `setControllerName()`.

- De naam van de actie die moet worden opgeroepen binnenin die controller kan verkregen en gezet worden door `getActionName()` en `setActionName()`.

- Paremeters die aan de actie moeten worden doorgegeven zijn een associatieve array van key/waarden-paren die verkregen en gezet kunnen worden door `getParams()` en `setParams()`.

### 2.1.4. Dispatch Process

Dispatching is het process waarin een token, `Zend_Controller_Dispatcher_Token`, wordt genomen en de informatie die het bevat er wordt uitgehaald: een controllernaam, een actienaam en optionele parameters. Dan wordt de controller geïnstantieerd en de actie van die controller opgeroepen.

Terug |  | Volgende
1.8. Zend::registry() | Begin | 2.2. Om te beginnen