设计模式之工厂模式
工厂模式
一：简单工厂模式
1. 问题的引出
我们打算做一个制作pizza的系统，从订购到出货，初始代码如下：
public class Pizza{
Pizza orderPizza(String type){
Pizza pizza;
// 会引起代码变化的部分
if(type.equals("cheese")){
pizza =new CheesePizza();
}else if (type.equals("greek")){
pizza=new GreekPizza();
}else if(type.equals("pepperoni")){
pizza=new pepperoniPizza();
}
//不需要改变的部分代码 这是对pizza的一系列处理
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
客户端通过调用pizza类的orderPizza方法来创建pizza，根据type的不同来获取不同种类的pizza，然而以上的设计存在着很多问题：
- Pizza类中存在大量的if-else,使得整个类的代码冗长，既不容易测试又很影响性能 ，程序运行中需要做大量的条件判断。
- 当需要增加新的pizza的时候，必须修改Pizza类的源代码，违反了开闭原则。
- 客户端只能通过new关键字来创建对象，使得Pizza类和客户端耦合度很高，违反了迪米特法则。
因此我们引出了简单工厂模式,此模式能在一定程度上解决这个问题。
2. 简单工厂模式概述
简单工厂模式不属于GoF23个经典设计模式，但它是学习工厂模式的基础，其思想：首先将需要创建的各种对象（各种风味pizza）封装到不同对象中，这些类称为具体产品类，将公共部分提取到抽象产品类，然后提供一个工厂类用于创建各种产品，在工厂类中提供创建产品的工厂方法，根据参数获取不同的产品对象。
其定义如下：
简单工厂模式(Simple Factory Pattern)：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法，因此简单工厂模式又被称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。
3. 简单工厂模式结构图
4. 简单工厂模式角色
Factory(工厂角色)：即工厂类，负责创建所有产品实例的内部逻辑，其中提供了静态的工厂方法factoryMethod(),外界直接调用此方法来返回抽象产品类型。Product(抽象产品角色)：工厂类所创建的所有对象的基类，也是工厂类返回类型，符合依赖倒转原则以及开闭原则，封装了各种产品对象的公共方法。ProductA(具体产品角色)：由简单工厂创建得到，每个具体产品都继承或实现了抽象产品角色
在简单工厂模式中
5.简单工厂模式解决上述问题
抽象产品角色：
public interface IPizza {
void prepare();
void bake();
void cut();
void box();
}
具体产品A：
public class PizzaA implements IPizza {
@Override
public void prepare() {
}
@Override
public void bake() {
}
@Override
public void cut() {
}
@Override
public void box() {
}
}
具体产品B：
public class PizzaB implements IPizza {
@Override
public void prepare() {
}
@Override
public void bake() {
}
@Override
public void cut() {
}
@Override
public void box() {
}
}
工厂角色：
public class SimplePizzaFactory {
public static IPizza createPizza(String type){
IPizza pizza=null;
if(type.equals("A")){
pizza =new PizzaA();
}else if (type.equals("B")){
pizza=new PizzaB();
}
return pizza;
}
}
客户端：
public class Client {
public static void main(String[] args) {
IPizza pizza = SimplePizzaFactory.createPizza("A");
// 创建pizza之后的工作
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
6：简单工厂模式总结
优点：
- 简单工厂模式使得对象的创建和使用分离开来。
- 简单工厂模式将创建对象的复杂逻辑封装起来。
- 使用者只需要传入参数即可获得对应的产品。
缺点：
- 违背开闭原则，一旦假如了新的产品就必须要更改工厂创建产品的逻辑。
- 工厂类集中所有产品的创建过程，一旦类不能正常工作，将引起整个系统的故障。
二：工厂方法模式
1.问题的引出
简单工厂模式虽然解决了产品对象的创建问题，但是仍然存在很大的设计问题:当添加新的产品时候，必须通过修改客户端传过去的类型参数，其次还需要修改工厂中的if-else逻辑，显然违反了开闭原则，此外简单工厂模式所有的产品都是同一个工厂所创，工厂类职责很重，违反了单一职责原则，因此将引出第二种工厂模式->工厂方法模式。
2.工厂方法模式概述
不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构，工厂方法模式定义如下：
工厂方法模式(Factory Method Pattern)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式(Factory Pattern)，又可称作虚拟构造器模式(Virtual Constructor Pattern)或多态工厂模式(Polymorphic Factory Pattern)。工厂方法模式是一种类创建型模式。
3.工厂方法模式结构图
4.工厂方法模式角色
Product(抽象产品角色)：用来定义产品的接口，是产品对象的基类。ProductB(具体产品)：实现了抽象产品接口Factory(抽象工厂)：声明了工厂方法，用于返回一个产品，抽象工厂是工厂方法模式的核心，所有的工厂类都必须实现此方法。ProductAFactory(具体工厂):是抽象工厂子类，实现抽象工厂方法，返回具体的产品实例
5.工厂方法模式解决上述问题
结构如图：
代码如下：
抽象产品角色：
public interface Pizza {
// 准备
void prepare();
// 烘烤
void bake();
// 切
void cut();
// 装盒
void box();
}
具体产品角色：
public class PizzaA implements Pizza {
@Override
public void prepare() {
System.out.println("pizzaA开始准备");
}
@Override
public void bake() {
System.out.println("pizzaA开始烘烤");
}
@Override
public void cut() {
System.out.println("pizzaA开始切");
}
@Override
public void box() {
System.out.println("pizzaA开始装盒");
}
}
public class PizzaB implements Pizza {
@Override
public void prepare() {
System.out.println("pizzaB开始准备");
}
@Override
public void bake() {
System.out.println("pizzaB开始烘烤");
}
@Override
public void cut() {
System.out.println("pizzaB开始切");
}
@Override
public void box() {
System.out.println("pizzaB开始装盒");
}
}
抽象工厂：
public interface PizzaFactory {
Pizza createPizza();
}
具体工厂角色:
public class PizzaAFactory implements PizzaFactory {
@Override
public Pizza createPizza() {
return new PizzaA();
}
}
public class PizzaBFactory implements PizzaFactory {
@Override
public Pizza createPizza() {
return new PizzaB();
}
}
客户端：
public class Client {
public static void main(String[] args) {
// 针对抽象编程 PizzaAFactory可根据DI（依赖注入）进去
// 整个客户端就不需要对修改变化，全部是针对抽象编程
PizzaFactory factory = new PizzaAFactory();
Pizza pizza = factory.createPizza();
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
6.工厂方法模式总结
优点：
- 对客户端隐藏了具体产品的创建细节，无需知道传入什么参数进去。
- 假如新产品时候，不需要更改客户端以及抽象产品角色以及抽象工厂角色，只需要添加新的工厂类以及具体产品即可，完全符合开闭原则。
缺点：
- 如果产品的个数种类很多，那么必然会出现大量的具体工厂类，增加了系统的复杂度，会给系统带来额外的开销。
三：抽象工厂模式
1.问题的引出
工厂方法通过引入工厂等级结构，解决简单工厂职责过重（所有的产品都在一个工厂里产生）的问题，但是工厂方法会额外产生大量的工厂类，ProductA、ProductB、ProductC........,会给系统带来很大的开销，因此我们可以将相同类型的产品组成产品族，由同一个工厂生产，即抽象工厂模式的核心。
2.抽象工厂模式概述
抽象工厂模式为创建一组对象提供了解决方案，与工厂方法模式相比，抽象工厂模式中的工厂负责创建一组，其定义如下：
抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。
3.抽象工厂结构图
- AbstractFactory(抽象工厂)：声明了一族产品的方法，每个方法对应一种产品。
- Factory1（具体工厂）：，实现了抽象工厂中的方法，生成一组具体产品，这些产品构成了产品族，某个产品都位于某个产品等级中。
- AbstractProductA:不同产品实现或继承不同的产品接口。
- ProductA:具体产品，实现抽象产品中的方法。
4.抽象工厂模式实例
场景如下：为了保证客户的实用安全，确保原料一致，所以需要一个工厂来生产原料，即此工厂负责原料家族中的每种原料，即工厂需要生产面团、酱料、芝士等，但是不同区域的风味不一致，抽象工厂模式设计如下图：
代码如下：
AbstractFactory(抽象工厂角色)：
//原料生产工厂 每个区域的原料工厂都需要实现此接口
public abstract class PizzaIngredientFactory {
//每个原料都有一个对应的方法创建该原料
// 生产面团
abstract Dough createDough();
// 生产酱
abstract Sauce createSauce();
}
具体工厂：纽约原料加工厂
// 纽约原料工厂
public class NYPizzaIngredientFactory extends PizzaIngredientFactory {
@Override
Dough createDough() {
return new DoughA();
}
@Override
Sauce createSauce() {
return new SauceA();
}
}
具体工厂：中国原料加工厂
// 中国原料工厂
public class ChinaIngredientFactory extends PizzaIngredientFactory {
@Override
Dough createDough() {
return new DoughB();
}
@Override
Sauce createSauce() {
return new SauceB();
}
}
抽象产品角色：面团
// 面团
public interface Dough {
}
抽象产品角色：酱料
// 酱料
public interface Sauce {
}
具体产品角色：面团A
public class DoughA implements Dough{
}
具体产品角色：面团B
public class DoughB implements Dough{
}
具体产品角色：酱料A
public class SauceA implements Sauce {
}
具体产品角色：酱料B
public class SauceB implements Sauce {
}
5.抽象工厂方法总结
我们可以发现要是在增加新的产品族很方便，只需要扩展新的具体工厂，但是要扩展产品的等级结构（在抽象工厂中加入新的原料），会发现完全违背开闭原则，修改量巨大，抽象工厂的产品等级结构以工厂方法模式形式呈现，同样的产品族也是以工厂方法模式形式呈现，而产品族依赖产品等级结构，也就是说一旦产品等级结构是稳定不变的，那么整个抽象工厂就是很稳定的。
优点：
- 增加新的产品族很方便，完全符合对修改关闭
- 我们要替换整个产品线的话是非常容易的，只需要修改对应的具体工厂即可。
缺点：
- 增加新的产品等级结构需要修改大量的代码，完全违背开闭原则。
四：简单工厂VS工厂方法 && 工厂方法模式VS抽象工厂模式
先来回顾一下这三者的结构图：
简单工厂模式：
工厂方法模式：
抽象工厂模式：
简单工厂模式VS工厂方法模式
- 简单工厂模式把所有产品都放在一个工厂里生产。
- 简单工厂违背开闭原则。
- 工厂方法模式将产品的具体实现推迟到子类中，且针对每个产品都有对应的实现。
- 工厂方法模式符合开闭原则。
工厂方法模式VS抽象工厂模式
- 抽象工厂在产品族上符合开闭原则，但是在产品等级结构上违背开闭原则。
- 抽象工厂将一系类的产品组合起来，很明显符合组合复用原则。
- 抽象工厂可以看做是工厂方法的变形。相对于产品族来说，是工厂方法模式，相对于产品等级结构来说，也是工厂方法模式。
