PHP 工厂模式

工厂模式简单示例

用工厂类中的方法实例化对象，当调用对象中的方法时，直接通过工厂类中的静态方法来调用对象中的方法。

如果想要更改实例化的类名，则只需要修改类名与工厂方法中 new 的类名即可。

<?php
    
/**
 * 接口
 */
interface people
{
	public function say();    
}

/**
 * 类实现接口
 */
class man implements people
{
    public function say()
    {
        echo 'man';
    }
}

/**
 * 类实现接口
 */
class woman implements people
{
    public function say()
    {
        echo 'woman';
    }
}

/**
 * 简单工厂类
 */
class echoFactory
{
    static function man()
    {
        return new man();
    }
    
    static function woman()
    {
        return new woman();
    }
}

# 调用
$man = echoFactory::man();
$man -> say();

工厂模式详解

工厂模式，就是负责生成其他对象的类或方法。

类实现

比如，我们有一些类，它们都继承自交通工具类：

简单示例1

<?php

class SimpleFactory
{
    public function createBicycle(): Bicycle
    {
        return new Bicycle();
    }
}

class Bicycle
{
    public function driveTo(string $destination)
    {
        echo 'Factory';
    }
}

$factory = new SimpleFactory();
$bicycle = $factory->createBicycle();
$bicycle->driveTo('Paris');

工厂模式

示例目录：factory 所有文件在此目录下。

AnimalInterface.php 动物接口

<?php
namespace factory;

# 动物接口
interface AnimalInterface{}

Chicken.php 实体鸡类继承–动物接口

<?php
namespace factory;
# 实体鸡
class Chicken implements AnimalInterface
{
  # 构造函数
  public function __construct()
  {
    echo "生产了一只鸡~ \n";
  }
}

Factory.php 农场生产接口

<?php
namespace factory;

interface Factory {
	# 生产
    public function produce();
}

Farm.php 生产动物类继承 Factory 农场接口

<?php
namespace factory;

# 农场：生产动物
class Farm implements Factory
{

  # 构造函数
  public function __construct()
  {
    echo "初始化了一个农场~ \n";
  }

  # 生产方法-生产动物-动物类型
  public function produce($type='')
  {
    switch ($type) {
      case 'chicken':
        return new Chicken();
        break;
      case 'pig':
        return new Pig();
        break;
      default:
        echo "该农场不支持生产该农物~ \n";
        break;
    }
  }

}

Pig .php 实体猪类继承–动物接口

<?php
namespace factory;

# 实体猪
class Pig implements AnimalInterface
{
  # 构造函数
  public function __construct()
  {
    echo "生产了一只猪~ \n";
  }
}

SampleFactory.php 动物工厂无须实现动物工厂接口–生产动物

<?php
namespace factory;

# 简单动物工厂--无须实现动物工厂接口--生产动物
class SampleFactory
{
	# 生产方法--生产动物--动物类型
    public static function produce($type='')
    {
        switch ($type) {
            case 'chicken':
                return new Chicken();
                break;

            case 'pig':
                return new Pig();
                break;

            default:
                echo "该农场不支持生产该农物~ \n";
                break;
        }
    }
}

Zoo.php 动物园–继承农场生产接口

<?php
namespace factory;

# 动物园：生产动物
class Zoo implements Factory
{
    # 构造函数
    public function __construct()
    {
        echo "初始化了一个动物园~ \n";
    }
    
	# 生产方法：生产动物：动物类型
    public function produce($type='')
    {
        switch ($type) {
            case 'chicken':
                return new Chicken();
                break;

            case 'pig':
                return new Pig();
                break;

            default:
                echo "该农场不支持生产该农物~ \n";
                break;
        }
    }
}

运行 php test.php

• 创建型模式
• 工厂方法模式和抽象工厂模式的核心区别
• 工厂方法模式利用继承，抽象工厂模式利用组合
• 工厂方法模式产生一个对象，抽象工厂模式产生一组对象
• 工厂方法模式利用子类创造对象，抽象工厂模式利用接口的实现创造对象
• 工厂方法模式可以退化为简单工厂模式

// 注册自加载
spl_autoload_register('autoload');

function autoload($class)
{
    # print_r(dirname($_SERVER['SCRIPT_FILENAME']) . '/' . str_replace('\\', '/', $class));exit;
    # 浏览器打印 D:/Centos/PHPstudyWWW/easy-tips/patterns/factory/factory/Farm
    # cli 打印 ./factory/Farm
    # 注意：factory/factory 重复路径
    # print_r(dirname($_SERVER['SCRIPT_FILENAME']) . '/../' . str_replace('\\', '/', $class) . '.php');exit;
    # D:/Centos/PHPstudyWWW/easy-tips/patterns/factory/../factory/Farm.php
    require dirname($_SERVER['SCRIPT_FILENAME']) . '/../' . str_replace('\\', '/', $class) . '.php';
}

/************************************* test *************************************/

use factory\Farm;
use factory\Zoo;
use factory\SampleFactory;

初始化 Farm 工厂

// 初始化一个工厂
$farm = new Farm();

// 生产一只鸡
$farm->produce('chicken');

$ php test.php
初始化了一个农场~
生产了一只鸡~

// 生产一只猪
$farm->produce('pig');

$ php test.php
初始化了一个农场~
生产了一只猪~

初始化 Zoo 工厂

// 初始化一个动物园工厂
$zoo = new Zoo();
$zoo->produce("chicken");

$ php test.php
初始化了一个农场~
初始化了一个动物园~
生产了一只鸡~

$zoo->produce("pig");

$ php test.php
初始化了一个农场~
初始化了一个动物园~
生产了一只猪~

// 工厂方法模式退化为简单工厂模式
SampleFactory::produce("chicken");
SampleFactory::produce("pig");

