Résumé du modèle d'usine simple PHP et du modèle d'usine-tutoriel php-php.cn

Tout d'abord, jetons un coup d'œil au modèle d'usine simple. Le code est le suivant :

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

<?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;
}

Copier après la connexion

Ce qui suit présente principalement le modèle d'usine du modèle de conception PHP. Le principe du modèle d'usine et le résume et l'analyse sous forme d'exemples. Les amis qui en ont besoin peuvent se référer à la définition et à l'utilisation spécifiques du mode usine. J'espère que cela pourra aider tout le monde.

Cet article décrit le modèle d'usine du modèle de conception PHP avec des exemples. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Quel est le but ou l'objectif de l'utilisation du mode usine ?

Le plus grand avantage du modèle d'usine réside dans la création d'objets, qui consiste à encapsuler le processus de création d'objets, afin qu'un nouvel objet puisse être généré à tout moment.

Réduisez le code et copiez-collez, la relation de couplage est importante et elle affecte d'autres parties du code.

En termes simples, vous utilisiez new pour créer un objet, mais maintenant ce processus est encapsulé.

En supposant que le mode usine n'est pas utilisé : alors la classe a est appelée à de nombreux endroits, et le code créera une instance comme celle-ci : new a() Supposons qu'un jour le nom de la classe a doive le faire. être modifié, ce qui signifie beaucoup de code d'appel. Tous doivent être modifiés.

L'avantage du patron usine réside dans la création d'objets.

L'avantage du patron usine réside dans la création d'objets. Établissez une usine (une fonction ou une méthode de classe) pour créer de nouveaux objets. Sa tâche est d'encapsuler le processus de création d'objets

La création d'objets n'utilise pas de new. Définissez plutôt une méthode de création d’instances d’objet.

Chaque classe devra peut-être se connecter à la base de données. Encapsulez ensuite la connexion à la base de données dans une classe. À l'avenir, utilisez des noms de classes dans d'autres classes :

Pourquoi introduire des concepts abstraits ?

Pensez-y, dans la vraie vie, lorsque nous sommes incapables de déterminer une chose précise, nous classons souvent une catégorie de choses dans une catégorie abstraite.

Méthode d'usine :

Par exemple, si votre usine s'appelle "Cigarette Factory", alors il peut y avoir "Septwolves Factory", "China Factory", etc. Cependant, cette usine ne produit que un produit : les cigarettes ;

Usine abstraite : Il est impossible de décrire quels produits elle produit. Elle fabrique de nombreux types de produits (l'usine abstraite générera donc des sous-usines).

Votre usine est complète et produit une « série » de produits plutôt qu'un « un », comme les « cigarettes » et la « bière ». Ensuite, il peut aussi y avoir des usines spécifiques qui en dérivent, mais ces usines fabriquent toutes cette série de produits, mais le goût peut être différent en raison des différentes régions et pour s'adapter aux goûts locaux.

Modèle d'usine : compris comme une usine qui ne génère qu'un seul produit. Par exemple, ceux qui produisent des cigarettes.

Méthode usine : une ligne de production de produits en usine. Par exemple, le processus de génération de clavier.

D'autres réfuteront : je n'ai rien à faire quand je suis rassasié, donc je dois changer le nom de la classe ? Peut être. Généralement, les noms de classes ne sont pas modifiés.

En fait, il existe de nombreuses variantes du modèle d'usine. La clé est d'en saisir l'essence : tant que différentes instances de classe peuvent être générées en fonction de différents paramètres, cela est conforme à l'idée de conception de . le modèle d'usine.

Cela me rappelle qu'il existe souvent des méthodes dans le framework qui sont chargées de générer des instances de classe spécifiques pour l'appel.

Comme j'ai déjà utilisé phpcms, il est préférable d'utiliser phpcms pour aider à comprendre, comme suit :

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

Copier après la connexion

générera une instance de commande . La transmission de différents paramètres pour obtenir différentes instances de classe est cohérente avec le modèle d'usine.

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

Copier après la connexion

Bien entendu, la méthode load_app_class intègre également l'idée dumode singleton. Évitez d'appeler n fois et de créer à plusieurs reprises n instances identiques

Une application typique à laquelle je pense en mode usine est la suivante : PHP peut avoir besoin de se lier à MySQL, ou il peut avoir besoin de se lier à sqlserver ou à d'autres bases de données. Créez ensuite une classe de base de données abstraite

Cette classe est une classe d'usine, chargée de générer différents objets.

C'est très pratique pour l'expansion. Lorsqu'on se connecte directement à la base de données, au lieu d'utiliser le code

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

Copier après la connexion

sous la forme

, on peut générer dynamiquement une instance à laquelle se connecter la base de données. Il peut s'agir de MySQL ou connecté à Oracle.

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

Copier après la connexion

Il existe également une implémentation correspondante dans le framework thinkphp :

Db.class.php est une classe d'usine (peut également être appelée la couche intermédiaire de la base de données, elle est appelée couche intermédiaire car elle peut faire fonctionner MySQL, Oracle et d'autres bases de données. Cette classe est la couche intermédiaire, protégeant l'implémentation spécifique, permettant aux programmeurs de se connecter à MySQL, Oracle, etc. sans modifier le code de requête d'origine. . Base de données

Il existe une factory() méthode dans Db.class.php pour créer différentes instances de base de données

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

Copier après la connexion

ainsi qu'un paiement. interface À l'avenir, cela pourrait correspondre à différentes passerelles de paiement : Alipay, Tenpay, banque en ligne, etc. Pour faciliter l'expansion future, concevoir une usine spécifiquement pour la production d'interfaces de passerelle, les résumer et en faire des interfaces La classe doit. implémenter son interface. À l'avenir, vous pourrez ajouter un mode de paiement et modifier les paramètres

Le livre (le nom anglais est PHP 5 Power Programming) mentionne également un exemple de mode usine. J'ai appris une astuce : lors de l'enregistrement des utilisateurs, divisez-les en utilisateurs avec de nombreux rôles. Tels que les utilisateurs enregistrés, les utilisateurs anonymes, les utilisateurs administrateurs, etc. Une utilisation complète peut être obtenue en utilisant l'idée d'usines, le code est également facile à maintenir et des classes d'opération peuvent être générées pour chaque rôle.

Définissez les classes suivantes :

UserFactory Classe d'usine d'utilisateurs, chargée de générer différentes classes d'utilisateurs
Utilisateur : la classe de base des classes d'utilisateurs, toutes les classes d'utilisateurs héritent de cette classe
Classes avec différents rôles : classe d'utilisateurs enregistrés, classe d'utilisateurs anonymes, classe d'utilisateurs administrateur

Recommandations associées :

Une brève analyse du modèle d'usine abstraite JS_Connaissances de base

Quel est le rôle du modèle de fabrique de modèles de conception PHP ?

Une brève introduction aux trois modes d'usine 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!