Anwendungsfälle und Analyse von PHP-Fabrikmustern

Dieses Mal werde ich Ihnen Anwendungsfälle und Analysen für den PHP-Factory-Modus vorstellen. Was sind die Vorsichtsmaßnahmen für Anwendungsfälle und Analysen im PHP-Factory-Modus?

Factory Design Pattern folgt als kreatives Designmuster dem Open-Closed-Prinzip, geschlossen für Änderungen und offen für Erweiterungen. Das Factory-Methode-Muster (Factory-Methode) besteht darin, „etwas“ mit der Factory-Methode zu schaffen Muster: Das zu erstellende „Ding“ ist ein Produkt, und es gibt keine Bindung zwischen diesem Produkt und der Klasse, die es erstellt. Um diese lose Kopplung aufrechtzuerhalten, stellt der Client die Anforderung dann über eine Fabrik Das angeforderte Produkt wird von der Fabrik erstellt. Sie können es auch anders betrachten, indem Sie das Fabrikmethodenmuster verwenden. Der Anforderer stellt nur eine Anfrage, ohne das Produkt speziell zu erstellen.

Das Arbeit der Fabrik

Erstellen Sie zunächst eine Fabrikschnittstelle

Factory.php

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

start Methode gibt ein Produkt zurück , die aufruft createProductDie Methode schließt den Vorgang des Generierens von Produkten ab. Daher muss die spezifische Implementierung von createProduct ein Produktobjekt erstellen und zurückgeben, das gemäß der Produktschnittstelle implementiert ist.

Zum Beispiel haben alle Produkte eine Gemeinsamkeit MethodegetProperties(), und das Folgende ist die entsprechende Produktschnittstelle

Product.php

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

Als nächstes müssen wir zwei Fabriken erstellen, die Textfabrik TextFactory und die Bildfabrik 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();
 }
}

Wie Sie sehen können, in der Implementierung von Die Factory-Methode, die getProperties-Methode, führt Polymorphismus ein, und diese Methode gibt „Text“ oder „Bild“ zurück. Dasselbe getProperties() hat mehrere (poly) unterschiedliche Morphen (Morphs), in diesem Fall einen Eines der Formulare gibt Text zurück und das andere gibt ein Bild zurück.

Sie können alles, was Sie wollen, in die Eigenschaftenimplementierung einfügen. Das Factory-Methodendesign erstellt dieses Objekt und gibt es zur Verwendung an den Client zurück.

Das Folgende sind zwei Implementierungen eines Produkts

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 "这里是图像产品";
 }
}

Diese beiden Produkte implementieren die abstrakten Methoden der Produktschnittstelle in getProperties(),

Kunde (Client)

Wir möchten nicht, dass Kunden Produktanfragen direkt stellen . Tatsächlich hoffen wir, dass Kunden auf diese Weise in Zukunft Produkte oder Fabriken hinzufügen können, um weitere Produkttypen zu erhalten, ohne die Anwendung zu zerstören:

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();

Führen Sie Client.php aus und erhalten Sie die folgenden Ergebnisse

Hier ist das Bildprodukt
Hier ist das Textprodukt

Hinweis: Das Client-Objekt stellt keine Anfrage direkt an das Produkt, sondern fordert sie über die Fabrik an. Wichtig ist, dass der Kunde die Produktfunktionen nicht implementiert Überlassen Sie es der Produktimplementierung.

Passen Sie das Produkt an.

Der wahre Wert von Entwurfsmustern besteht nicht darin, die Betriebsgeschwindigkeit zu erhöhen, sondern darin, die Entwicklung zu beschleunigen.

Wenn sich die Anforderungen jetzt ändern und Sie Änderungen am Bildprodukt vornehmen müssen, müssen Sie nur die getProperties-Methode des entsprechenden Produkts PhotoProduct ändern.

Die Änderung des Objekts scheint sehr zu sein Einfach, aber die getProperties()-Methode von Product behält immer noch die gleiche Schnittstelle bei und fordert die Fabrik auf, ein Attributobjekt zurückzugeben

Neues Produkt hinzufügen und parametrisierte Anforderung

Die Frage Ist es notwendig, jedes Mal eine neue Fabrikklasse zu einem neuen Bereich hinzuzufügen, wenn Sie weitere Bilder und Textbeschreibungen hinzufügen möchten? das parametrische Fabrikentwurfsmuster

Parametrisches Fabrikentwurfsmuster Einer der Hauptunterschiede zum allgemeinen Fabrikentwurfsmuster besteht darin, dass der Client Verweise auf die Fabrik und das Produkt enthält. In einer parametrisierten Anfrage muss die Client-Klasse angeben Der Parameter in der createProduct()-Operation wird vom Kunden übergeben, daher muss die Anfrage weiterhin über die Factory-Schnittstelle erfolgen. Obwohl der Kunde eine Produktreferenz enthält, ist der Kunde dennoch über Factory vom Produkt getrennt.

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

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

新工厂接口

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实现红包金额拆分算法案例详解

Das obige ist der detaillierte Inhalt vonAnwendungsfälle und Analyse von PHP-Fabrikmustern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!