Zusammenfassung des einfachen PHP-Fabrikmusters und des Fabrikmusters

Werfen wir zunächst einen Blick auf das einfache Fabrikmuster:

<?php
/**
 * 一个事例
 *
 * 一个农场，要向市场销售水果
 * 农场里有三种水果 苹果、葡萄
 * 我们设想：1、水果有多种属性，每个属性都有不同，但是，他们有共同的地方 | 生长、种植、收货、吃
 *       2、将来有可能会增加新的水果、我们需要定义一个接口来规范他们必须实现的方法
 *       3、我们需要获取某个水果的类，要从农场主那里去获取某个水果的实例，来知道如何生长、种植、收货、吃
 */
  
  
/**
 * 虚拟产品接口类
 * 定义好需要实现的方法
 */
  
interface fruit{
  
  /**
   * 生长
   */
  public function grow();
  
  /**
   * 种植
   */
  public function plant();
  
  /**
   * 收获
   */
  public function harvest();
  
  /**
   * 吃
   */
  public function eat();
    
}
  
/**
 * 定义具体产品类 苹果
 * 首先，我们要实现所继承的接口所定义的方法
 * 然后定义苹果所特有的属性，以及方法
 */
class apple implements fruit{
  
  //苹果树有年龄
  private $treeAge;
  
  //苹果有颜色
  private $color;
  
  public function grow(){
    echo "grape grow";
  }
  
  public function plant(){
    echo "grape plant";
  }
  
  public function harvest(){
    echo "grape harvest";
  }
  
  public function eat(){
    echo "grape eat";
  }
  
  //取苹果树的年龄
  public function getTreeAge(){
    return $this->treeAge;
  }
  
  //设置苹果树的年龄
  public function setTreeAge($age){
    $this->treeAge = $age;
    return trie;
  }
  
}
  
/**
 * 定义具体产品类 葡萄
 * 首先，我们要实现所继承的接口所定义的方法
 * 然后定义葡萄所特有的属性，以及方法
 */
class grape implements fruit{
  
  //葡萄是否有籽
  private $seedLess;
  
  public function grow(){
    echo "apple grow";
  }
  
  public function plant(){
    echo "apple plant";
  }
  
  public function harvest(){
    echo "apple harvest";
  }
  
  public function eat(){
    echo "apple eat";
  }
  
  //有无籽取值
  public function getSeedLess(){
    return $this->seedLess;
  }
  
  //设置有籽无籽
  public function setSeedLess($seed){
    $this->seedLess = $seed;
    return true;
  }
}
  
/**
 *农场主类 用来获取实例化的水果
 *
 */
class farmer{
  
  //定义个静态工厂方法
  public static function factory($fruitName){
    switch ($fruitName) {
      case &#39;apple&#39;:
        return new apple();
        break;
      case &#39;grape&#39;:
        return new grape();
        break;
      default:
        throw new badFruitException("Error no the fruit", 1);
        break;
    }
  }
}
  
class badFruitException extends Exception{
  public $msg;
  public $errType;
  public function __construct($msg = &#39;&#39; , $errType = 1){
    $this->msg = $msg;
    $this->errType = $errType;
  }  
}
  
/**
 * 获取水果实例化的方法
 */
