Zend FR

ok, sinon pour revenir au sujet principal j'ai du mal a bien voir la différence entre controller et service.
Quoi mettre dans l'un et dans l'autre et surtout comment faire cette couche service.
Un petit exemple de code serait bienvenue merci.

Dernière modification par Moimeme (22-07-2010 15:25:59)

Bonjour,

lil-works a écrit:

Du coup je fais comme ça

Code:

class Tight_Controller_Action extends Zend_Controller_Action
{
    public function init()
    {
        $di = $this->_helper->getHelper('Di');
    }
}

Es la bonne methode?

Merci et bonne journée

Tu fais comme ça ? c'est à dire ? Pour faire quoi ?

Tu ne devrais pas implémenter de classe Tight_Controller_Action. Le helper Di n'est utilisé que pour injecter dynamiquement et récursivement les dépendances (comprendre "les classes utilisées par") de ton contrôleur.

L'idée toute simple derrière l'injection de dépendances est qu'au lieu de créer des dépendances en dur dans le code, de cette manière :

public function doSomethingAction()
{
    $user = new Model_User();
    $user->firstname = 'Benjamin';
    
    $userService = new Service_User();
    $userService->createUser($user);
}

public function doSomethingElseAction()
{
    $userService = new Service_User();
    $user = $userService->getUserByLogin('Delprog');
    
    $this->view->user = $user;
}

On injecte la dépendance dans le contrôleur directement :

protected $_userService;

public function setUserService(Service_User $userService)
{
    $this->_userService = $userService;
}

public function doSomethingAction()
{
    $user = new Model_User();
    $user->firstname = 'Benjamin';
    
    $this->_userService->createUser($user);
}

public function doSomethingElseAction()
{
    $user = $this->_userService->getUserByLogin('Delprog');
    
    $this->view->user = $user;
}

Voilà, j'ai fait de l'inversion de contrôle
On voit tout de suite que c'est beaucoup plus flexible, parce que je n'aurais pas des dizaines de dépendances créées en dur (avec new) un peu partout dans mon application.

L'injection de dépendances quand à elle consiste à injecter la dépendance au runtime, dynamiquement, en s'appuyant sur la configuration de l'utilisateur. C'est à ça que sert le helper Di, tu n'as pas à le manipuler directement. Le helper va récupérer le conteneur de dépendances (ici Tight_Di), et lui demande d'injecter récursivement toutes les dépendances en partant du contrôleur courant.

De cette façon, si je veux changer l'implémentation de mon service Service_User qui doit être utilisée c'est très facile. Je n'ai qu'à le changer dans la configuration de mon conteneur de dépendances (DIC).

<?xml version="1.0" encoding="UTF-8"?>
<components>
    <component id="indexController" class="IndexController">
        <property name="userService" ref="userService" />
    </component>

    <component id="userService" class="Service_Impl_User">
</components>

Grâce à l'IOC et l'injection de dépendances, je peux changer très facilement les classes utilisées par d'autres classes, et sans toucher une seule ligne de code.

Soit dit en passant, utiliser un helper est un peu "sale", mais c'est bien plus simple que de modifier le Front controller de ZF pour faire ça au moment de l'instanciation du contrôleur d'actions. En fait l'utilisation de l'IOC dans ZF est biaisée parce que le framework n'est pas du tout pensé pour ça. Si c'était le cas, tout passerait par un conteneur de dépendances. Au moins, avec cette solution, tu peux utiliser le concept pour tes propres classes, et rendre plus flexible la partie de l'application que tu maitrises.

Pour plus d'informations je t'invite à lire ce billet : http://code.anonymation.com/zend-framew … plication/

Le principe est vraiment très simple, j'imagine que c'est surtout que tu dois te mélanger un peu les pinceaux avec toutes les informations qui te sont données d'un coup dans ce topic.


A+ benjamin.

Bonsoir,

Oui c'est dans le bootstrap, il faut ajouter le helper dans le gestionnaire de helpers (broker), par exemple :

protected function _initHelpers()
{        
    Zend_Controller_Action_HelperBroker::addHelper(new Tight_Controller_Action_Helper_Di());
}

Ensuite tu n'as rien d'autre à faire, sachant que tu peux désactiver le helper pour certains contrôleurs si tu n'en as pas besoin :

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        $this->_helper->getHelper('Di')->disable();
    }

    //...
}

A+ benjamin

Hello,

Oui il s'agit d'une horrible erreur que je n'avais pas vu (copier/coller) parce que je n'ai jamais désactivé le helper haha

C'est bien:

    /**
     * Disable IOC
     * To be called from action controllers
     */
    public function disable()
    {        
        $this->_enabled = false;
    }

Ça m'apprendra à ne pas couvrir tout le code par des tests unitaires

A+ benjamin.

Pour ma part, le dépendances sont chargées dans le bootstrap de cette manière

protected function _initHelpers()
    {        
        Zend_Controller_Action_HelperBroker::addHelper(new Tight_Controller_Action_Helper_Di());
    }

Cependant, après la desactivation dans l'init d'un controller les dépendances sont deja chargée et le ->disable() est sans effet

Merci de cette precision

Maintenant j'essai d'implementer le lazy loding:

Mais comment mettre en place le "Lazy-load" si les objets ne doivent rien connaitre de la persistance ? J'ai décidé d'utiliser le pattern Proxy.

Est-il possible d'avoir un exemple?

<component id="mapper" class="Model_Db_Mapper">
        <property name="db" ref="db" />
        <property name="template" ref="modeltemplate" />
    </component>

J'ai beaucoup de mal à voire ce que doit contenir la classe Model_Db_Mapper Et-il possible d'avoir le code de cette classe?
Cette classe doit elle étendre Tight_Model_Db_Mapper?