Comprendre les usines simples, les méthodes d'usine et les usines abstraites dans un seul article

Mode usine simple

En gros, tout le monde a un lecteur de musique sur son téléphone mobile. Les lecteurs actuellement populaires sont : QQ Music, Kugou Music, Sogou Music, NetEase Cloud Music, Tiantian Dongting, etc. Ce qui suit est un morceau de code sur la lecture de musique :

if ($type == 'QQ') {
    $player = new QQPlayer();
} else if ($type == 'Wy') {
    $player = new WyPlayer();
} else if ($type == 'KG') {
    $player = new KGPlayer();
} else {
    $palyer = null;
}
 
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Afin de rendre la logique du code plus claire et plus lisible, nous devons être doués pour encapsuler des blocs de code fonctionnellement indépendants dans des fonctions. Selon cette idée de conception, nous pouvons extraire les branches conditionnelles et les placer dans une méthode distincte dans une classe. Cette classe peut être appelée le modèle d’usine simple.

Définition d'un modèle de fabrique simple : Une classe peut obtenir différentes instances en fonction de différents paramètres. Généralement, ces instances créées ont la même classe parent.

Modèle d'usine statique : Généralement, nous définissons les méthodes utilisées pour créer différentes instances dans le modèle d'usine simple comme méthodes statiques pour éviter de créer plusieurs instances identiques.

Réécrivons le code ci-dessus en utilisant le modèle d'usine simple

class MusicPlayerFactory
{
    public static function create ($type)
    {
        if ($type == 'QQ') {
            $player = new QQPlayer();
        } else if ($type == 'Wy') {
            $player = new WyPlayer();
        } else if ($type == 'KG') {
            $player = new KGPlayer();
        } else {
            $player = null;
        }
        return $player;
    }
}

// 业务代码修改如下
$player = MusicPlayerFactory:create('QQ');
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Pour le modèle d'usine simple ci-dessus, si nous devons ajouter un nouveau lecteur de musique, nous le modifierons certainement it La méthode de création de MusicPlayerFactory est quelque peu incompatible avec le "principe d'ouverture et de fermeture". Il n'existe pas beaucoup de branches conditionnelles de ce type et la création d'autres classes est également très simple. Il est tout à fait possible d'utiliser le modèle d'usine simple. Si vous devez supprimer la logique de branche if et la rendre conforme au "principe d'ouverture et de fermeture", alors vous pouvez utiliser la méthode d'usine pour y parvenir. Pour les méthodes d'usine, ce n'est pas nécessairement meilleur que le simple modèle d'usine. Bien que son évolutivité soit meilleure, il sacrifie la lisibilité.

Modèle de méthode Factory

Définition : Dans le modèle de méthode Factory, la classe parent Factory est chargée de définir l'interface publique pour créer des objets produit. , et l'enfant d'usine La classe est responsable de la génération d'objets de produit spécifiques. Le but est de retarder l'opération d'instanciation de la classe de produit vers la sous-classe d'usine, c'est-à-dire de déterminer quelle classe de produit spécifique doit être instanciée via la sous-classe d'usine. .

Maintenant, nous utilisons le "polymorphisme" pour éliminer la structure de branche if du modèle d'usine simple ci-dessus. Le code implémenté est le suivant :

interface IMusicPlayerFactory
{
    static function create ();
}

class QQPlayerFactory implements IMusicPlayerFactory
{
    public static function create ()
    {
        return new QQPlayer();
    }
}

class WyPlayerFactory implements IMusicPlayerFactory
{
    public static function create ()
    {
        return new WyPlayer();
    }
}

class KGPlayerFactory implements IMusicPlayerFactory
{
    public static function create ()
    {
        return new KGPlayer();
    }
}

// 业务代码修改如下
if ($type == 'QQ') {
    $player = QQPlayerFactory::create();
} else if ($type == 'Wy') {
    $player = WyPlayerFactory::create();
} else if ($type == 'KG') {
    $player = KGPlayerFactory::create();
} else {
    throw new \Exception('...');
}
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Comme vous pouvez le voir, le problème est revenu au point d'origine et la structure de branche conditionnelle if apparaît à nouveau dans le code métier. Alors comment résoudre ce problème ?

Nous pouvons créer une usine simple pour la classe usine afin de créer des objets de classe usine. Le nouveau code d'usine simple est le suivant :

class MusicPlayerFactoryMap
{
    const Players = [
        'QQ' => 'QQPlayerFactory',
        'Wy' => 'WyPlayerFactory',
        'KG' => 'KGPlayerFactory'
    ];
    public static function getPlayerFactory (string $type)
    {
        if (empty($type)) {
            return null;
        }
        return (self::Players[$type])::create();
    }
}

