Factory模式和Abstract Factory模式：全国连锁的披萨店

有一个连锁披萨店要在湖南和广东两个地方开店，但是湖南人喜欢辣，广东人喜欢清淡

需求故事

• 1.作为一个披萨店PizzaStore，可以根据客人要求orderPizza提供湖南口味的Pizza，口味是peppery+cheese；
• 2.作为一个披萨店PizzaStore, 还可以根据客人要求orderPizza提供广东口味Pizza，口味是seafood+cheese；
• 3.作为一个披萨店PizzaStore，还可以根据客人要求orderChicken生产广东口味的FriedChicken，口味是peppery+chicken，而作为一个广东的披萨店GDPizzaStore，可以生产FriedChicken，口味是light+chicken

Story1

作为一个披萨店PizzaStore，可以根据客人要求orderPizza提供湖南口味的Pizza，口味是peppery+cheese；

Story1 Test Case

由于Story1的需求都很具体，所以都是使用具体类来实现的

public class PizzaStoreTest {
    @Test
    public void testOrderPizzaStory1(){
        HNPizzaStore hnPizzaStore = new HNPizzaStore();
        HNStylePizza hnStylePizza = hnPizzaStore.orderPizza();
        assertEquals("peppery+cheese",hnStylePizza.taste());
        assertTrue(hnStylePizza.isBaked());
    }
}

Story1 Implementation

public class HNStylePizza {
    private boolean baked=false;
    public String taste() {
        return "peppery+cheese";
    }
    public void baking() {
        baked = true;
    }
    public boolean isBaked() {
        return baked;
    }
}
public class HNPizzaStore {
    public HNStylePizza orderPizza() {
        HNStylePizza pizza = new HNStylePizza();
        pizza.baking();
        return pizza;
    }
}

Story2

作为一个新的连锁广东披萨店PizzaStore, 还可以根据客人要求orderPizza提供广东口味Pizza，口味是seafood+cheese；

Story2 Test Case

增加的一个连锁披萨店，所以可以对披萨店进行抽象PizzaStore。广东风味的披萨和湖南风味的披萨口味也不通，但都是披萨，所以对披萨也要进行抽象Pizza来准备testcase

    @Test
    public void testOrderPizzaStory2(){
        PizzaStore hnPizzaStore = new HNPizzaStore();
        Pizza hnStyledPizza = hnPizzaStore.orderPizza();
        assertEquals("peppery+cheese",hnStyledPizza.taste());
        assertTrue(hnStyledPizza.isBaked());

        PizzaStore gdPizzaStore = new GDPizzaStore();
        Pizza gdStyledPizza = gdPizzaStore.orderPizza();
        assertEquals("seafood+cheese",gdStyledPizza.taste());
        assertTrue(gdStyledPizza.isBaked());
    }

Story2 Implemetation

public abstract class Pizza {
    private boolean baked=false;
    public void baking() {
        baked = true;
    }
    public boolean isBaked() {
        return baked;
    }
    public abstract String taste();
}

public class HNStylePizza extends Pizza {
    public String taste() {
        return "peppery+cheese";
    }
}

public class HNPizzaStore extends PizzaStore {
    public Pizza prepareUnbakedPizza() {
        HNStylePizza pizza = new HNStylePizza();
        pizza.baking();
        return pizza;
    }
}

public abstract class PizzaStore {
    public Pizza orderPizza() {
        Pizza pizza = prepareUnbakedPizza();
        pizza.baking();
        return pizza;
    }
    protected abstract Pizza prepareUnbakedPizza();
}

public class GDPizzaStore extends PizzaStore {
    @Override
    protected Pizza prepareUnbakedPizza() {
        Pizza pizza = new GDStylePizza();
        return pizza;
    }
}

public class HNPizzaStore extends PizzaStore {
    @Override
    public Pizza prepareUnbakedPizza() {
        Pizza pizza = new HNStylePizza();
        return pizza;
    }
}

上面的实现就是一个标准的Factory模式实现了，所以Factory模式就是把生产的对象，和生产的工厂进行抽象，从而达到了把实现产品的细节放到了工厂的子类中实现。
Factory模式的使用场景是使用不同的工厂来创建对象，以及要对创建的对象进行一些初始化操作，所以Factory模式里面通常都包含了Template方法模式

Story3

作为一个披萨店PizzaStore，还可以根据客人要求orderChicken生产广东口味的Chicken，口味是peppery+chicken，而作为一个广东的披萨店GDPizzaStore，可以生产Chicken，口味是light+chicken

Story3 Test Case

public void testOrderChickenStory3(){
   PizzaStore pizzaStore = new HNPizzaStore();
   Chicken chicken = pizzaStore.orderChicken();
   assertEquals("peppery+chicken",chicken.taste());

   pizzaStore = new GDPizzaStore();
   chicken = pizzaStore.orderChicken();
   assertEquals("light+chicken",chicken.taste());
}

Story3 Implementation

public abstract class Chicken {
    public abstract String taste();
}
public class PeppyChicken extends Chicken {
    @Override
    public String taste() {
        return "peppery+chicken";
    }
}
public class LightChicken extends Chicken {
    @Override
    public String taste() {
        return "light+chicken";
    }
}

public abstract class PizzaStore {
    public Pizza orderPizza() {
        Pizza pizza = prepareUnbakedPizza();
        pizza.baking();
        return pizza;
    }
    protected abstract Pizza prepareUnbakedPizza();

    public abstract Chicken orderChicken();
}
public class HNPizzaStore extends PizzaStore {
    public Pizza prepareUnbakedPizza() {
        HNStylePizza pizza = new HNStylePizza();
        return pizza;
    }

    @Override
    public Chicken orderChicken() {
        return new PeppyChicken();
    }
}
public class GDPizzaStore extends PizzaStore {
    @Override
    protected Pizza prepareUnbakedPizza() {
        Pizza gdStylePizza = new GDStylePizza();
        return gdStylePizza;
    }

    @Override
    public Chicken orderChicken() {
        return new LightChicken();
    }
}

这就是Abstract Factory模式的实现了，你没有看错，Abstract Factory比Factory最大的区别就是多了生产其他产品的方法，所以如果Factory就是只生产1个产品的Abstract Factory。

和坚思辨

Factory模式系列其实是要解决创建对象的问题，应用的场景是当创建一个对象比较复杂，使用构造函数来创建对象无法满足需求的情况。所以是否使用Factory系列相关模式的主要问题就是当你需要一个对象，但是使用构造函数还需要再做其他的额外准备时，就应该考虑Factory系列模式。

Factory系列其实一套一共有3个：
Simple Factory模式
Factory模式
Abstract Factory模式
其中Simple Factory就是根据传递的参数，用IF来判断创建对象，由于我个人不是很喜欢这种很多if的嵌套结构，所以我就没有进行介绍了。