浅谈设计模式4——简单工厂与工厂模式

序
书上是三个模式——简单工厂模式、工厂模式、抽象工厂模式，一块说。对于昨天实在没有休息好的状态下，看到如此混乱的景象，确实有点受不了。好在后面一遍又一遍重复，总算是理解了。但是，既然是记笔记，也是给别人看，那么我觉得拆开来说或许更加明白。

1、背景
书上用pizza来打比方，其实还是挺爱吃，但是名字太绕口，而且也不熟悉。所以还是用饺子我觉得会更加亲切些——我最爱吃的。
现在我要开一家饺子馆，供应各种口味的饺子，三鲜馅，胡萝卜羊肉馅，西胡虾仁馅，芹菜牛肉馅，猪肉大葱馅，猪肉白菜馅——看来好吃的说起来都没完没了。
最开始的想法是，按照如下步骤建立饺子：
1）用饺子抽象类建立饺子对象实体。
2）包饺子。
3）煮饺子。
4）装盘，配酱油和醋。
5）上桌或打包外卖。
实现成的代码如下——为了不让很多的名词困扰，此处直接采用更加形式化的命名方法：

//产品类型
abstract class ProductBase
{
    @Override
    public String toString() {
        return "productbase";
    }
}

class Product1 extends ProductBase
{
    @Override
    public String toString() {
        return "product1";
    }
}

class Product2 extends ProductBase
{
    @Override
    public String toString() {
        return "product2";
    }
}

//商店
class Store
{
    ProductBase product;
    public void  create(String product) {
        if(product.equals("product1"))
            this.product=new Product1();
        else if(product.equals("product2"))
            this.product=new Product2();
        
        //后续的操作
        //包饺子（）;
        //煮饺子（）；
        //装盘，配酱油和醋（）；
        //上桌或打包（）；
    }
}

上面的代码将创建饺子对象和对饺子的后续的加工操作，严重耦合，造成以下两个比较严重的问题：
1）一个函数中的代码量过大，而且随着新类型产品研发，这个函数将越来越大，不容易维护。
2）当餐馆发明新的饺子时，就需要修改sell()方法。原来类的封装性就遭到破坏。

2、简单工厂模式
根据上面的问题，我们自然想到的是将创建产品对象的那部分代码进行封装，这样就实现了工厂模式。简单工厂模式如下：

//产品类型
abstract class ProductBase
{
    @Override
    public String toString() {
        return "productbase";
    }
}

class Product1 extends ProductBase
{
    @Override
    public String toString() {
        return "product1";
    }
}

class Product2 extends ProductBase
{
    @Override
    public String toString() {
        return "product2";
    }
}

class ProductFactory
{
    public ProductBase create(String product)
    {
        if(product.equals("product1"))
            return new Product1();
        else if(product.equals("product2"))
            return new Product2();
        else return null;
    }
}

//商店
class Store
{
    ProductBase product;
    ProductFactory productFactory;
    
    public Store(ProductFactory productFactory)
    {
        this.productFactory=productFactory;
    }
    
    public void  create(String product) {
    /*  if(product.equals("product1"))
            this.product=new Product1();
        else if(product.equals("product2"))
            this.product=new Product2();
    */
        this.productFactory.create(product);
        //后续的操作
        //包饺子（）;
        //煮饺子（）；
        //装盘，配酱油和醋（）；
        //上桌或打包（）；
    }
}

“简单工厂模式”是将对象的生成和使用进行分离，以组合的方式，当创建使用某一类对象的实体时（如Store类的对象），将真正创建对象的工厂传入。从而获得以下两方面的收益：
1）工厂可以在动态运行时的时候指定。比如我现在不打算开饺子店了，想做包子，由于包子和饺子的后续工作都是一样的，所以只需把制作包子的工厂传入Store类中就行。
2）产品、制作、使用三者进行了有效分离。产品的分离已经在前面的策略模式中说道——用抽象接口来“临时”代替具体类，占位置，将创建对象实体推迟到运行时。制作即使用了简单工厂模式，而使用即为Store类。这样就在一定程度上，将类之间的耦合度降到很低。

3、工厂模式
相对于简单工厂模式，工厂模式的耦合度相对来说比较大。之所以比较大，先看下面的例子。
假设饺子店生意不错，规模逐渐增大，最后成立一个实业公司——饺子餐饮有限公司，而且设立了各个分部——华北子公司，东北子公司，华南子公司，华东子公司，中西部子公司。为了保证所有公司生产的饺子质量过关，公司决定控制生产流程。所有子公司可以根据当地特产，选择自己的馅料，但是制作工艺必须严格按照公司的流程，比如每个面皮必须为10g，直径5CM的圆面片。馅料必须20g。
这样，既增加了灵活性——子公司可以根据当地特产选择馅料，又保证了质量——严格按照母公司的规程办事。

说这么多，我想“简单工厂模式”和“工厂模式”应用的场景大家也应该能看出来了。
1）简单工厂模式是针对只有一个使用者的情况来说，即程序中只有一个Store类，这个Store类可以使用多用“工厂类”来为自己加工产品。
2）工厂模式不同，它是针对某个基类的一堆子类，在保证某些流程不改变的情况下， 允许子类有自己的行为特征。也就是说，基类规定了框架，而子类只能在框架的基础上修补、更改。

那么看下面的代码就比较能说明问题了：

abstract class ProductBase
{
    @Override
    public String toString() {
        return "productbase";
    }
}
class a1 extends ProductBase
{
    @Override
    public String toString() {
        return "a1";
    }
}
class a2 extends ProductBase
{
    @Override
    public String toString() {
        return "a2";
    }
}
class b1 extends ProductBase
{
    @Override
    public String toString() {
        return "b1";
    }
}
class b2 extends ProductBase
{
    @Override
    public String toString() {
        return "b2";
    }
}


//创建工厂基类
abstract class FactoryBase
{
    public abstract ProductBase create(String type);
    final public ProductBase sell(String type)
    {
        ProductBase productBase;
        productBase=create(type);
        //后续的操作
        //包饺子（）;
        //煮饺子（）；
        //装盘，配酱油和醋（）；
        //上桌或打包（）；
        return productBase;
    }
}
//实现工厂派生类
class Factory1 extends FactoryBase
{
    @Override
    public ProductBase create(String type) {
        ProductBase productBase=null;
        if(type.equals("a1"))
            productBase=new a1();
        else if(type.equals("a2"))
            productBase=new a2();
        return productBase;
    }
}

class Factory2 extends FactoryBase
{
    @Override
    public ProductBase create(String type) {
        ProductBase productBase=null;
        if(type.equals("b1"))
            productBase=new b1();
        else if(type.equals("b2"))
            productBase=new b2();
        return productBase;
    }
}

如上代码所示：
1）分别建立产品基类、工厂基类。由产品基类，根据不同地区（地区a和地区b），构建了子类产品。相应的，也构建了不同的子类工厂。
2）基类工厂中，sell()方法作为对外统一方法，控制生产总流程，因此生命为final方法。而create()方法则因地制宜，按照不同地区特点，生产特定的产品。

这样，工厂方法既保证了修改的灵活性，也保证了某些必要操作不会被修改。