Une introduction aux modèles de conception en PHP

Publié: 2020-04-14

Les modèles de conception PHP se sont avérés extrêmement utiles pour les développeurs et constituent un résolveur de problèmes majeur. Pour écrire du code efficace, les développeurs doivent suivre les meilleures pratiques. Les modèles de conception PHP sont un concept de programmation orientée objet (POO) qui est désormais également utilisé dans les projets Drupal 8. Avec Drupal 8 adoptant les concepts PHP et OOP modernes, les modèles de conception peuvent être exploités pour une programmation plus propre et plus robuste.

Que sont les Design Patterns en PHP ?

En génie logiciel, un modèle de conception est une solution générale reproductible à un problème courant dans la conception de logiciels. Les bonnes conceptions orientées objet doivent être réutilisables, maintenables et extensibles et les modèles de conception en PHP pourraient être très utiles pour ce faire. Cela n'aide pas seulement à résoudre les problèmes, cela implique une manière optimale de relever les défis communs.

Avantages de l'utilisation des modèles de conception PHP

Les principaux avantages des modèles de conception en PHP sont :

Les modèles de conception PHP aident à résoudre les problèmes répétitifs rencontrés pendant le développement
L'utilisation de modèles de conception en PHP rend la communication plus efficace entre les concepteurs
Les autres développeurs qui examinent votre code n'auront pas à lutter pour comprendre car le code est bien structuré avec des modèles de conception
Le respect des meilleures pratiques permet de créer des logiciels plus robustes
Il aide à rendre le développement plus rapide et plus facile

Modèles de conception largement utilisés en PHP

Les Design Patterns peuvent être utilisés dans diverses situations pour résoudre des problèmes similaires. Il existe environ 23 modèles de conception qui peuvent être globalement classés en trois types de modèles de conception : modèles de création, structurels et comportementaux.

Modèles de création : modèles de conception utilisés dans les mécanismes de création d'objets, pour créer des objets pouvant être découplés du système qui les a mis en œuvre.

Modèles structurels : cela facilite la conception en identifiant des moyens simples de réaliser des relations entre les entités

Modèles comportementaux : ils sont utilisés pour gérer les relations, les responsabilités et les algorithmes entre les objets

Modèle d'usine

Un modèle d'usine est utilisé pour construire un objet. C'est vrai - construisez un objet et non créez un objet. Lorsque nous construisons l'objet, nous le créons d'abord puis l'initialisons. Habituellement, cela nécessite d'appliquer une certaine logique et d'effectuer plusieurs étapes. Avec cela, il est logique d'avoir tout cela au même endroit et de le réutiliser chaque fois que vous avez besoin de construire un nouvel objet de la même manière. Fondamentalement, c'est l'utilisation du modèle d'usine.
C'est une excellente idée d'avoir une interface pour notre usine et d'avoir notre code dépendant de celle-ci et non d'une usine concrète

 interface FamilyFactoryInterface {
    Publique une fonction créer () : Famille
}

Ensuite, implémentez l'interface d'usine avec la classe suivante :

