Cas d'utilisation et analyse du modèle d'usine PHP

Cette fois, je vais vous présenter les cas d'utilisation et l'analyse du mode usine PHP. Quelles sont les précautions pour les cas d'utilisation et l'analyse du mode usine PHP. Ce qui suit est un cas pratique, jetons un coup d'œil.

Factory Design Pattern, en tant que modèle de conception créatif, suit le principe ouvert-fermé, fermé à la modification et ouvert à l'extension. Le modèle Factory Method (Factory Method) consiste à créer "quelque chose" avec la méthode Factory. modèle, la "chose" à créer est un produit, et il n'y a aucune liaison entre ce produit et la classe qui le crée. En fait, afin de maintenir ce couplage lâche, le client en fera la demande via une usine. Le produit demandé est créé par l'usine. Vous pouvez également y penser d'une autre manière, en utilisant le modèle de méthode d'usine. Le demandeur émet uniquement une demande sans créer spécifiquement le produit.

Le produit demandé est créé par l'usine. travail de l'usine

Créez d'abord une interface d'usine

Factory.php

<?php
abstract class Factory
{
 //抽象的创建对象的方法
 protected abstract function createProduct();
 //该方法调用createProduct方法返回一个产品对象.
 public function start()
 {
   return $this->createProduct();
 }
}

start retours de la méthode un produit, quelle méthode appelle La méthode createProduct termine l'opération de génération de produits. Par conséquent, l'implémentation spécifique de createProduct doit construire et renvoyer un objet produit implémenté selon l'interface Product

Par exemple, products all. avons une méthode commune getProperties(), et ce qui suit est l'interface produit correspondante

Product.php

<?php
//产品接口
interface Product
{
 public function getProperties();
}

Ensuite, nous devons créer deux usines, texte factory TextFactory et image factory phptoFactory

TextFactory.php

