PHP 设计模式 - 工厂模式

---

提示：以下是本篇文章正文内容，下面案例可供参考

工厂模式

概念： 工厂模式:提供获取某个对象实例的一个接口，同时使调用代码避免确定实例化基类的步骤；实际上就是建立一个统一的类实例化的函数接口。统一调用，统一控制。

工厂模式属于创建型设计模式。

1、简单工厂模式

简单工厂模式又叫做静态工厂模式。
　
特点: 将调用者与创建者分离，调用者直接向工厂请求，减少代码的耦合，提高系统的可维护性与可扩展性。
缺点:当要修改类的时候，工厂类也需要做出相对应的更改，违反了开闭原则(对于扩展代码开放，对于类内修改关闭)。

// 加法类
class add
{
    public function getVal($i, $j)
    {
        return $i + $j;
    }
}
// 乘法类
class mul
{
    public function getVal($i, $j){
        return $i * $j;
    }
}
// 文本
class text
{
    public function getVal(){
        return '文本';
    }
}
// 输出结果
class factory
{
    public static function outputResult($class) 
    {
        $res = null;
        switch ($class) {
            case 'add':
                $res = new add;
                break;
            case 'mul':
                $res = new mul;
                break;
            case 'text':
                $res = new text;
                break;
            default:
               return null;
        }
        return $res;
    }
}
$factory1 = factory::outputResult('add');
echo $factory1->getVal(1, 4). '
'; // 5
$factory1 = factory::outputResult('mul');
echo $factory1->getVal(1, 4). '
'; // 4
$factory1 = factory::outputResult('text');
echo $factory1->getVal(). '
'; // 文本

2、工厂方法模式

特点:

完全实现开闭原则，实现了对扩展开放，对更改关闭。
工厂类和产品类往往可以依次对应。
一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。

代码实现就是：一个工厂方法的功能由一个接口继承实现。

// 如果要添加新的计算方式直接添加新的计算类不必修改原来的代码,降低耦合度，可以测试下面注释的示例
interface base
{
    function getVal($i, $j);
}
// 加法
class add implements base
{
    function getVal($i, $j)
    {
        return $i + $j;
    }
}
// 减法
class sub implements base
{
    function getVal($i, $j)
    {
        return $i - $j;
    }
}
// // 乘法
// class mul implements base
// {
//     function getVal($i, $j)
//     {
//         return $i * $j;
//     }
// }
interface baseFactory
{
    function getResult();
}
// 加法工厂
class addFactory implements baseFactory
{
    function getResult()
    {
        return new add();
    }
}
// 减法工厂
class subFactory implements baseFactory
{
    function getResult()
    {
        return new sub();
    }
}
// // 乘法工厂
// class mulFactory implements baseFactory
// {
//     function getResult()
//     {
//         return new mul();
//     }
// }

$i = 10;
$j = 5;
$addFactory = new addFactory();
$add = $addFactory->getResult();
echo '加： '. $add->getVal($i, $j)."
";
$subFactory = new subFactory();
$sub = $subFactory->getResult();
echo '减： '. $sub->getVal($i, $j)."
";
// $mulFactory = new mulFactory();
// $mul = $mulFactory->getResult();
// echo '乘： '. $mul->getVal($i, $j)."
";

3、抽象工厂模式

抽象工厂是在工厂方法模式再进行一次复杂的处理。它是工厂方法的升级版。
这里和工厂方法的区别是：一系列，而工厂方法则是一个。

代码实现就是：一个抽象工厂的功能可以实现多个接口的功能。
如下：两个不同的接口实现了不同加减法，然后通过调用不同接口的同类方法（add和add2， sub和sub2）组成抽象工厂（加法工厂和减法工厂）

// 接口1
interface base
{
    function getVal($i, $j);
}
class add implements base
{
    function getVal($i, $j)
    {
        return $i + $j;
    }
}
class sub implements base
{
    function getVal($i, $j)
    {
        return $i - $j;
    }
}

// 接口2
interface base2
{
    function getVal($i, $j);
}
class add2 implements base2
{
    function getVal($i, $j)
    {
        return $i + $j + 2;
    }
}
class sub2 implements base2
{
    function getVal($i, $j)
    {
        return $i - $j - 2;
    }
}

interface baseFactory
{
    function getResult();
    function getResult2();
}
// 加法工厂
class addFactory implements baseFactory
{
    function getResult()
    {
        return new add();
    }
    function getResult2()
    {
        return new add2();
    }
}
// 减法工厂
class subFactory implements baseFactory
{
    function getResult()
    {
        return new sub();
    }
    function getResult2()
    {
        return new sub2();
    }
}
$i = 10;
$j = 5;
$addFactory = new addFactory();
$add = $addFactory->getResult();
echo '加： '. $add->getVal($i, $j)."
";
$subFactory = new subFactory();
$sub = $subFactory->getResult();
echo '减： '. $sub->getVal($i, $j)."
";

$addFactory1 = new addFactory();
$add1 = $addFactory1->getResult2();
echo '加1： '. $add1->getVal($i, $j)."
";
$subFactory1 = new subFactory();
$sub1 = $subFactory1->getResult2();
echo '减1： '. $sub1->getVal($i, $j)."
";

总结

工厂方法模式：

• 一个抽象产品类，可以派生出多个具体产品类。
• 一个抽象工厂类，可以派生出多个具体工厂类。
• 每个具体工厂类只能创建一个具体产品类的实例。
   

抽象工厂模式：

• 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
• 一个抽象工厂类，可以派生出多个具体工厂类。
• 每个具体工厂类可以创建多个具体产品类的实例。

 
三种工厂的比较

• 简单工厂 ：用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力[修改原方法]）
• 工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
• 抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力[修改原方法]；支持增加产品族）