Patrons de création : fabrique, constructeur, singleton
Contrôlez proprement la création des objets grâce aux patrons de création.
Patrons de création : fabrique, constructeur, singleton est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.
Contrôler la création
Les patrons de création découplent ce dont vous avez besoin de la manière dont cela est construit. Lorsque la construction est conditionnelle, comporte plusieurs étapes ou doit être centralisée, disperser new dans la base de code couple les appelants aux classes concrètes. Nous abordons ici la Fabrique (et la Méthode Fabrique), le Monteur pour les assemblages complexes et le Singleton (avec ses réserves).
Fabrique simple
Une fabrique simple centralise une décision de création derrière une seule méthode. Les appelants demandent un type logique et reçoivent une instance concrète configurée, sans connaître les noms de classes.
<?php
interface Notifier { public function send(string $msg): string; }
final class EmailNotifier implements Notifier {
public function send(string $m): string { return "email: $m"; }
}
final class SmsNotifier implements Notifier {
public function send(string $m): string { return "sms: $m"; }
}
final class NotifierFactory {
public static function make(string $channel): Notifier {
return match ($channel) {
'email' => new EmailNotifier(),
'sms' => new SmsNotifier(),
default => throw new InvalidArgumentException($channel),
};
}
}
echo NotifierFactory::make('sms')->send('Hi'), PHP_EOL;
Méthode Fabrique
Le patron de la Méthode Fabrique reporte l’instanciation aux sous-classes. La classe de base définit un algorithme qui appelle une méthode abstraite create() ; chaque sous-classe choisit le produit concret. Cette approche respecte OCP : vous pouvez ajouter un nouveau créateur sans modifier ceux qui existent.
<?php
abstract class ReportExporter {
abstract protected function create(): string;
public function export(): string {
return 'Exported as ' . $this->create();
}
}
final class PdfExporter extends ReportExporter {
protected function create(): string { return 'PDF'; }
}
final class CsvExporter extends ReportExporter {
protected function create(): string { return 'CSV'; }
}
echo (new PdfExporter())->export(), PHP_EOL;
echo (new CsvExporter())->export(), PHP_EOL;
Fabrique abstraite
Une Fabrique abstraite produit des familles d’objets associés qui doivent être utilisés ensemble (par exemple, une combinaison de MySqlConnection et de MySqlQueryBuilder). Elle garantit la compatibilité des composants, car une seule fabrique fournit l’ensemble. Utilisez-la lorsqu’une famille de produits doit rester cohérente en interne.
Monteur : le problème
Lorsqu’un objet nécessite de nombreux paramètres facultatifs, les constructeurs se transforment en listes d’arguments positionnels illisibles ou en surcharges en cascade que PHP ne propose même pas. Le patron du Monteur assemble un objet complexe étape par étape, puis renvoie à la fin un produit terminé et valide.
Monteur à interface fluide
Un monteur à interface fluide renvoie $this depuis chaque méthode d’affectation, puis build() produit le résultat immuable. Le produit lui-même reste ainsi simple, tandis que la logique d’assemblage est déplacée dans le monteur.
<?php
final class Query {
public function __construct(public readonly string $sql) {}
}
final class QueryBuilder {
private string $table = '';
private array $where = [];
public function from(string $t): self { $this->table = $t; return $this; }
public function where(string $c): self { $this->where[] = $c; return $this; }
public function build(): Query {
$sql = "SELECT * FROM {$this->table}";
if ($this->where) { $sql .= ' WHERE ' . implode(' AND ', $this->where); }
return new Query($sql);
}
}
echo (new QueryBuilder())->from('users')->where('age > 18')->build()->sql, PHP_EOL;
Monteur ou constructeurs nommés
Dans les cas plus simples, les arguments nommés de PHP 8 et les constructeurs nommés (méthodes de fabrique statiques) sont souvent préférables à un monteur complet.
- Utilisez des arguments nommés lorsque toutes les données sont disponibles en une seule fois.
- Utilisez un monteur lorsque l’assemblage comporte plusieurs étapes, est conditionnel ou est réutilisé depuis plusieurs points d’appel.
<?php
final class Money {
private function __construct(public readonly int $cents, public readonly string $cur) {}
public static function fromDollars(float $d): self {
return new self((int) round($d * 100), 'USD');
}
public static function zero(string $cur = 'USD'): self {
return new self(0, $cur);
}
}
var_dump(Money::fromDollars(19.99)->cents); // int(1999)
Singleton
Un Singleton garantit une seule instance avec un point d’accès global. Implémentez-le avec un constructeur privé et un accesseur statique. Il est véritablement utile pour les éléments qui doivent réellement être uniques au sein d’un processus, mais c’est aussi le patron le plus utilisé à mauvais escient.
<?php
final class Config {
private static ?self $instance = null;
private array $data = ['debug' => true];
private function __construct() {}
public static function instance(): self {
return self::$instance ??= new self();
}
public function get(string $k): mixed { return $this->data[$k] ?? null; }
}
var_dump(Config::instance()->get('debug'));
var_dump(Config::instance() === Config::instance()); // true
Pourquoi le Singleton pose problème
Les Singletons introduisent un état global caché : les appelants accèdent à Config::instance() au lieu de déclarer la dépendance, ce qui nuit à la testabilité et au parallélisme. En PHP moderne, préférez l’enregistrement d’une instance partagée unique dans un conteneur DI (cycle de vie « instance unique »), puis injectez-la. Vous obtenez une seule instance sans couplage global.
Choisir le bon outil
- Fabrique simple/Méthode Fabrique : masquez les classes concrètes derrière une décision de création.
- Fabrique abstraite : produisez des familles de produits compatibles.
- Monteur : assemblez des objets complexes étape par étape.
- Singleton : solution de dernier recours ; préférez les services partagés gérés par le conteneur.
Ces quatre patrons réduisent le couplage aux constructeurs concrets, ce qui facilite l’extension et le test du code.
Fabrique fondée sur un registre
Une fabrique plus dynamique recherche les créateurs dans un registre, de sorte que les nouveaux types s’enregistrent eux-mêmes sans qu’il soit nécessaire de modifier la fabrique (OCP véritable). C’est ainsi que les systèmes d’extensions et les sérialiseurs associent à l’exécution un nom de type à un constructeur.
<?php
interface Shape { public function name(): string; }
final class Circle implements Shape { public function name(): string { return 'circle'; } }
final class Square implements Shape { public function name(): string { return 'square'; } }
final class ShapeRegistry {
private array $creators = [];
public function register(string $key, callable $factory): void {
$this->creators[$key] = $factory;
}
public function create(string $key): Shape {
return ($this->creators[$key] ?? throw new InvalidArgumentException($key))();
}
}
$r = new ShapeRegistry();
$r->register('circle', fn() => new Circle());
$r->register('square', fn() => new Square());
echo $r->create('square')->name(), PHP_EOL; // square
Vérification rapide
Choisissez l’outil de création le mieux adapté au scénario.
Récapitulatif
Vous avez contrôlé la création d’objets à l’aide des patrons de création : les fabriques pour masquer les types concrets et choisir des familles de produits, les monteurs pour assembler des objets complexes avec une interface fluide, et le Singleton avec ses compromis. La conclusion moderne est la suivante : utilisez librement les fabriques et les monteurs, mais remplacez le Singleton par le cycle de vie d’instance partagée d’un conteneur DI afin que les dépendances restent explicites et testables.
Questions Fréquemment Posées
La leçon « Patrons de création : fabrique, constructeur, singleton » est-elle gratuite ?
Oui — le texte complet de « Patrons de création : fabrique, constructeur, singleton » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Patrons de création : fabrique, constructeur, singleton » ?
Contrôlez proprement la création des objets grâce aux patrons de création. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer PHP Academy ?
Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Patrons de création : fabrique, constructeur, singleton » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?
Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Les principes SOLID en pratique
- Patrons de création : fabrique, constructeur, singleton
- Patrons structurels : adaptateur, décorateur, façade
- Patrons comportementaux : stratégie, observateur, commande