classer Usine Familiale met en oeuvre FamilyFactoryInterface {

Publique une fonction créer () : Famille {

$famille = nouvelle Famille();

// initialise ta famille

retourner $famille ;

}

Modèle d'adaptateur

Dans Adapter Design Pattern, une classe transforme l'interface d'une classe en une autre classe. Dans cet exemple, nous avons une classe TextBook qui a des méthodes getTitle() et getAuthor(). Le client attend une méthode getTitleAndAuthor(). Pour "adapter" SimpleBook pour demoAdapter, nous avons une classe d'adaptateur, BookAdapter , qui prend une instance de TextBook et utilise les méthodes TextBook getTitle() et getAuthor() dans sa propre méthode getTitleAndAuthor.

<?php

classer Manuel {

titre $ privé ;
$auteur privé ;
une fonction __construct ($title_in, $author_in) {
$this ->title = $title_in;

$this ->author = $author_in;
}

une fonction obtenirTitre () {
retourner $this ->titre ;
}
une fonction getAuteur () {
retourner $this ->auteur ;
}
}

classer BookAdapter {
$book privé ;
une fonction __construct (TextBook $book_in) {
$this ->book = $book_in;
}
une fonction getTitleAndAuthors () {
retourner $this ->book->getTitle(). ' par ' . $this ->book->getAuthor();
}
}

// client

writeln( 'DÉBUT DE TEST DU MODÈLE D'ADAPTATEUR' );
writeln( '' );

$book = new TextBook( "Gamma, Helm, Johnson et Vlissides" , "Design Patterns" );
$bookAdapter = new BookAdapter($book);
writeln( 'Auteur et titre : ' .$bookAdapter->getTitleAndAuthor());
writeln( '' );

writeln( 'FIN DE TEST DU MOTIF D'ADAPTATEUR' );

une fonction writeln ($line_in) {
echo $line_in. "<br/>" ;
}

?>

Modèle de singleton PHP

Afin de limiter l'instanciation d'une classe à un seul objet, un pattern singleton en PHP est utilisé. Cela peut être utile lorsqu'un seul objet est nécessaire dans le système. Il est logique d'autoriser l'accès à une seule instance d'une certaine classe lors de la conception d'applications Web. Afin d'empêcher la création explicite d'objets à partir de la classe de modèle Singleton, un constructeur privé est utilisé.

<?php
classer Singleton
{
Publique statique une fonction obtenirInstance ()
{
statique $instance = null ;
if ( null === $instance) {
$instance = nouveau statique ();
}
renvoie $instance ;
}
protégé une fonction __construire ()
{
}
privé une fonction __clone ()
{
}
privé une fonction __réveil ()
{
}
}
classer SingletonEnfant s'étend Singleton
{
}
$obj = Singleton::getInstance();
var_dump($obj === Singleton::getInstance());
$obj2 = SingletonChild::getInstance();
var_dump($obj2 === Singleton::getInstance());
var_dump($obj2 === SingletonChild::getInstance());
?>

Modèle d'observateur en PHP

Le modèle PHP Observer est utilisé pour alerter le reste du système sur des événements particuliers à certains endroits.
Par exemple, si nous devons créer un Théâtre pour montrer des films aux critiques. On définit la classe Theater avec la méthode courante. Avant de présenter le film, nous souhaitons envoyer des messages aux téléphones portables des critiques. Ensuite, au milieu du film, nous voulons arrêter le film pendant 5 minutes pour laisser un intervalle aux critiques. Enfin, après la fin du film, nous voulons demander aux critiques de laisser leur réponse. Ainsi, dans le modèle d'observateur pour PHP, l'objet observateur n'est notifié que lorsque l'état est modifié.

Voici à quoi ressemble le code -

classer Théâtre {

Publique une fonction actuel (Film $film) : void {

$critics = $movie->getCritics();
$this ->message->send($critics, '...' );

$film->play();

$film->pause( 5 );
$this ->progress->interval($critics)
$film->fin();

$this ->response->request($critics);
}
}

Modèle de décorateur pour PHP

Le modèle Decorator est utilisé lorsque vous souhaitez modifier le caractère d'un objet au moment de l'exécution, et avec cela, réduire les héritages inutiles et le nombre de classes. Eh bien, cela peut être expliqué avec des exemples. Disons que nous avons les classes Sofa et Bed, et qu'elles implémentent toutes les deux SleeperInterface.

interface SleeprInterface {
Publique une fonction sommeil () : vide;
}
classer Sofa met en oeuvre SleeperInterface {
Publique une fonction sommeil () : vide {
// dort sur le canapé
}
}
classer Lit met en oeuvre SleeperInterface {
Publique une fonction sommeil () : vide {
// dort sur le lit
}
}

Les canapés et les lits ont le même comportement pour dormir. Maintenant, nous avons besoin d'autres canapés et lits avec des fonctionnalités supplémentaires qui indiqueront aux utilisateurs le suivi du sommeil lorsqu'ils dorment sur les canapés ou les lits. Avec l'héritage, nous pouvons résoudre ce problème comme ceci :

classer SmartSofa s'étend Canapé {
fonction publique sleep() : void {
parent::sommeil();
$ this ->sleepHours();
}
}
classer Lit intelligent s'étend Fenêtre {
fonction publique sleep() : void {
parent::sommeil();
$ this ->sleepHours();
}
}

Maintenant, nous avons 4 classes au total. Cependant, nous n'avons pu résoudre ce problème avec 3 classes qu'avec le pattern Decorator. Voici comment:

classer SmartSleeper met en oeuvre SleeperInterface {

$dormeur privé ;
Publique une fonction __construct (SleeperInterface $sleeper) {
$this ->sleeper = $sleeper;
}

Publique une fonction sommeil () : vide {
$this ->sleeper->sleep();
$this ->sleepHours();
}
}
$canapé = nouveau Canapé();
$lit = nouveau lit();
$smartSofa = nouveau SmartSleeper($canapé);
$smartBed = nouveau SmartSleeper($lit);

Ici, nous avons introduit un nouveau type de dormeur qui agit comme un proxy mais avec une fonctionnalité supplémentaire en plus.

Tirer parti des modèles de conception dans Drupal 8

Bien qu'il existe de nombreux modèles de conception déjà établis dans Drupal avant Drupal 8, Drupal 8 se compose désormais de nombreux modèles qui n'étaient pas disponibles auparavant. Certains de ces nouveaux modèles remplacent complètement les anciens, tandis que d'autres introduisent de nouvelles fonctionnalités dans Drupal 8.

Les modèles de conception utilisés dans Drupal 8 incluent :

Modèle de programmation orienté objet (OOP)
Injections de dépendance
Modèle d'usine
Modèle de singleton

La POO n'est pas vraiment un modèle unique, mais une manière complètement radicale de conceptualiser et de structurer des codes qui va bien au-delà des simples modèles de conception. C'est la base de nombreux modèles de conception de logiciels populaires utilisés aujourd'hui, y compris ceux utilisés dans Drupal 8. Il a été introduit dans Drupal 7, mais il n'a pas été largement utilisé et n'était pas nécessaire. La situation dans Drupal 8 est désormais différente, il est largement utilisé, et il est obligatoire.

Injection de dépendance

L'injection de dépendances est ce modèle de conception de logiciel qui vous permettrait de supprimer les dépendances codées en dur et de les modifier à l'exécution ou à la compilation. L'ajout de l'injection de dépendances est simple et n'interfère pas avec votre code existant. Drupal 8 a introduit le concept de services afin de découpler les fonctionnalités réutilisables. core.services.yml est un exemple d'injection de dépendances dans Drupal 8. Nous avons déjà discuté du Factory Pattern et du Singleton Pattern en PHP ci-dessus.