设计模式 —— 简单工厂、工厂、抽象工厂模式-蒲公英云

文章目录

- 1 原始代码
- 2 简单工厂
- 3 工厂模式
- 4 抽象工厂模式
- 5 总结
- 6 通过反射和配置文件优化
- 7 简单工厂 UML 关系图
- 8 工厂模式 UML 关系图
- 9 抽象工厂 UML 关系图
- 参考

1 原始代码

以下是最原始的代码，客户端要订披萨时，直接调用 orderPizza() 方法，传入类型参数，即可得到相应披萨
优点： 客户端调用很方便

缺点： 当要扩展新的披萨类型时，需要修改旧的代码，可知它对修改不闭合

public Pizza orderPizza(String type) {

    Pizza pizza = null;
    switch (type) { 
        case "cheese":
            pizza = new CheesePizza();
            break;
        case "greek":
            pizza = new GreekPizza();
            break;
        default:
            throw new IllegalArgumentException("无此类型的Pizza");
    }
    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.done();
    return pizza;
}
// 客户端代码
orderPizza("cheese");

2 简单工厂

将可能会变化的代码做了封装，即封装成了一个创建披萨的简单工厂

这样虽然对修改还是开放的，但是修改的代价会低一点（只需修改一处）

public class PizzaStoreSimple {

    public Pizza orderPizza(String type) { 
        Pizza pizza = SimplePizzaFactory.createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.done();
        return pizza;
    }
}
// 客户端代码，和原始代码一样
orderPizza("cheese");

3 工厂模式

工厂模式在简单工厂的基础上做了一层抽象，它让子类决定如何制造披萨
和简单工厂的区别：
- 简单工厂的 PizzaStoreSimple 类就是一个实例工厂，客户端之间调用这个类，就可以返回披萨
- 工厂模式将实例工厂抽象成了抽象工厂 PizzaStoreFactory，这个抽象工厂可以分化出许多具体的实例工厂，并且不同的实例工厂制造不同类型的披萨
- 简单来说，工厂模式就是将简单工厂分化成许多小工厂，每个小工厂制作不同的披萨。所有小工厂制作出的披萨总和，就等于简单工厂制作出的披萨种类
优点： 对修改闭合。当要添加新的披萨类型时，不需要修改旧代码，只要新建一个工厂类即可

缺点： 客户端需要自己选定需要的披萨工厂

public abstract class PizzaStoreFactory {

    //其实这里就相当于模板模式了
    public Pizza orderPizza(String type) { 
        Pizza pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.done();
        return pizza;
    }
    //让子类决定如何制造披萨，这里一般是没有类型的，每个工厂对应一种类型
    //当然也可以是多个类型
    abstract Pizza createPizza(String type);
}
// 客户端代码
PizzaStoreFactory pizzaStore = new 客户端需要的工厂();
pizzaStore.orderPizza("这里一般是没有类型的，每个工厂对应一种类型");

4 抽象工厂模式

抽象工厂模式出现的情况是：一个完整产品是由多个产品家族组合而成。比如披萨由披萨原料组合；车是由轮子、发动机等产品组合而成。而简单工厂生产的产品就是一个独立的个体。其它的感觉都是一样的
优点： 和简单工厂一样，都是对修改封闭的。只是简单工厂是一个产品，这个是多个产品
缺点： 当扩展产品家族时（添加一种新的原料），新加代码比较繁琐，比较多。需要在所有的抽象工厂实现类中，实现新加的方法

完全可以在抽象工厂的 createPizza() 方法中，分别创建多个产品，再直接组合。而不需要专门定义一个抽象工厂来组合。这样扩展产品族的时候，就好些。这就由沦为了工厂模式了。

public abstract class PizzaStoreAbstractFactory {

    //其实这里就相当于模板模式了
    public PizzaCustom orderPizza(String type) { 
        PizzaCustom pizza = createPizza(type);
        pizza.prepareIngredient();
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.done();
        return pizza;
    }
    //让子类决定如何制造披萨
    abstract PizzaCustom createPizza(String type);
}
public class ChinesePizzaFactory extends PizzaStoreAbstractFactory { 
    @Override
    PizzaCustom createPizza(String type) { 
        return new ChinesePizzaCustom("中国",1,new ChineseIngredientFactory());
    }
}
public class ChinesePizzaCustom extends PizzaCustom { 
    //这里就是一个抽象工厂，它负责生产一系列的产品家族!!!!
    IIngredientFactory iIngredientFactory;
    public ChinesePizzaCustom(String name, Integer size, IIngredientFactory iIngredientFactory){ 
        super(name, size);
        this.iIngredientFactory = iIngredientFactory;
    }
    //名字尺寸都可以自己定义
    public ChinesePizzaCustom() { 
        super("中国披萨",2);
    }
    //但是加盟店的原料，应该是总店统一配置的，不然有些加盟店偷工减料，影响声誉
    //这时候就需要一个原料工厂了
    //通过将抽象工厂得到的产品家族组合，最终形成一个完整的产品
    @Override
    void prepareIngredient() { 
        System.out.println("开始准备原料...");
        this.cheese = iIngredientFactory.createCheese();
        this.sauce = iIngredientFactory.createSauce();
        System.out.println("原料 "+ cheese + "、"+sauce + " 准备完成！");
    }
}
//这个就是产品族的抽象工厂，每个实例工厂都自定义对应工厂生产的产品
//如 chineseFactory 生产chineseSauce/chineseCheese，JapenPactory生产japenSauce/japenCheese
public interface IIngredientFactory { 
    Sauce createSauce();
    Cheese createCheese();
}
// 客户端代码
PizzaStoreAbstractFactory pizzaStore = new ChinesePizzaFactory();
pizzaStore.orderPizza("");

5 总结

不管时工厂模式还是抽象工厂模式，横向扩展很方便（不修改产品属性，增加产品类型），纵向扩展不易（修改产品属性）
总得来说，工厂、抽象工厂模式，都是符合开放-封闭原则的（在不修改产品属性的情况下）
观察工厂、抽象工厂模式的客户端代码：说明两都是面向接口编程的，应用程序和具体的类之间是解耦的，如果想使用别的产品，只要该一行代码即可。
这个披萨的例子可扩展到数据库的例子，不同的数据库由自己的实现，而客户端使用不同的数据库，只要修改一行代码即可

6 通过反射和配置文件优化

通过 SPI 读取 META-INF.services包下的文件名，来决定使用的是那个实例类

//这样客户端的代码就不用变了，只需要修改相应文件夹中的属性即可

ServiceLoader<PizzaStoreAbstractFactory> serviceLoader = ServiceLoader.load(PizzaStoreAbstractFactory.class);
Iterator<PizzaStoreAbstractFactory> iter = serviceLoader.iterator();
while (iter.hasNext()) { 
    PizzaStoreAbstractFactory proxy = iter.next();
    proxy.orderPizza("");
    break;
}