Modèles de conception Le modèle Observer

Maintenant, je viens avec un autre modèle de conception comportemental dans cette série, qui est le modèle Observer. Observateur signifie que quelqu'un regarde votre activité et qu'il est possible que l'observateur prenne des mesures en fonction de votre activité..

Le même concept est également applicable au motif de conception. Nous devrions implémenter ce modèle lorsque nous avons une dépendance d'un à plusieurs entre notre objet et qu'un objet doit être modifié / notifié lorsque des modifications sont apportées à un autre objet..

Wikipedia dit la même chose dans les mots ci-dessous:

Le modèle d'observateur est un modèle de conception logicielle dans lequel un objet, appelé sujet, maintient une liste de ses dépendants, appelés observateurs, et les informe automatiquement de tout changement d'état, généralement en appelant l'une de leurs méthodes. Il est principalement utilisé pour mettre en œuvre des systèmes de gestion d'événements distribués. Le modèle Observer est également un élément clé du modèle architectural bien connu modèle-vue-contrôleur (MVC).

Pour en savoir plus sur ce modèle, je prend l'exemple d'un simulateur qui montre la valeur de différentes devises par rapport au dollar américain. Nous supposons que le simulateur indique le prix et met également à jour le prix à intervalles réguliers.

Avant de commencer, définissons les responsabilités de la classe de simulateur principal (qui se comporte comme un observateur dans cet exemple)..

Cet observateur devrait avoir la possibilité d'ajouter une nouvelle devise, de sorte que le client puisse ajouter autant de devises qu'il le souhaite..
Cet observateur devrait conserver la référence à toutes les devises ajoutées.
Cet observateur doit indiquer le statut / la valeur de chaque devise enregistrée..

Dans la section suivante, nous allons implémenter notre observateur:

interface Observer fonction publique addCurrency (Currency $ currency);  class priceSimulator implémente les devises Observer private $; fonction publique __construct () $ this-> currency = array ();  fonction publique addCurrency (Currency $ currency) array_push ($ this-> monnaies, $ currency);  fonction publique updatePrice () foreach ($ this-> monnaies en tant que $ currency) $ currency-> update ();

Si vous regardez le code ci-dessus, vous pouvez voir qu'il a la capacité d'assumer toutes les responsabilités mentionnées dans la section précédente..

Nous avons maintenant notre observateur prêt. Ce dont nous avons besoin maintenant, ce sont quelques devises différentes que nous pouvons ajouter à cet observateur, puis nous sommes prêts à partir. Implémentons maintenant nos classes de devises.

interface Currency public function update (); fonction publique getPrice ();  La classe Pound implémente Currency private $ price; fonction publique __construct ($ price) $ this-> price = $ price; écho "Prix d'origine Pound: $ price
"; public function update () $ this-> price = $ this-> getPrice (); echo"Prix mis à jour: $ this-> price
"; fonction publique getPrice () return f_rand (0.65, 0.71); la classe Yen implémente la devise private $ price; fonction publique __construct ($ price) $ this-> price = $ price; echo"Prix d'origine Yen: $ price
"; public function update () $ this-> price = $ this-> getPrice (); echo"Yen Mis à jour Prix: $ this-> price
"; fonction publique getPrice () return f_rand (120.52, 122.50);

Nous sommes tous prêts à tout mettre en place et à diriger notre observateur.

Mettre tous ensemble

interface Observer fonction publique addCurrency (Currency $ currency);  class priceSimulator implémente les devises Observer private $; fonction publique __construct () $ this-> currency = array ();  fonction publique addCurrency (Currency $ currency) array_push ($ this-> monnaies, $ currency);  fonction publique updatePrice () foreach ($ this-> monnaies en tant que $ currency) $ currency-> update ();  interface Currency public function update (); fonction publique getPrice ();  La classe Pound implémente Currency private $ price; fonction publique __construct ($ price) $ this-> price = $ price; écho "Prix d'origine Pound: $ price
"; public function update () $ this-> price = $ this-> getPrice (); echo"Prix mis à jour: $ this-> price
"; fonction publique getPrice () return f_rand (0.65, 0.71); la classe Yen implémente la devise private $ price; fonction publique __construct ($ price) $ this-> price = $ price; echo"Prix d'origine Yen: $ price
"; public function update () $ this-> price = $ this-> getPrice (); echo"Yen Mis à jour Prix: $ this-> price
"; public function getPrice () return f_rand (120.52, 122.50); function f_rand ($ min = 0, $ max = 1, $ mul = 1000000) if ($ min> $ max) renvoie false; retour mt_rand ($ min * $ mul, $ max * $ mul) / $ mul; $ priceSimulator = nouveau simulateur de prix (); $ currency1 = nouvelle livre (0.60); $ currency2 = nouveau Yen (122); $ priceSimulator-> addCurrency ($ currency1); $ priceSimulator-> addCurrency ($ currency2); echo "
"; $ priceSimulator-> updatePrice (); echo"
"; $ priceSimulator-> updatePrice ();

Le code ci-dessus affichera:

Prix d'origine: 0.6 Yen Prix d'origine: 122 ------------- Livre mis à jour Prix: 0.65346 Yen Prix mis à jour: 121.287809 ------------- Livre mis à jour: 0.671269 Yen Prix mis à jour: 121.300605

Ici, vous pouvez voir que nous avons mis à jour les prix de toutes les devises enregistrées et qu’ils sont affichés dans notre simulateur. Nous allons maintenant examiner comment ajouter de nouvelles devises à ce simulateur avec juste une modification mineure..

Cette modification inclut l’enregistrement de devises sur le simulateur uniquement. En tant que tel, notre code client reste inchangé chaque fois qu'il appelle le programme de mise à jour de prix dans notre simulateur..

Ajout d'une nouvelle devise

Classe de monnaie

classe Euro implémente Currency private $ price; fonction publique __construct ($ price) $ this-> price = $ price; écho "Prix d'origine Euro: $ price
"; public function update () $ this-> price = $ this-> getPrice (); echo"Euro Mise à jour Prix: $ this-> price
"; fonction publique getPrice () return f_rand (0.78, 0.85);

Il était facile et simple d'ajouter une nouvelle devise. Il ne reste plus maintenant qu’à enregistrer cette nouvelle devise auprès de notre observateur et nous avons tous terminé.!

$ priceSimulator = new priceSimulator (); $ currency1 = nouvelle livre (0,60); $ currency2 = nouveau Yen (122); $ currency3 = nouvel euro (122); $ priceSimulator-> addCurrency ($ currency1); $ priceSimulator-> addCurrency ($ currency2); $ priceSimulator-> addCurrency ($ currency3); écho "
"; $ priceSimulator-> updatePrice (); echo"
"; $ priceSimulator-> updatePrice ();

Conclusion

L'état de tout objet est très important dans la programmation orientée objet, car tout se déroule entre les objets et leurs interactions. Il arrive fréquemment que quelques objets doivent être notifiés lorsque des modifications sont apportées à d'autres objets. Le modèle de conception de l'observateur peut être utilisé lorsqu'un ou plusieurs observateurs doivent observer les modifications apportées à un sujet..

N'oubliez pas de laisser vos commentaires ci-dessous.

Code