Summary of PHP simple factory pattern and factory pattern

First of all, let’s take a look at the simple factory pattern. The code is as follows:

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

The following mainly introduces the factory pattern of PHP design pattern. It briefly introduces the concept and principle of the factory pattern and summarizes and analyzes the factory pattern in the form of examples. Friends who need it can refer to the specific definition and usage method. I hope it can help everyone.

The example in this article describes the factory pattern of PHP design pattern. Share it with everyone for your reference, 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 (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 model that specializes in producing gateway interfaces, abstract it, and make it into an interface form to allow all. 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

Related recommendations:

A brief analysis of JS abstract factory pattern_Basic knowledge

What is the role of php design pattern factory pattern?

A brief introduction to the three PHP factory modes

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