设计模式之工厂模式

关于设计模式这一块，个人觉得还是挺重要的。因为这个关乎到代码的优雅程度。

今天不讲设计模式六大原则，就单纯的来说说我对工厂模式的理解，用最通俗易懂的自然语言，讲述一下工厂模式的原理。

定义

什么是工厂模式？就是一种创建型的设计模式。这么说可能有些晦涩，用通俗易懂的话来说，就是按照一种类似于工厂生产商品的方式来对类进行实例化，而不是用到了就new一个。

简单工厂模式

现在有一个客户，肚子饿了，想吃方便面。他现在脑子里这有一个念头：快点吃到方便面，他根本就不想了解方便面到底是怎么生产出来的（客户端与实现的解耦）。这个时候如果有一个卖方便面的小店（工厂）就好了，客户只需要看一下店里有哪些方便面。然后挑选一包就好了。

优点：

白话：客户不需要知道怎么生产方便面，就可以吃到想要的方便面，甚至能挑选到自己想要的那个牌子的方便面。

书面：客户端和具体实现的解耦。

缺点：

白话：这个小店为了应对越来越多的客户需求，进货的时候进了100多种品牌的方便面，味道各不一样，描述七老比较困难。吃的方法也不一样，有一些是水煮的，有一些是干吃的，有一些是干拌的。因此老板自己也经常记错，更别说客户问的时候听得一头雾水了。客户挑了半天，可能并不能挑到自己心满意足的产品。

书面：随着数据量的增大，工厂类会变得臃肿。逻辑和实现混杂在一起，使得工厂类的内部构造变得难以理解和维护，非常不利于后期的拓展。对于客户端来说，需要知道工厂的内部实现，增加了大量的学习成本，增加了客户端的复杂度。

实现：

首先我们需要定义一个方便面的接口，每包方便面都可以吃：

//noodles.php
interface Noodles{
    public function eat();  
}

然后我们写两个实现类，分别代表康师傅生产的方便面，和统一生产的方便面：

//kangNoodles.php
class KangNoodles implements Noodles{
    public function eat(){
        echo '吃一包美味的康师傅红烧牛肉面';
    }  
}
//Tongyi.php
class TongyiNoodles implements Noodles{
    public function eat(){
        echo '吃一包美味的统一红烧牛肉面';
    }  
}

然后我们生成一个简单工厂：

//NoodlesFactory.php
class NoodlesFactory{
    public function createNoodles($brand){
        switch($brand){
            case 'kang':
                return new KangNoodles();
            case 'tongyi':
                return new TongyiNoodles();        
        }
    }    
}

生成客户端：

//SimpleFactoryDemo.php
class SimpleFactoryDemo{    
    public function setNoodles($brand){
        $noodles = (new NoodlesFactory())->createNoodles($brand);
        $noodles->eat();
    } 
}

工厂模式

还是上述场景，客户肚子饿了想吃方便面。现在我们建立一个康师傅工厂，专门生产（售卖）康师傅红烧牛肉面，再建立一个生产（售卖）统一红烧牛肉面的工厂，等等，在理想的条件下，我们甚至可以建立起100个品牌的方便面加工工厂，客户想吃哪一个牌子，直接去对应的工厂（商店）进行购买就行了。

优点：

相对于简单工厂模式，工厂模式的每一个工厂都做自己的事，避免建立起一个庞大而又臃肿的工厂。有利于代码的扩展和维护。

缺点：

每增加一个产品，相应的也要增加一个子工厂，加大了额外的开发量（个人觉得这一点可以接受，不算什么太大的缺点）

实现：

首先我们需要定义一个方便面的接口

 

//noodles.php
interface Noodles{
    public function eat();  
}

 

然后我们写两个实现类，分别代表生产康师傅生产的方便面，和统一生产的方便面这种商品：

//kangNoodles.php
class KangNoodles implements Noodles{
    public function eat(){
        echo '吃一包美味的康师傅红烧牛肉面';
    }  
}
//Tongyi.php
class TongyiNoodles implements Noodles{
    public function eat(){
        echo '吃一包美味的统一红烧牛肉面';
    }  
}

 

 

然后，生成一个工厂接口：

//NoodlesFactory.php
interface NoodlesFactory{
    public function createNoodles();
}

