Etat de l'objet dans le modèle de conception de la méthode Template

Question

Voici un exemple d'implémentation de l'algorigthm dans la classe absctract de base issue de http://sourcemaking.com. / design_patterns / template_method / php

public final function showBookTitleInfo($book_in) {
    $title = $book_in->getTitle();
    $author = $book_in->getAuthor();
    $processedTitle = $this->processTitle($title);
    $processedAuthor = $this->processAuthor($author);
    if (NULL == $processedAuthor) {
        $processed_info = $processedTitle;
    } else {
        $processed_info = $processedTitle.' by '.$processedAuthor;
    }
    return $processed_info;
}

Je n'aime pas cela parce que je pense que "showBookTitleInfo". en sait trop sur les méthodes qu'il appelle.

Voici un autre exemple     classe abstraite template_method {         var $ state;         fonction publique __construct () {             $ this- > state = 0;         }

    public function processEvent( $event ) {
        $this->doFirstStep( $event );
        $this->doSecondStep( $event );
    }
    abstract public function doFirstStep( &$event );
    abstract public function doSecondStep( &$event );
}

class CustomLogic extends template_method {
    public function doFirstStep( &$event ) {
        echo __METHOD__.": state: ".$this->state." event: $event\n";
        $this->state++;
    }
    public function doSecondStep( &$event ) {
        echo __METHOD__.": state: ".$this->state." event: $event\n";
        $this->state++;
    }
}

pourquoi nous passons l’événement en référence, si nous ne changeons pas sa valeur? Comment dois-je mettre en œuvre "mes étapes" la logique, s’ils utilisent l’état en cours, peut modifier sa valeur et d’autres étapes peuvent lire la valeur modifiée et la modifier aussi?

Par exemple, je souhaite implémenter un mécanisme de comptage des coûts pour l’envoi programmé de messages - simple et récurrent (ex: tous les lundis, vendredis et vendredis jusqu'au 23.05.2009).

J'ai donc implémenté l'algorithme en classe abstraite comme suit:

abstract class AbstractCostCounter {
    public function countNotReccurentSendingCost($messageObj) {
        $totalMessages = $messageObj->getTotalMessages(); // multiple recipients are allowed
        $message_cost = 1; // just to give you an idea
        $this->cost = $totalMessages * $message_cost;
    }
    abstract public function countOptional();

    // I pass $messageObject not as by-reference, because it hasn't to be modified
    public function countCost( $messageObject ) {
        $this->countNotReccurentSendingCost( $messageObject );
        $this->countOptional( $messageObject );
    }

}

class TemplateNotReccurentCostCounting {
    public function countOptional($messageObj) {
        // do nothing
    }
}

class TemplateReccurentCostCounting {
    public function countOptional($messageObj) {
        $notReccurentSendingCost = $this->cost;
        $totalMessagesInScheduledPlan = $messageObj->getTotalMessagesInScheduledPlan();
        $reccurentSendingPlanCost = $notReccurentSendingCost * $totalMessagesInScheduledPlan;
        $this->cost = $reccurentSendingPlanCost;
    }
}

Est-ce que je vais dans la bonne direction? Est-ce là que le modèle de conception de la méthode Template doit être mis en œuvre? Faites-le moi savoir, s'il y a quelque chose qui ne va pas avec ce code.

P.S. compteur de coûts n'est pas un code de production. Je l'ai écrit parce que je voulais vous donner une idée.

Merci d'avance

Answer 1

Le modèle de méthode template donne beaucoup de contrôle à la classe parent. La classe parent doit en savoir beaucoup sur les méthodes abstraites (leur signature) car elle doit "contrôler" l'algorithme. BTW, la méthode concrète dans la classe parente doit être finale.

Vous n’avez aucun avantage avec vos méthodes firstStep secondStep, je pourrais implémenter ce que je veux dans stepOne et ne rien faire dans stepTwo ...

La question est de savoir quand voulez-vous utiliser le modèle de modèle, et non pas comment le réécrire pour plus de flexibilité:)