Detailed explanation of PHP design pattern factory pattern

This article mainly introduces the factory pattern of PHP design pattern, briefly introduces the concept and principle of the factory pattern, and summarizes and analyzes the specific definition and usage of the factory pattern in the form of examples. Friends in need can refer to it

The details are as follows:

What is the purpose or goal of using the factory pattern?

The biggest advantage of the factory pattern is to create objects, which is to encapsulate the process of creating objects, so that a new object can be generated at any time.

Reduce the code and copy and paste, the coupling relationship is heavy, and it affects other parts of the code.

In layman's terms, you used to use new to create an object, but now this process is encapsulated.

Assuming that the factory mode is not used: then class a is called in many places, and the code will create an instance like this: new a(). Suppose that one day the name of class a needs to be modified, which means a lot of calling code. All need to be modified.

The advantage of the factory pattern lies in creating objects.

The advantage of the factory pattern lies in creating objects. Establish a factory (a function or a class method) to create new objects. Its task is to encapsulate the object creation process.

Creating objects does not use the new form. Instead, define a method for creating object instances.

Each class may need to connect to the database. Then encapsulate the connection to the database in a class. In the future, use the class name in other classes:

Why introduce abstract concepts?

Think about it, in real life, when we are unable to determine a specific thing, we often classify a category of things into an abstract category.

Factory method:

For example, if your factory is called "Cigarette Factory", then there can be "Septwolves Factory", "China Factory", etc. However, this factory only produces one product: cigarettes ;

Abstract factory: It is impossible to describe what products it produces. It produces many types of products (so the abstract factory will generate sub-factories).

Your factory is comprehensive and produces "a series" of products rather than "one", such as: producing "cigarettes" and "beer", etc. Then it can also have specific factories derived from it, but these factories all produce this series of products, but the taste may be different because of different regions and to adapt to local tastes.

Factory pattern: understood as a factory that only generates one product. For example, those who produce cigarettes.

Factory method: a product production line in the factory. For example, the keyboard generation process.

Others will refute: I have nothing to do when I am full, so I must change the class name? Maybe. Generally, class names are not modified.

In fact, there are many variations of the factory pattern. Grasping the essence is the key: as long as different class instances can be generated according to different parameters, then it is consistent with the design idea of ​​the factory pattern.

This reminds me that there are often methods in the framework that are responsible for generating specific class instances for calling.

Since I have used phpcms before, it is better to use phpcms to help understand, as follows:

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

will generate an instance of order . Passing different parameters to get different class instances is consistent with the factory pattern.

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

Of course, the load_app_class method also incorporates the idea of ​​​​the singleton mode. Avoid calling n times and repeatedly creating n identical instances

Factory mode A typical application I think of is: PHP may need to link to mysql, or it may need to link to sqlserver, and other databases. Then make an abstract database class.

This class is a factory class that is responsible for generating different objects.

It is very convenient to expand in this way. When we directly connect to the database, instead of using the code

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

, we can dynamically generate an instance to connect to the database. It can be mysql or connected to oracle.

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

There is also a corresponding implementation in the thinkphp framework:

Db.class.php is a factory class (can also be called the database middle layer , it is called the middle layer because it can operate MySQL, Oracle and other databases. This class is the middle layer, shielding the specific implementation. Allowing programmers to not change the original query code. The middle layer connects MySQL, Oracle Wait for the database.

There is a

method in Db.class.php to create different database instances

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

When making payment interfaces, they may correspond to different payment gateways in the future: Alipay, Tenpay, online banking, etc. To facilitate future expansion, design it in factory mode. Decide on a factory specializing in the production of gateway interfaces, abstract it, and make In the form of an interface, all subclasses must implement its interface. Later, add a payment method and which payment method to use, just change the parameters.

Books (English name is PHP 5 Power Programming) also mentioned an example of factory mode, and learned a trick: when registering users, users are divided into many roles. For example, registered users, anonymous users, administrator users, etc. It can be completely implemented using the idea of ​​​​factories, and the code is easy to maintain. Operation classes can be generated for each role.

Define the following classes:

UserFactory User factory class, responsible for generating different user classes
User: the base class of the user class, all user classes inherit this class
Classes with different roles: registered user class, anonymous user class, management Employee User Class

Related recommendations:

PHP Factory Pattern Use Cases and Analysis

PHP singleton and factory mode

The above is the detailed content of Detailed explanation of PHP design pattern factory pattern. For more information, please follow other related articles on the PHP Chinese website!