A brief analysis of php factory pattern-PHP Tutorial-php.cn

A brief analysis of php factory pattern

PHP中文网

Release： 2023-02-28 17:58:02

Original

1441 people have browsed it

This series of articles summarizes the application of design patterns in PHP. This is the second article of the creational pattern factory pattern.

The general introduction of design patterns is discussed in the first article, so I will not repeat it here.

Factory Pattern

Implementation: Define an interface for creating objects and let subclasses decide which class to instantiate.
Application scenarios: There are many subclasses and they will be expanded, and the creation method is more complicated.

Factory patterns are divided into three types: simple factory, factory method, and abstract factory.

The difference between the three types of factories is that the abstract factory has multiple product lines, while the factory method has only one product line. , is a simplification of the abstract factory. The factory method is opposite to the simple factory. At first glance, it seems that the factory method adds a lot of code but implements the same functions as the simple factory. But the essence is that the simple factory does not strictly follow the opening and closing principles of the design pattern. When new products need to be added, the factory code also needs to be modified. However, the factory method strictly adheres to the opening and closing principle. The mode is only responsible for the abstract factory interface, and the specific factory is left to the customer to expand. During the division of labor, core engineers are responsible for the definition of abstract factories and abstract products, and business engineers are responsible for the implementation of specific factories and specific products. As long as the abstraction layer is well designed, the framework is very stable.

/**
 * 工厂模式
 */
//抽象产品
interface Person {
    public function getName(); 
}
//具体产品实现
class Teacher implements Person {
    function getName() {
        return "老师n";
    }
}
class Student implements Person {
    function getName() {
        return "学生n";
    }
}
//简单工厂
class SimpleFactory {
       public static function getPerson($type) {
              $person = null;
              if ($type == &#39;teacher&#39;) {
                     $person = new Teacher();
              } elseif ($type == &#39;student&#39;) {
                     $person = new Student();
              }
              return $person;
       }
}
//简单工厂调用
class SimpleClient {
       function main() {
              // 如果不用工厂模式，则需要提前指定具体类
              // $person = new Teacher();
              // echo $person->getName();
              // $person = new Student();
              // echo $person->getName();
              // 用工厂模式，则不需要知道对象由什么类产生，交给工厂去决定
              $person = SimpleFactory::getPerson(&#39;teacher&#39;);
              echo $person->getName();
              $person = SimpleFactory::getPerson(&#39;student&#39;);
              echo $person->getName();
       }
}
//工厂方法
interface CommFactory {
    public function getPerson();
}
//具体工厂实现
class StudentFactory implements CommFactory {
    function getPerson(){
        return new Student();
    }
}
class TeacherFactory implements CommFactory {
    function getPerson() {
        return new Teacher();
    }
}
//工厂方法调用
class CommClient {
    static function main() {
           $factory = new TeacherFactory();
           echo $factory->getPerson()->getName();
           $factory = new StudentFactory();
           echo $factory->getPerson()->getName();
    }
}
//抽象工厂模式另一条产品线
interface Grade {
       function getYear();
}
//另一条产品线的具体产品
class Grade1 implements Grade {
       public function getYear() {
              return &#39;2003级&#39;;
       }
}
class Grade2 implements Grade {
       public function getYear() {
              return &#39;2004级&#39;;
       }
}
//抽象工厂
interface AbstractFactory {
       function getPerson();
       function getGrade();
}
//具体工厂可以产生每个产品线的产品
class Grade1TeacherFactory implements AbstractFactory {
       public function getPerson() {
              return new Teacher();
       }
       public function getGrade() {
              return new Grade1();
       }
}
class Grade1StudentFactory implements AbstractFactory {
       public function getPerson() {
              return new Student();
       }
       public function getGrade() {
              return new Grade1();
       }
}
class Grade2TeacherFactory implements AbstractFactory {
       public function getPerson() {
              return new Teacher();
       }
       public function getGrade() {
              return new Grade2();
       }
}
//抽象工厂调用
class FactoryClient {
       function printInfo($factory) {
              echo $factory->getGrade()->getYear().$factory->getPerson()->getName();
       }
       function main() {
              $client = new FactoryClient();
              $factory = new Grade1TeacherFactory();
              $client->printInfo($factory);
              $factory = new Grade1StudentFactory();
              $client->printInfo($factory);
              $factory = new Grade2TeacherFactory();
              $client->printInfo($factory);
       }
}
//简单工厂
//SimpleClient::main();
//工厂方法
//CommClient::main();
//抽象工厂
FactoryClient::main();

Copy after login

Have you guys understood the factory pattern in the PHP design pattern? It’s quite simple, isn’t it?

Detailed explanation of the three forms of sample code of PHP factory mode

Simple instructions for using PHP factory mode

Analyzing the benefits of PHP factory pattern