Introduction à l'application du modèle d'usine dans Zend Framework

Tout d'abord, citons quelques concepts :
Modèle d'usine : définit spécifiquement une classe qui sera responsable de la création d'instances d'autres classes. Les instances créées ont généralement la même classe parent. Le modèle d'usine est un modèle de création de classe qui renvoie généralement des instances de différentes classes en fonction de différentes variables indépendantes.
L'essence du modèle d'usine est qu'une classe d'usine détermine dynamiquement quelle instance de produit doit être créée en fonction des paramètres entrants. Le modèle d'usine implique des rôles d'usine, des rôles de produit abstraits et des rôles de produit spécifiques.
Rôle d'usine (créateur) : c'est le cœur du modèle d'usine. Il est responsable de la mise en œuvre de la logique interne de création de toutes les instances. La classe d'usine peut être directement appelée par le monde extérieur pour créer les objets produit requis.
Rôle de produit abstrait (Product) : C'est la classe parent de tous les objets créés par le modèle d'usine. Elle est chargée de décrire l'interface publique commune à toutes les instances.
Rôle du produit concret : c'est la cible de création du modèle d'usine. Tous les objets sont des instances d'une classe spécifique qui joue ce rôle.
zend_db dans ZF est un bon exemple de modèle d'usine.
L'analyse commencera ensuite. . . . . .
Lors de la configuration de zf, nous pouvons mettre les informations sur l'opération de connexion à la base de données dans le fichier Bootstrap.php

<?php 
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap 
{ 
function __construct($app){ 
parent::__construct($app); 
$url=constant(&#39;APPLICATION_PATH&#39;).DIRECTORY_SEPARATOR.&#39;configs&#39;.DIRECTORY_SEPARATOR.&#39;config.ini&#39;; 
$dbconfig=new Zend_Config_Ini($url,null,true); 
$db=Zend_Db::factory($dbconfig->general->db->adapter,$dbconfig->general->db->params->toArray()); 
// var_dump($db); 
$db->query(&#39;SET NAMES UTF8&#39;); 
Zend_Db_Table::setDefaultAdapter($db); 
} 
} 
?>

Dans le fichier d'entrée, appelez bootstrap() via un objet Zend_Application, similaire à Bootstrap Le constructeur va être appelé.
Dans le constructeur, via Zend_Db::factory() nous pouvons obtenir une instance d'objet pour faire fonctionner la base de données.
Lisez les informations pertinentes dans config.ini via une instance Zend_Config_Ini et transmettez-les en tant que paramètre à la fonction d'usine Zend_Db::factory()
Informations Configuration.ini
[général]
db.adapter =PDO_MYSQL
db.params.host =localhost
db.params.username =root
db.params.password =
db.params.dbname = nom de la base de données
Zend_Db::factory( )
Paramètre un : indique le type de base de données à utiliser, tel que PDO_MYSQL
Paramètre deux : indique les informations pour se connecter à la base de données, y compris le nom du serveur, le nom d'utilisateur, le mot de passe et la base de données à connecter

Jetez d'abord deux questions :
①Si la base de données que nous voulons exploiter est MSSQL, que devons-nous faire
②Ici, nous utilisons Zend_Db::factory(). Si nous utilisons la méthode traditionnelle, que devons-nous faire ? devrions-nous faire ?

Réponse :
① Il suffit de modifier PDO_MYSQL en PDO_MSSQL dans le fichier config.ini
② Créer une instance d'objet pour faire fonctionner la base de données de manière traditionnelle :
$db=new Zend_Db_Adapter_Pdo_Mysql($ config)
Parmi eux : les informations $config sont lues depuis config.ini
Le problème est : si nous utilisons la méthode traditionnelle pour créer une instance d'objet, nous devons avoir un processus pour déterminer le type de base de données à exploiter ?
Par exemple :

switch ($dbType){ 
case 'PDO_MYSQL': 
.... 
case 'PDO_MSSQL': 
.... 
case 'PDO_SQLITE': 
.... 
}

Nous devons écrire différentes instructions pour faire fonctionner la base de données en fonction de différents types de bases de données.
Cependant, dans tout cela, zf utilise. le mode usine Cela a été fait pour nous et c'est très pratique à utiliser

Comment implémenter le mode usine dans Zf ?
Tout d'abord, il doit y avoir une classe de base abstraite : Zend_Db_Adapter_Abstract. Cette classe est la classe parent de tous les objets créés par le pattern factory. Elle est chargée de fournir l'interface commune à toutes les instances.
Cette classe fournit non seulement certaines méthodes d'implémentation que nous connaissons très bien avec le fonctionnement des bases de données, telles que : select, update, insert, delete, query, fetchRow, fetchAssoc, en plus, elle fournit également certaines interfaces pour l'implémentation dans les sous-classes ; tels que : limit, getServerVersion, closeConnection,scribeTable, etc.

abstract class Zend_Db_Adapter_Abstract 
{ 
//.. 
} 
abstract class Zend_Db_Adapter_Pdo_Abstract extends Zend_Db_Adapter_Abstract 
{ 
//.. 
} 
class Zend_Db_Adapter_Pdo_Mysql extends Zend_Db_Adapter_Pdo_Abstract 
{ 
//...实现针对Mysql数据库的操作 
} 
class Zend_Db_Adapter_Pdo_Mssql extends Zend_Db_Adapter_Pdo_Abstract 
{ 
//....实现针对Mssql数据库的操作 
} 
class Zend_Db_Adapter_Pdo_Sqlite extends Zend_Db_Adapter_Pdo_Abstract 
{ 
//....实现针对Sqlite数据库的操作 
}

La relation ci-dessus peut être simplement exprimée avec une image

Ensuite, regardons découvrez comment Zend_Db::Factory() sélectionne différentes bases de données en fonction de différents paramètres.

Pour plus d'articles sur l'application du modèle d'usine dans Zend Framework, veuillez faire attention au site Web PHP chinois !