Introduction to the application of factory pattern in Zend Framework

First of all, let’s quote some concepts:
Factory pattern: specifically define a class to be responsible for creating instances of other classes. The created instances usually have the same parent class. The factory pattern is a class creation pattern that usually returns instances of different classes based on different independent variables.
The essence of the factory pattern is that a factory class dynamically determines which product instance should be created based on the incoming parameters. The factory pattern involves factory roles, abstract product roles and specific product roles.
Factory (Creator) role: It is the core of the factory pattern. It is responsible for implementing the internal logic of creating all instances. The factory class can be directly called by the outside world to create the required product objects.
Abstract product (Product) role: It is the parent class of all objects created by the factory pattern. It is responsible for describing the public interface common to all instances.
Concrete Product role: It is the creation target of the factory pattern. All objects are instances of a specific class that plays this role.
Zend_db in ZF is a good example of the factory pattern.
The analysis will begin next. . . . . .
When configuring zf, we can put the database connection operation information in the Bootstrap.php file

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

At the entry file, call bootstrap() through a Zend_Application object, the constructor of the Bootstrap class will be called.
In the constructor, through Zend_Db::factory() we can get an object instance for operating the database.
Read the relevant information in config.ini through a Zend_Config_Ini instance and pass it as a parameter to the factory function Zend_Db::factory()
Configuration.ini information
[general]
db.adapter =PDO_MYSQL
db.params.host =localhost
db.params.username =root
db.params.password =
db.params.dbname = database name
Zend_Db::factory()
Parameter one: Indicates the type of database to be operated, such as PDO_MYSQL
Parameter two: Indicates information about connecting to the database, including server name, user name, password, and the database to be connected

Throw first Two questions:
①If the database we want to operate is MSSQL, how should we operate
②Here we use Zend_Db::factory(), if we use the traditional method, how should we operate

Answer:
① We only need to modify PDO_MYSQL to PDO_MSSQL in the config.ini file
② Create an object instance for operating the database in the traditional way:
$db=new Zend_Db_Adapter_Pdo_Mysql($ config)
Among them: $config information is read from config.ini
Here comes the problem: If we use the traditional method to create an object instance, we must have a process to determine the type of database currently to be operated. ?
For example:

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

We have to write different statements to operate the database according to different database types. Isn’t this very troublesome?
However, all of this has been done by zf through the factory mode. It has been done for us and it is very convenient to use.

How to implement the factory mode in Zf?
First of all, there must be an abstract base class: Zend_Db_Adapter_Abstract. This class is the parent class of all objects created by the factory mode. It is responsible for providing the interface common to all instances.
This class not only provides some implementation methods that we are very familiar with operating databases, such as: select, update, insert, delete, query, fetchRow, fetchAssoc; in addition, it also provides some interfaces for implementation in subclasses , such as: limit, getServerVersion, closeConnection, describeTable, 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数据库的操作 
}

The above relationship can be simply expressed with a picture

Next, we track Next, Zend_Db::Factory() implements the selection of different databases based on different parameters.

For more articles related to the application of factory pattern in Zend Framework, please pay attention to the PHP Chinese website!