Principaux modèles de conception que tout ingénieur logiciel devrait connaître

PHP, en particulier avec ses fonctionnalités modernes telles que les attributs, les énumérations et les propriétés en lecture seule en PHP, est bien adapté à la mise en œuvre de modèles de conception. Voici cinq modèles essentiels que tout ingénieur logiciel devrait connaître.

---

1. Modèle Singleton

Garantit qu'une classe n'a qu'une seule instance.

final class Config 
{
    private static ?Config $instance = null;

    private function __construct(public readonly array $settings) {}

    public static function getInstance(): Config 
    {
        return self::$instance ??= new Config(['env' => 'production']);
    }
}

// Usage
$config = Config::getInstance();
echo $config->settings['env']; // Output: production

---

2. Modèle d'usine

Centralise la logique de création d'objets.

class DatabaseFactory 
{
    public static function create(string $type): Database 
    {
        return match ($type) {
            'mysql' => new MySQLDatabase(),
            'postgres' => new PostgresDatabase(),
            default => throw new InvalidArgumentException("Unknown database type"),
        };
    }
}

interface Database { public function connect(): void; }
class MySQLDatabase implements Database { public function connect() { echo "MySQL connected"; } }
class PostgresDatabase implements Database { public function connect() { echo "Postgres connected"; } }

// Usage
$db = DatabaseFactory::create('mysql');
$db->connect(); // Output: MySQL connected

---

3. Modèle d'observateur

Avertit plusieurs objets des changements d'état.

class Event 
{
    private array $listeners = [];

    public function attach(callable $listener): void { $this->listeners[] = $listener; }
    public function trigger(string $data): void { foreach ($this->listeners as $listener) $listener($data); }
}

// Usage
$event = new Event();
$event->attach(fn($data) => print "Listener 1: $data\n");
$event->attach(fn($data) => print "Listener 2: $data\n");

$event->trigger("Event triggered"); 
// Output:
// Listener 1: Event triggered
// Listener 2: Event triggered

---

4. Motif Décorateur

Ajoute dynamiquement un comportement aux objets.

interface Text { public function render(): string; }

class PlainText implements Text 
{
    public function __construct(private string $text) {}
    public function render(): string { return $this->text; }
}

class BoldText implements Text 
{
    public function __construct(private Text $text) {}
    public function render(): string { return "<b>" . $this->text->render() . "</b>"; }
}

// Usage
$text = new BoldText(new PlainText("Hello, World!"));
echo $text->render(); // Output: <b>Hello, World!</b>

---

5. Modèle de stratégie

Bascule entre les algorithmes au moment de l'exécution.

interface PaymentStrategy { public function pay(float $amount): void; }

class CreditCardPayment implements PaymentStrategy 
{
    public function pay(float $amount): void { echo "Paid $amount with Credit Card\n"; }
}

class PayPalPayment implements PaymentStrategy 
{
    public function pay(float $amount): void { echo "Paid $amount via PayPal\n"; }
}

class PaymentProcessor 
{
    public function __construct(private PaymentStrategy $strategy) {}

    public function execute(float $amount): void 
    {
        $this->strategy->pay($amount);
    }
}

// Usage
$processor = new PaymentProcessor(new PayPalPayment());
$processor->execute(100.00); // Output: Paid 100 via PayPal

---

Ces modèles résolvent des problèmes du monde réel et sont fondamentaux pour écrire des applications maintenables et évolutives.

Quel motif résonne avec votre projet actuel ? Discutons-en dans les commentaires ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!