<?php
include_once(&#39;Factory.php&#39;);
include_once(&#39;TextProduct.php&#39;);
class TextFactory extends Factory
{
 protected function createProduct()
 {
  $product = new TextProduct();
  return $product->getProperties();
 }
}

PhotoFactory.php

<?php
include_once(&#39;Factory.php&#39;);
include_once(&#39;PhotoProduct.php&#39;);
class PhotoFactory extends Factory
{
 protected function createProduct()
 {
  $product = new PhotoProduct();
  return $product->getProperties();
 }
}

Comme vous peut voir, dans l'implémentation de la méthode factory, la méthode getProperties introduit le polymorphisme (polymorphisme), cette méthode sera utilisée pour renvoyer "texte" ou "image". Le même getProperties() a plusieurs (poly) morphes (morphes) différents. , qui est un polymorphisme. Dans ce cas, l'un des formulaires renvoie du texte, tandis que l'autre renvoie une image.

Vous pouvez mettre tout ce que vous voulez dans l'implémentation des propriétés, et la conception de la méthode d'usine créera cet objet et retournez-le au Client pour utilisation.

Ce qui suit est la mise en œuvre des deux produits

TextProduct.php

<?php
include_once(&#39;Product.php&#39;);
class TextProduct implements Product
{
 public function getProperties()
 {
  return "这里是文本产品";
 }
}

PhotoProduct.php

<?php
include_once(&#39;Product.php&#39;);
class PhotoProduct implements Product
{
 //这是产品具有的方法
 public function getProperties()
 {
  return "这里是图像产品";
 }
}

Ces deux produits implémentent les méthodes abstraites dans l'interface ProduitgetProperties(),

Client (Client)

Nous ne voulons pas que les clients fassent des demandes de produits directement. En fait, nous voulons que les clients fassent des demandes via l'interface Factory de cette manière, si nous ajoutons des produits ou des usines à l'avenir. , les clients peuvent faire la même demande pour obtenir plus de types de produits sans casser l'application :

Client.php

<?php
include_once(&#39;PhotoFactory.php&#39;);
include_once(&#39;TextFactory.php&#39;);
class Client
{
 public function construct()
 {
  $this->somePhotoObject = new PhotoFactory();
  echo $this->somePhotoObject->start() . &#39;<br />&#39;;
  $this->someTextObject = new TextFactory();
  echo $this->someTextObject->start() . &#39;<br />&#39;;
 }
}
$worker = new Client();

Exécutez Client.php et obtenez le. résultats suivants

Voici un produit image
Ceci est un produit texte

Remarque : L'objet Client ne fait pas de requête directement au produit, mais le demande via l'usine. L'important est que le client Il ne met pas en œuvre les fonctionnalités du produit, mais les laisse à la mise en œuvre du produit.

Ajustement des produits

La vraie valeur des modèles de conception n'est pas d'augmenter la vitesse de fonctionnement, mais d'accélérer le développement La vitesse.

Si les besoins changent maintenant et que vous devez modifier l'image du produit, il vous suffit de modifier la méthode getProperties du produit correspondant PhotoProduct

Le changement d'objet semble très simple, mais Product La méthode getProperties() conserve toujours la même interface, et la fabrique de requêtes renvoie un objet attribut

Ajouter de nouveaux produits et requêtes paramétrées

Le problème vient, si vous souhaitez en ajouter plus Avec de nombreuses images et descriptions textuelles, est-il nécessaire d'ajouter une nouvelle classe d'usine spécifique à chaque fois qu'une nouvelle zone est ajouté ? Cela signifie ajouter une nouvelle usine et un nouveau produit pour chaque nouveau domaine. Par conséquent, nous avons introduit le modèle de conception d'usine d'ingénierie paramétrique.

L'une des principales différences entre le modèle de conception d'usine paramétrique et le modèle de conception d'usine général est que. le Client contient des références à la fois au Factory et au Product. Dans une requête paramétrée, la classe Client doit spécifier le Product, pas le Product Factory . Le paramètre dans l'opération createProduct() est un produit transmis par le client ; doit indiquer le produit spécifique qu'il souhaite. Cependant, la demande se fait toujours via l'interface de l'usine Factory Ainsi, bien que le client contienne une référence produit, Avec Factory, le client reste séparé du produit.

一个工厂多个产品(参数化工厂方法)

对于大多数请求, 参数化工厂方法更为简单, 因为客户只需要处理一个具体工厂.工厂方法操作有一个参数,指示需要创建的产品.而在原来的设计中, 每个产品都有自己的工厂, 不需要另个传递参数; 产品实现依赖于各个产品特定的工厂.

新工厂接口

Factory.php

<?php
abstract class Factory
{
 //抽象的创建对象的方法
 protected abstract function createProduct(Product $product);
 //该方法由factoryMethod方法返回一个产品对象.
 public function start($product)
 {
   return $this->createProduct($product);
 }
}

在这个新的Factory接口中可以看到, create()和start()都需要一个参数,指定一个Product对象, 而不是Product接口的一个特定实现, 所以可以接受任何Product的具体实例.

工厂具体实现

具体的创建者类CommonFactory实现了createProduct(),如下

CommonFactory.php

<?php
include_once(&#39;Factory.php&#39;);
include_once(&#39;Product.php&#39;);
class CommonFactory extends Factory
{
 protected function createProduct(Product $product)
 {
  return $product->getProperties();
 }
}

这个类调用Product的方法getProperties将产品返回给客户.

新产品

具体产品的变化并不会改变原来的Product接口,还是原来的代码

<?php
//产品接口
interface Product
{
 public function getProperties();
}

例如, 现在有一个钢笔产品PenProduct

PenProduct.php

<?php
include_once(&#39;Product.php&#39;);
class PenProduct implements Product
{
 public function getProperties()
 {
  return "钢笔产品";
 }
}

客户Clent(有参数)

<?php
include_once(&#39;CommonFactory.php&#39;);
include_once(&#39;PenProduct.php&#39;);
class Client
{
 public function construct()
 {
  $commonFactory = new CommonFactory();
  echo $commonFactory->start(new PenProduct());
 }
}
$worker = new Client();

运行后输出

钢笔产品

以后如果开发出了新的产品, 只需要创建对应的产品类, 然后客户指定想要的新产品 , 即可返回客户需要的产品.

总结:

产品改变: 接口不变

使用设计模式的一大好处就是可以很容易地对类做出改变, 而不会破坏更大的程序. 之所以能够容易地做出改变, 秘诀在于保持接口不变, 而只改变内容.

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

PHP单一职责原则(SRP)使用案例解析

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!