Summary of usage examples of php 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 example in this article describes the factory pattern of PHP design pattern. Share it with everyone for your reference, 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 based on different parameters, then it is in line 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 (it can also be called the database middle layer. The reason why It is called the middle layer because it can operate various databases such as MySQL and Oracle. This class is the middle layer, which allows programmers to connect to MySQL, Oracle and other databases without changing the original query code.

There is a

factory()

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

and make payments When it comes to interfaces, they may correspond to different payment gateways in the future: Alipay, Tenpay, online banking, etc. To facilitate future expansion, design a factory that specializes in producing gateway interfaces, abstract them, and make them into interfaces. All subclasses must implement its interface. If you add a payment method later, just change the parameters
.

The book 4108b714f7c3d0f728383a09d933f293 (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. Such as registered users, anonymous users, administrator users, etc. Complete use can be achieved using the idea of ​​​​factories, the code is also easy to maintain, and 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 user classes, all user classes inherit this class
Classes of different roles: registered user class, anonymous user class, administrator user class

The above is the detailed content of Summary of usage examples of php factory pattern. For more information, please follow other related articles on the PHP Chinese website!