Parlons du modèle de fabrique abstraite en PHP

Cet article vous amènera à comprendre le modèle d'usine abstrait dans les modèles de conception PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Le point culminant de la série Factory Pattern est ici, oui, c'est le Abstract Factory Pattern selon la rumeur. Qu’avez-vous ressenti lorsque vous avez entendu ce nom pour la première fois ? Quoi qu'il en soit, je pense que ce truc devrait être très haut de gamme, après tout, il contient le mot "abstrait". On dit que ces deux mots ont vraiment un sentiment de développement de haut niveau. Lorsqu'ils sont utilisés avec le mot abstrait, il semble que tout soit très puissant. Cependant, Abstract Factory peut effectivement être considéré comme le grand frère du modèle d'usine.

Diagramme de classe Gof et explication

En fait, tant que vous comprenez le modèle de méthode d'usine, il est facile de comprendre le modèle d'usine abstrait. Comment le dire ? Il retarde toujours les sous-classes et renvoie l'objet spécifié. C'est juste que la fabrique abstraite ne renvoie pas seulement un objet, mais plusieurs.

Définition GoF : Fournit une interface permettant de créer une série d'objets liés ou interdépendants sans spécifier leurs classes spécifiques.

Schéma des classes GoF :

• A gauche se trouvent deux usines 1 et 2, à la fois hériter d'une usine abstraite et implémenter les méthodes CreateProductA et CreateProductB
• L'usine 1 produit ProductA1 et ProductB1
• De même, l'usine 2 produit ProductA2 et ProductB2

Implémentation du code

// 商品A抽象接口
interface AbstractProductA
{
    public function show(): void;
}

// 商品A1实现
class ProductA1 implements AbstractProductA
{
    public function show(): void
    {
        echo 'ProductA1 is Show!' . PHP_EOL;
    }
}
// 商品A2实现
class ProductA2 implements AbstractProductA
{
    public function show(): void
    {
        echo 'ProductA2 is Show!' . PHP_EOL;
    }
}

// 商品B抽象接口
interface AbstractProductB
{
    public function show(): void;
}
// 商品B1实现
class ProductB1 implements AbstractProductB
{
    public function show(): void
    {
        echo 'ProductB1 is Show!' . PHP_EOL;
    }
}
// 商品B2实现
class ProductB2 implements AbstractProductB
{
    public function show(): void
    {
        echo 'ProductB2 is Show!' . PHP_EOL;
    }
}

Implémentation du produit, il y a beaucoup de choses, cette fois il y a en fait quatre produits, à savoir A1, A2, B1 et B2, supposons qu'il y ait cette relation entre eux, A1 et B1 sont des produits connexes similaires, B1 et B2 sont des produits connexes similaires

// 抽象工厂接口
interface AbstractFactory
{
    // 创建商品A
    public function CreateProductA(): AbstractProductA;
    // 创建商品B
    public function CreateProductB(): AbstractProductB;
}

// 工厂1，实现商品A1和商品B1
class ConcreteFactory1 implements AbstractFactory
{
    public function CreateProductA(): AbstractProductA
    {
        return new ProductA1();
    }
    public function CreateProductB(): AbstractProductB
    {
        return new ProductB1();
    }
}

// 工厂2，实现商品A2和商品B2
class ConcreteFactory2 implements AbstractFactory
{
    public function CreateProductA(): AbstractProductA
    {
        return new ProductA2();
    }
    public function CreateProductB(): AbstractProductB
    {
        return new ProductB2();
    }
}

Et notre usine est également l'usine 1 et l'usine 2, l'usine 1 produit deux produits connexes, A1 et B1 Pour les produits liés, l'usine 2 produit deux produits , A2 et B2. D'accord, je sais que c'est encore un peu abstrait ici, et je ne comprends peut-être toujours pas pourquoi c'est le cas. Continuons à utiliser la production de téléphones mobiles comme exemple.

Notre marque de téléphones portables s'est développée, nous avons donc confié des produits périphériques tels que des films pour téléphones portables et des coques pour téléphones portables à Abstract Factory pour m'aider. Comme mentionné la dernière fois, je possède déjà plusieurs types de téléphones portables, je vais donc continuer comme avant. Hengyang Factory (Factory1) produit le modèle de téléphone portable 1001 (ProductA1), et en même temps, le film pour téléphone portable (ProductB1) et L'étui de téléphone portable du modèle 1001 (ProductB1) est également produit dans l'usine de Hengyang. Le modèle de téléphone portable 1002 (ProductA2) est toujours dans l'usine de Zhengzhou (Factory2), donc le film pour téléphone portable (ProductB2) et le film pour téléphone portable (ProductC2) de ce modèle doivent leur être laissés. Je viens donc de passer une commande auprès de l'usine principale. Ils ont demandé à différentes usines de produire un ensemble complet de produits de téléphonie mobile pour moi, et j'ai pu vendre l'ensemble directement ! !