我们生成两个对应的工厂：

 

//KangNoodlesFactory.php
class KangNoodlesFactory implements NoodlesFactory{
     public function createNoodles(){
         return new KangNoodles();  
    }  
}
//TongyiNoodlesFactory.php
class TongyiNoodlesFactory implements NoodlesFactory{
     public function createNoodles(){
         return new TongyiNoodles();  
    }  
}

 

生成客户端：

//FactoryDemo.php
class FactoryDemo{    
    public function kangFunc(){
        $noodles = (new KangNoodlesFactory())->createNoodles();
        $noodles->eat();  
    } 

    public function TongyiFunc(){
        $noodles = (new TongyiNoodlesFactory())->createNoodles();
        $noodles->eat();  
    } 
    
}

抽象工厂模式

还是上述场景，随着物质条件的提升，客户提出，要在吃泡面的时候加一分榨菜，形成一个套餐。这个时候怎么办?

我们可以把泡面和榨菜想象成一个“套餐”，统一交给一家工厂（商店）去帮忙搞定。市场上于是新推出一条这样的套餐：泡面——榨菜。于是各个厂家纷纷效仿，推出自家工厂的“套餐”。客户只需要到对应的工厂直接下单套餐就行了，无需其他操作。

优点：

拥有工厂模式的优点。

拥有产品族的概念，这一系列的产品源于同一厂家，易于管理约束。保证客户只使用同一家工厂的产品。

一个具体的工厂实现代表的是一个产品族，切换产品族只需要切换一下具体工厂

缺点：

如果要新增加一个产品，比如说套餐中要加入一款饮料。那么所有的工厂都要去遵循这个规定，去研发出一款自家的饮料，比较麻烦。

实现：

首先我们需要定义一个方便面的接口

//noodles.php
interface Noodles{
    public function eat();  
}

然后我们写两个实现类，分别代表生产康师傅生产的方便面，和统一生产的方便面这种商品：

//kangNoodles.php
class KangNoodles implements Noodles{
    public function eat(){
        echo '吃一包美味的康师傅红烧牛肉面';
    }  
}
//Tongyi.php
class TongyiNoodles implements Noodles{
    public function eat(){
        echo '吃一包美味的统一红烧牛肉面';
    }  
}

我们再写一个榨菜的接口：

//Mustard.php
interface Mustard{
    public functioneat();
}

再写两个榨菜的实现类：

//kangMusterd.php
class kangMusterd implements Musterd{
    public function eat(){
        echo '吃一包美味的康师傅榨菜';
    }  
}
//Tongyi.php
class TongyiMusterd implements Musterd{
    public function eat(){
        echo '吃一包美味的统一榨菜';
    }  
}

写一个抽象工厂，包含多个产品：

//AbstractFactory.php
abstract AbstractFactory(){
     abstract public function createNoodle();
     abstract public function createMusterd();
}

生成两个工厂类：

//KangFactory.php
class KangFactory extends AbstractFactory{
    public function createNoodles(){
        return new KangNoodles();
    }

    public function createMusterd(){
        return new KangMusterd();
    }
}
//TongyiFactory.php
class TongyiFactory extends AbstractFactory{
    public function createNoodles(){
        return new TongyiNoodles();
    }

    public function createMusterd(){
        return new TongyiMusterd();
    }
}

客户端：

//AbstractFactoryDemo.php
class AbstractFactoryDemo{
    public function eatKangTaocan(){
        $kangFactory = new KangFactory();
        $noodles = $kangFactory->createNoodles();
        $musterd = $kangFactory->createMusterd();
        $noodles->eat();
        $musterd->eat();
    }  
    public function eatTongyiTaocan(){
        $TongyiFactory = new TongyiFactory();
        $noodles = $TongyiFactory->createNoodles();
        $musterd = $TongyiFactory->createMusterd();
        $noodles->eat();
　　　　 $musterd->eat();

    }   
}  

总结：

简单工厂，就是在一个工厂类直接生产产品，工厂庞大难以维护，适用于小型业务系统。

工厂模式，就是每个工厂生产对应的产品，做到客户端解耦。

抽象工厂模式，就是每个工厂生产“多个”对应的“自家”的产品。