Le pattern Builder est un modèle de conception de développement logiciel qui permet de créer des objets complexes étape par étape. En PHP, ce modèle est utile pour séparer la construction d’un objet complexe de sa représentation finale. Cela permet de créer différents types d’objets en utilisant un processus de construction similaire tout en gardant une certaine flexibilité dans la création de ces objets.
Problème
Imaginez que vous devez construire une maison pour différentes espèces animales dans une réserve naturelle.
Chaque animal a des besoins spécifiques et des préférences en matière de logement. Par exemple, un oiseau a besoin d’une petite maisonnette perchée dans un arbre, tandis qu’un ours a besoin d’une grande grotte avec une entrée étroite pour se protéger des prédateurs.
Solution
Le pattern Builder peut vous aider à résoudre ce problème en séparant la construction de chaque type de maison de sa représentation finale. Vous pouvez créer une interface qui décrit les différentes étapes de construction pour chaque type de maison, puis créer une classe de constructeur (Builder) pour chaque espèce animale. Chaque constructeur mettra en œuvre l’interface en utilisant les étapes spécifiques à chaque espèce animale pour construire la maison finale.
Le directeur (Director) peut alors être utilisé pour créer différentes maisons pour chaque type d’animal en utilisant les constructeurs correspondants. Ainsi, vous pouvez créer des maisons pour différentes espèces animales en utilisant un processus de construction similaire, tout en gardant une certaine flexibilité dans la création de ces maisons pour répondre aux besoins spécifiques de chaque animal.
Implémentation
Voici la méthodologie d’implémentation générale du pattern Builder :
- Identifiez l’objet complexe à créer
- déterminez quel objet complexe vous voulez créer en utilisant le pattern Builder. Il peut s’agir d’un objet avec de nombreux attributs, ou d’un objet qui nécessite une séquence complexe d’étapes pour être créé.
- Décomposez l’objet complexe en étapes – Décomposez la construction de l’objet complexe en étapes simples et atomiques, chaque étape correspondant à une tâche particulière.
- Créez une interface pour les constructeurs – Créez une interface ou un ensemble d’interfaces pour les constructeurs qui permettent de mettre en œuvre les différentes étapes de la construction. Cette interface doit être flexible et permettre la création d’objets différents en utilisant le même ensemble d’étapes.
- Créez une classe abstraite pour le constructeur – Créez une classe abstraite pour les constructeurs qui fournit des méthodes par défaut pour l’ensemble des étapes. Cette classe permettra d’implémenter les étapes nécessaires pour la construction de l’objet complexe.
- Créez des classes concrètes pour les constructeurs – Créez des classes concrètes pour les constructeurs qui implémentent les différentes étapes de la construction pour un objet complexe spécifique. Chaque constructeur peut utiliser un ensemble différent de méthodes pour la construction de l’objet complexe.
- Créez une classe directeur – Créez une classe directeur qui utilise les constructeurs pour construire l’objet complexe en appelant les différentes étapes de construction dans l’ordre approprié.
- Utilisez le pattern Builder pour construire l’objet – Utilisez le pattern Builder pour construire l’objet complexe en utilisant le directeur et les constructeurs appropriés. Chaque constructeur est utilisé pour construire une partie spécifique de l’objet complexe, et le directeur combine ces parties pour construire l’objet final.
Cette méthodologie permet de créer des objets complexes de manière flexible en utilisant un processus de construction similaire tout en gardant une certaine flexibilité dans la création de ces objets.
L’interface HouseBuilder définit les méthodes pour construire différentes parties de la maison.
interface HouseBuilder {
public function buildFoundation();
public function buildWalls();
public function buildRoof();
public function getResult();
}La classe abstraite AbstractHouseBuilder fournit une implémentation de base pour la construction de maisons.
abstract class AbstractHouseBuilder implements HouseBuilder {
protected $house;
public function __construct() {
$this->house = new House();
}
public function buildFoundation() {
$this->house->setFoundation("Beton");
}
public function buildWalls() {
$this->house->setWalls("Briques");
}
public function buildRoof() {
$this->house->setRoof("Tuiles");
}
public function getResult() {
return $this->house;
}
}La classe BirdHouseBuilder fournit une implémentation spécifique pour construire une maison pour les oiseaux.
class BirdHouseBuilder extends AbstractHouseBuilder {
public function buildFoundation() {
$this->house->setFoundation("Brindilles");
}
public function buildWalls() {
$this->house->setWalls("Bois");
}
public function buildRoof() {
$this->house->setRoof("Feuilles");
}
}La classe BearHouseBuilder fournit une implémentation spécifique pour construire une maison pour les ours.
class BearHouseBuilder extends AbstractHouseBuilder {
public function buildFoundation() {
$this->house->setFoundation("Terre");
}
public function buildWalls() {
$this->house->setWalls("Pierres");
}
public function buildRoof() {
$this->house->setRoof("Herbe");
}
}La classe HouseDirector utilise les constructeurs pour construire une maison finale.
class HouseDirector {
public function build($builder) {
$builder->buildFoundation();
$builder->buildWalls();
$builder->buildRoof();
return $builder->getResult();
}
}La class House finale définie une maison.
class House
{
private $walls;
private $roof;
private $foundation;
public function setWalls($material)
{
$this->walls = $material;
}
public function setRoof($material)
{
$this->roof = $material;
}
public function setFoundation($material)
{
$this->foundation = $material;
}
public function getWalls()
{
return $this->walls;
}
public function getRoof()
{
return $this->roof;
}
public function getFoundation()
{
return $this->foundation;
}
}Afficher les caractéristiques des maisons créées.
$birdBuilder = new BirdHouseBuilder();
$bearBuilder = new BearHouseBuilder();
$director = new HouseDirector();
$birdHouse = $director->build($birdBuilder);
$bearHouse = $director->build($bearBuilder);
echo "Maison de l'oiseau: Fondation en " . $birdHouse->getFoundation() . ", murs en " . $birdHouse->getWalls() . ", toit en " . $birdHouse->getRoof() . ".\n";
echo "Maison de l'ours: Fondation en " . $bearHouse->getFoundation() . ", murs en " . $bearHouse->getWalls() . ", toit en " . $bearHouse->getRoof() . ".\n";Dans cet exemple, nous avons créé une interface HouseBuilder qui définit les méthodes nécessaires pour construire les différentes parties d’une maison. Ensuite, nous avons créé une classe abstraite AbstractHouseBuilder qui fournit une implémentation de base pour la construction de maisons et qui contient une instance de la classe House.
Nous avons également créé deux classes concrètes BirdHouseBuilder et BearHouseBuilder, chacune fournissant une implémentation spécifique pour construire une maison pour les oiseaux ou les ours respectivement.
Nous avons également créé une classe HouseDirector qui utilise un constructeur pour construire une maison finale. Enfin, nous avons créé une classe House pour représenter la maison finale.
Dans l’exemple, nous avons utilisé le pattern builder pour construire une maison pour les oiseaux en utilisant le BirdHouseBuilder et une maison pour les ours en utilisant le BearHouseBuilder. Nous avons ensuite affiché les matériaux utilisés pour chaque maison en utilisant les méthodes de la classe House.