打印全部

<?php
/**
 * 创建型模式
 * 工厂方法模式和抽象工厂模式的核心区别
 * 工厂方法模式利用继承，抽象工厂模式利用组合
 * 工厂方法模式产生一个对象，抽象工厂模式产生一族对象
 * 工厂方法模式利用子类创造对象，抽象工厂模式利用接口的实现创造对象
 * 工厂方法模式可以退化为简单工厂模式(非23中GOF)
 *
 * php工厂模式
 * @author  TIGERB <https://github.com/TIGERB>
 * @author  jealone <https://github.com/jealone>
 * @example 运行 php test.php
 */


// 注册自加载
spl_autoload_register('autoload');

function autoload($class)
{
    require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
}

/************************************* test *************************************/

use factory\Farm;
use factory\Zoo;
use factory\SampleFactory;

// 初始化一个工厂
$farm = new Farm();

// 生产一只鸡
$farm->produce('chicken');
// 生产一只猪
$farm->produce('pig');

// 初始化一个动物园工厂
$zoo = new Zoo();
$zoo->produce("chicken");
$zoo->produce("pig");

// 工厂方法模式退化为简单工厂模式
# SampleFactory::produce("chicken");
# SampleFactory::produce("pig");

$ php test.php
初始化了一个农场~
生产了一只鸡~
生产了一只猪~
初始化了一个动物园~
生产了一只鸡~
生产了一只猪~

PHP抽象工厂模式

根目录： factoryAbstract

Factory.php 工厂接口

<?php
namespace factoryAbstract;

interface Factory 
{
    public function createFarm();
    public function createZoo();
}

Income.php 收入接口

<?php
namespace factoryAbstract;

Interface Income {
    public function money();
}

ZooInterface.php 动物园接口-继承-收入接口

<?php
namespace factoryAbstract;

# 动物园接口
interface ZooInterface extends Income
{
    public function show();
}

FarmInterface.php 农场接口-继承-收入接口

<?php
namespace factoryAbstract;

# 农场接口
interface FarmInterface extends Income
{
    public function harvest();
}

AnimalFactory.php 动物工厂类-继承-工厂接口

<?php
namespace factoryAbstract;

class AnimalFactory implements Factory
{
    public function createFarm()
    {
        return new PigFarm();
    }

    public function createZoo()
    {
        return new PandaZoo();
    }
}

PlantFactory.php 种植工厂类-继承-工厂接口

<?php
namespace factoryAbstract;

class PlantFactory implements Factory
{
    public function createFarm()
    {
        return new RiceFarm();
    }

    public function createZoo()
    {
        return new PeonyZoo();
    }
}

PandaZoo.php 熊猫园开馆类-继承-动物园接口

<?php
namespace factoryAbstract;

class PandaZoo implements ZooInterface {

    public function show()
    {
        echo "熊猫园开馆\n";
    }

    public function money()
    {
        $this->show();
        echo "卖门票\n\n";
    }
}

PeonyZoo.php 牡丹园开馆类-继承–动物园接口

<?php
namespace factoryAbstract;
class PeonyZoo implements ZooInterface {

    public function show()
    {
        echo "牡丹园开馆\n";
    }

    public function money()
    {
        $this->show();
        echo "卖门票\n\n";
    }

}

PigFarm.php 养猪场类-继承-农场接口

<?php
namespace factoryAbstract;

class PigFarm implements FarmInterface {

    public function harvest()
    {
        echo "养殖部门收获猪肉(不清真)\n";
    }

    public function money()
    {
        $this->harvest();
        echo "卖猪肉\n\n";
    }
}

RiceFarm.php 稻田类-继承-农场接口

<?php
namespace factoryAbstract;

class RiceFarm implements FarmInterface
{
    public function harvest()
    {
        echo "种植部门收获大米\n";
    }

    public function money()
    {
        $this->harvest();
        echo "卖大米\n\n";
    }
}

预览打印

• 创建型模式：php抽象工厂模式
• 说说我理解的工厂模式和抽象工厂模式的区别：
• 工厂就是一个独立公司，负责生产对象；
• 抽象工厂就是集团，负责生产子公司（工厂）；

test.php

// 注册自加载
spl_autoload_register('autoload');

function autoload($class)
{
    require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
}

use factoryAbstract\AnimalFactory;
use factoryAbstract\PlantFactory;

// 初始化一个动物生产线, 包含了一组产品
$animal = new AnimalFactory();

// 初始化一个植物生产线, 包含了一组产品
$plant = new PlantFactory();

// 模拟调用， 抽象工厂模式核心是面向接口编程
function call(factoryAbstract\Factory $factory) 
{
    $earn = function(factoryAbstract\Income $income) 
    {
        $income->money();
    };
    $earn($factory->createFarm());
    $earn($factory->createZoo());
}

call($animal);

运行 php test.php

$ php test.php
养殖部门收获猪肉(不清真)
卖猪肉

熊猫园开馆
卖门票

call($plant);

$ php test.php
种植部门收获大米
卖大米

牡丹园开馆
卖门票

// 初始化一个动物生产线, 包含了一组产品
$animal = new AnimalFactory();

// 模拟调用， 抽象工厂模式核心是面向接口编程
function call(factoryAbstract\Factory $factory) {
    var_dump($factory);exit; # object(factoryAbstract\AnimalFactory)#1 (0) {}
    $earn = function(factoryAbstract\Income $income) {
    	var_dump($income);exit; # object(factoryAbstract\PigFarm)#4 (0) {}       
    	$income->money();
    };
    $earn($factory->createFarm());
    $earn($factory->createZoo());
}

call($animal);

$ php test.php
object(factoryAbstract\AnimalFactory)#1 (0) {}