// 业务代码修改如下
$palyer = MusicPlayerFactoryMap::getPlayerFactory('QQ')
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Comme vous pouvez le voir, en utilisant le modèle d'usine, la structure devient beaucoup plus complexe qu'avant. Nous recommandons d'utiliser le modèle de méthode d'usine uniquement si le processus de création d'une instance est copié.

Abstract Factory Pattern

Les scénarios d'utilisation du Abstract Factory Pattern sont assez particuliers et sont rarement utilisés. Dans le modèle de méthode d'usine, des usines spécifiques sont responsables de la production de produits spécifiques, et chaque usine correspond à un produit spécifique. Mais parfois, nous avons besoin d’une usine capable de créer plusieurs objets produits au lieu d’un seul produit.

Prenons un exemple : l’usine informatique cible est chargée de produire les ordinateurs destinés à la vente. Nous savons qu'un ordinateur est composé d'un hôte, d'un clavier, d'un moniteur et d'une souris. Actuellement, Target Computer City ne produit que trois types d'ordinateurs, des ordinateurs bas de gamme, de milieu de gamme et haut de gamme avec des configurations différentes. différentes marques d'hôtes, marques de moniteurs, etc.

Les consoles actuelles sont : la console Kirin, la console Thunder, la console Winter

Les claviers sont actuellement : Rapoo, Logitech, Razer

Les moniteurs sont actuellement : aoc, hkc, BenQ

Les souris incluent actuellement : Logitech, Snake et Founder

La version supérieure de l'ordinateur est composée d'un hôte Kirin, d'un clavier Rapoo, d'un moniteur AOC et d'une souris Logitech, et la version milieu de gamme la version est composée de...

Le code de l'hôte est le suivant :

interface Host
{
    static function createHost ();
}
class DrHost implements Host
{
    public static function createHost()
    {
        echo '创建冬日主机' . PHP_EOL;
    }
}
class QlHost implements Host
{
    public static function createHost()
    {
        echo '创建麒麟主机' . PHP_EOL;
    }
}
class LtHost implements Host
{
    public static function createHost()
    {
        echo '创建雷霆主机' . PHP_EOL;
    }
}

De même, pour créer un clavier, un moniteur et une souris, le code ne sera pas publié ici.

Maintenant, nous définissons une interface pour créer des ordinateurs.

interface ComputerFactory
{
    static function createHost ();
    static function createKeyboard ();
    static function createMonitor ();
    static function createMouse ();
}

Réalisez ensuite trois usines spécifiques pour créer des ordinateurs bas de gamme, milieu de gamme et haut de gamme.

class GreatComputerFactory implements ComputerFactory
{
    public static function createHost()
    {
        QlHost::createHost();
    }
    public static function createKeyboard()
    {
        LbKeyboard::createKeyboard();
    }
    public static function createMonitor()
    {
        AocMonitor::createMonitor();
    }
    public static function createMouse()
    {
        LjMouse::createMouse();
    }
}
class GoodComputerFactory implements ComputerFactory
{
    public static function createHost()
    {
        LtHost::createHost();
    }
    public static function createKeyboard()
    {
        LjKeyboard::createKeyboard();
    }
    public static function createMonitor()
    {
        HkcMonitor::createMonitor();
    }
    public static function createMouse()
    {
        LsMouse::createMouse();
    }
}
class NormalComputerFactory implements ComputerFactory
{
    public static function createHost()
    {
        DrHost::createHost();
    }
    public static function createKeyboard()
    {
        LsKeyboard::createKeyboard();
    }
    public static function createMonitor()
    {
        BenqMonitor::createMonitor();
    }
    public static function createMouse()
    {
        FzMouse::createMouse();
    }
}

Vous pouvez maintenant créer un ordinateur spécifique

class GreatComputer
{
    public function __construct()
    {
        echo '高配电脑' . PHP_EOL;
        GreatComputerFactory::createHost();
        GreatComputerFactory::createKeyboard();
        GreatComputerFactory::createMonitor();
        GreatComputerFactory::createMouse();
    }
}
class GoodComputer
{
    public function __construct()
    {
        echo '中配电脑' . PHP_EOL;
        GoodComputerFactory::createHost();
        GoodComputerFactory::createKeyboard();
        GoodComputerFactory::createMonitor();
        GoodComputerFactory::createMouse();
    }
}
class NormalComputer
{
    public function __construct()
    {
        echo '低配电脑' . PHP_EOL;
        NormalComputerFactory::createHost();
        NormalComputerFactory::createKeyboard();
        NormalComputerFactory::createMonitor();
        NormalComputerFactory::createMouse();
    }
}

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!