try{
  $appleInstance = farmer::factory(&#39;apple&#39;);
  var_dump($appleInstance);
}catch(badFruitException $err){
  echo $err->msg . "_______" . $err->errType;
}

Im Folgenden wird hauptsächlich das Fabrikmuster des PHP-Entwurfsmusters vorgestellt Das Prinzip des Fabrikmusters wird in Form von Beispielen zusammengefasst und analysiert. Freunde, die es benötigen, können sich auf die spezifische Definition und Verwendung des Fabrikmusters beziehen.

Dieser Artikel beschreibt das Fabrikmuster des PHP-Entwurfsmusters anhand von Beispielen. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

Was ist der Zweck oder das Ziel der Verwendung des Werksmodus?

Der größte Vorteil des Factory-Musters liegt in der Objekterstellung, nämlich der Kapselung des Prozesses der Objekterstellung, sodass jederzeit ein neues Objekt generiert werden kann.

Reduzieren Sie den Code und kopieren Sie ihn und fügen Sie ihn ein. Die Kopplungsbeziehung ist wichtig und wirkt sich auf andere Teile des Codes aus.

Um es für den Laien auszudrücken: Früher hat man „new“ verwendet, um ein Objekt zu erstellen, aber jetzt ist dieser Prozess gekapselt.

Angenommen, der Factory-Modus wird nicht verwendet: Dann wird an vielen Stellen Klasse a aufgerufen, und der Code erstellt eine Instanz wie diese: new a() Angenommen, eines Tages muss der Name der Klasse a eingegeben werden geändert werden, was bedeutet, dass viel Code aufgerufen werden muss. Alle müssen geändert werden.

Der Vorteil des Fabrikmusters liegt in der Erstellung von Objekten.

Der Vorteil des Fabrikmusters liegt in der Erstellung von Objekten. Richten Sie eine Factory (eine Funktion oder eine Klassenmethode) ein, um neue Objekte zu erstellen. Ihre Aufgabe besteht darin, den Objekterstellungsprozess zu kapseln.

Beim Erstellen von Objekten werden keine neuen Objekte verwendet. Definieren Sie stattdessen eine Methode zum Erstellen von Objektinstanzen.

Jede Klasse muss möglicherweise eine Verbindung zur Datenbank herstellen. Kapseln Sie dann die Verbindung zur Datenbank in einer Klasse. Verwenden Sie in Zukunft Klassennamen in anderen Klassen:

Warum abstrakte Konzepte einführen?

Denken Sie darüber nach: Wenn wir im wirklichen Leben nicht in der Lage sind, eine bestimmte Sache zu bestimmen, klassifizieren wir oft eine Kategorie von Dingen in eine abstrakte Kategorie.

Fabrikmethode:

Wenn Ihre Fabrik beispielsweise „Zigarettenfabrik“ heißt, dann kann es „Septwolves-Fabrik“, „China-Fabrik“ usw. geben. Diese Fabrik produziert jedoch nur ein Produkt: Zigaretten ;

Abstrakte Fabrik: Es ist unmöglich zu beschreiben, welche Produkte sie produziert. Sie produziert viele Arten von Produkten (die abstrakte Fabrik generiert also Unterfabriken).

Ihre Fabrik ist umfassend und produziert eine „Serie“ von Produkten und nicht „ein einziges“, wie zum Beispiel „Zigaretten“ und „Bier“. Dann können auch bestimmte Fabriken daraus abgeleitet werden, aber diese Fabriken produzieren alle diese Produktserie, aber der Geschmack kann aufgrund unterschiedlicher Regionen und zur Anpassung an den lokalen Geschmack unterschiedlich sein.

Fabrikmuster: verstanden als eine Fabrik, die nur ein Produkt erzeugt. Zum Beispiel diejenigen, die Zigaretten herstellen.

Fabrikmethode: eine Produktproduktionslinie in der Fabrik. Zum Beispiel der Tastaturgenerierungsprozess.

Andere werden widerlegen: Ich habe nichts zu tun, wenn ich satt bin, also muss ich den Klassennamen ändern? Vielleicht. Im Allgemeinen werden Klassennamen nicht geändert.

Tatsächlich gibt es viele Variationen des Factory-Musters. Der Schlüssel liegt darin, das Wesentliche zu erfassen: Solange verschiedene Klasseninstanzen basierend auf unterschiedlichen Parametern generiert werden können, entspricht dies der Designidee von das Fabrikmuster.

Das erinnert mich daran, dass es im Framework oft Methoden gibt, die für die Generierung bestimmter Klasseninstanzen zum Aufruf verantwortlich sind.

Da ich phpcms bereits zuvor verwendet habe, ist es zum Verständnis besser, phpcms wie folgt zu verwenden:

pc_base:load_app_class("order"');//参数名称就是类名称。

generiert eine Instanz der Bestellung . Die Übergabe verschiedener Parameter zum Abrufen verschiedener Klasseninstanzen entspricht dem Factory-Muster.

pc_base:load_app_class("comment"');//生成一个comment类实例

Natürlich beinhaltet die Methode „load_app_class“ auch die Idee des Singleton-Modus. Vermeiden Sie es, n-mal aufzurufen und wiederholt n identische Instanzen zu erstellen.

Eine typische Anwendung, die ich im Factory-Modus denke, ist: PHP muss möglicherweise eine Verbindung zu MySQL herstellen, oder es muss möglicherweise eine Verbindung zu SQL Server oder anderen Datenbanken herstellen. Erstellen Sie dann eine abstrakte Datenbankklasse.

Diese Klasse ist eine Factory-Klasse, die für die Generierung verschiedener Objekte verantwortlich ist.

Dies ist sehr praktisch für die Erweiterung. Wenn wir uns direkt mit der Datenbank verbinden, können wir statt des Codes

new Mysql($host,$username,$password,$dbname)

in der Form

dynamisch eine Instanz generieren, mit der wir eine Verbindung herstellen können die Datenbank. Es kann MySQL sein oder mit Oracle verbunden sein.

class DbFactory
{
  function static factory($db_class_name)
  {
    $db_class_name = strtolower($db_class_name);
    if (include_once 'Drivers/' . $db_class_name . '.php') {
      $classname = 'Driver_' . $db_class_name;
      return new $db_class_name;
    } else {
      throw new Exception ('对应的数据库类没找到');
    } 
  }
}
DbFactory::factory("mysql");
DbFactory::factory("oracle");

Es gibt auch eine entsprechende Implementierung im thinkphp-Framework:

Db.class.php ist eine Factory-Klasse (kann auch aufgerufen werden Datenbank-Mittelschicht, wird als mittlere Schicht bezeichnet, da sie MySQL, Oracle und andere Datenbanken betreiben kann. Diese Klasse ist die mittlere Schicht, die die spezifische Implementierung abschirmt und es Programmierern ermöglicht, eine Verbindung zu MySQL, Oracle usw. herzustellen, ohne den ursprünglichen Abfragecode zu ändern . Datenbank.

Es gibt eine factory() Methode zum Erstellen verschiedener Datenbankinstanzen

public function factory($db_config='') {
    // 读取数据库配置
    $db_config = $this->parseConfig($db_config);
    if(empty($db_config['dbms']))
      throw_exception(L('_NO_DB_CONFIG_'));
    // 数据库类型
    $this->dbType = ucwords(strtolower($db_config['dbms']));
    $class = 'Db'. $this->dbType;
    if(is_file(CORE_PATH.'Driver/Db/'.$class.'.class.php')) {
      // 内置驱动
      $path = CORE_PATH;
    }else{ // 扩展驱动
      $path = EXTEND_PATH;
    }
    // 检查驱动类
    if(require_cache($path.'Driver/Db/'.$class.'.class.php')) {
      $db = new $class($db_config);
      // 获取当前的数据库类型
      if( 'pdo' != strtolower($db_config['dbms']) )
        $db->dbType = strtoupper($this->dbType);
      else
        $db->dbType = $this->_getDsnType($db_config['dsn']);
      if(APP_DEBUG) $db->debug  = true;
    }else {
      // 类没有定义
      throw_exception(L('_NOT_SUPPORT_DB_').': ' . $db_config['dbms']);
    }
    return $db;
}

sowie eine Zahlung Schnittstelle In Zukunft kann es verschiedenen Zahlungsgateways entsprechen: Alipay, Tenpay, Online-Banking usw. Um zukünftige Erweiterungen zu erleichtern, entwerfen Sie eine Fabrik speziell für die Produktion von Gateway-Schnittstellen, abstrahieren Sie sie und machen Sie sie zu Schnittstellen Wenn Sie später eine Zahlungsmethode hinzufügen, ändern Sie einfach die Parameter

.

Das Buch (englischer Name ist PHP 5 Power Programming) erwähnt auch ein Beispiel für den Factory-Modus. Ich habe einen Trick gelernt: Teilen Sie sie bei der Registrierung in Benutzer mit vielen Rollen auf. Wie registrierte Benutzer, anonyme Benutzer, Administratorbenutzer usw. Mit der Idee der Fabriken kann eine vollständige Nutzung erreicht werden, der Code ist zudem einfach zu warten und für jede Rolle können Operationsklassen generiert werden.

Definieren Sie die folgenden Klassen:

UserFactory Benutzerfabrikklasse, verantwortlich für die Generierung verschiedener Benutzerklassen
Benutzer: Die Basisklasse der Benutzerklassen, alle Benutzerklassen erben diese Klasse
Klassen mit verschiedenen Rollen: registrierte Benutzerklasse, anonyme Benutzerklasse, Administrator-Benutzerklasse

Verwandte Empfehlungen:

Eine kurze Analyse des abstrakten JS-Fabrikmusters_Grundkenntnisse

Welche Rolle spielt das PHP-Designmuster-Fabrikmuster?

Eine kurze Einführung in die drei PHP-Factory-Modi

Das obige ist der detaillierte Inhalt vonZusammenfassung des einfachen PHP-Fabrikmusters und des Fabrikmusters. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!