Code complet : Modèle d'usine abstrait

https://github.com/zhangyue0503/designpatterns-php/blob/master/03.abstract-factory/source/ abstract-factory.php

Exemple

Tu as encore un peu le vertige ? En fait, pour faire simple, il s'agit simplement de renvoyer différents objets via différentes méthodes dans une classe d'usine. Reprenons l’exemple des SMS pour l’expliquer !

Scénario : Cette fois, nous avons un besoin professionnel non seulement d'envoyer des messages texte, mais également d'envoyer un message push en même temps. Le but des messages texte est d'informer les utilisateurs qu'il y a de nouvelles activités auxquelles participer, tandis que les notifications push informent non seulement les utilisateurs des nouvelles activités, mais ils peuvent également cliquer directement pour recevoir des enveloppes rouges. N'est-ce pas excitant ? Heureusement, les fournisseurs de services cloud que nous avons choisis auparavant disposent tous à la fois d'interfaces SMS et push, nous utiliserons donc simplement l'usine abstraite pour l'implémenter !

Diagramme des classes d'envoi de SMS

<?php

interface Message {
    public function send(string $msg);
}

class AliYunMessage implements Message{
    public function send(string $msg){
        // 调用接口，发送短信
        // xxxxx
        return &#39;阿里云短信（原阿里大鱼）发送成功！短信内容：&#39; . $msg;
    }
}

class BaiduYunMessage implements Message{
    public function send(string $msg){
        // 调用接口，发送短信
        // xxxxx
        return &#39;百度SMS短信发送成功！短信内容：&#39; . $msg;
    }
}

class JiguangMessage implements Message{
    public function send(string $msg){
        // 调用接口，发送短信
        // xxxxx
        return &#39;极光短信发送成功！短信内容：&#39; . $msg;
    }
}

interface Push {
    public function send(string $msg);
}

class AliYunPush implements Push{
    public function send(string $msg){
        // 调用接口，发送客户端推送
        // xxxxx
        return &#39;阿里云Android&iOS推送发送成功！推送内容：&#39; . $msg;
    }
}

class BaiduYunPush implements Push{
    public function send(string $msg){
        // 调用接口，发送客户端推送
        // xxxxx
        return &#39;百度Android&iOS云推送发送成功！推送内容：&#39; . $msg;
    }
}

class JiguangPush implements Push{
    public function send(string $msg){
        // 调用接口，发送客户端推送
        // xxxxx
        return &#39;极光推送发送成功！推送内容：&#39; . $msg;
    }
}


interface MessageFactory{
    public function createMessage();
    public function createPush();
}

class AliYunFactory implements MessageFactory{
    public function createMessage(){
        return new AliYunMessage();
    }
    public function createPush(){
        return new AliYunPush();
    }
}

class BaiduYunFactory implements MessageFactory{
    public function createMessage(){
        return new BaiduYunMessage();
    }
    public function createPush(){
        return new BaiduYunPush();
    }
}

class JiguangFactory implements MessageFactory{
    public function createMessage(){
        return new JiguangMessage();
    }
    public function createPush(){
        return new JiguangPush();
    }
}

// 当前业务需要使用阿里云
$factory = new AliYunFactory();
// $factory = new BaiduYunFactory();
// $factory = new JiguangFactory();
$message = $factory->createMessage();
$push = $factory->createPush();
echo $message->send(&#39;您已经很久没有登录过系统了，记得回来哦！&#39;);
echo $push->send(&#39;您有新的红包已到帐，请查收！&#39;);

Code source complet : méthode d'usine d'envoi de SMS

https : //github.com/zhangyue0503/designpatterns-php/blob/master/03.abstract-factory/source/abstract-factory-message-push.php

Description

• Est-ce très clair ?
• Oui, nous avons deux produits, l'un est Message et l'autre est Push, qui envoient respectivement des messages et envoient du push.
• La fabrique abstraite nécessite uniquement que nos implémenteurs d'interface implémentent deux méthodes, renvoie l'objet de l'envoi de messages texte et de l'envoi de messages push
• Pouvez-vous dire que je veux uniquement envoyer des messages texte et non envoyer des messages push ? Bien sûr que vous pouvez, mais n'appelez pas la méthode createPush()
• Pour quel scénario la fabrique abstraite est-elle la plus adaptée ? De toute évidence, la création d'une série d'objets associés
• Le modèle de méthode d'usine est le cœur de l'usine abstraite. Il équivaut à l'intégration de plusieurs méthodes d'usine dans une grande usine pour produire un ensemble complet de produits (y compris). périphériques) au lieu d'un seul produit

Apprentissage recommandé : "Tutoriel vidéo PHP"

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!