设计模式之简单工厂模式

1、什么是简单工厂模式（静态工厂模式）

1）简单工厂模式属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单的实用模式。
2）简单工厂模式：定义一个创建对象的类，这个类来封装实例化对象的行为。
3）在软件开发中，当我们会用到大量创建某种，某类或者某批对象，就会使用到工厂模式。

2、如何实现简单工厂模式

这里我们以生产披萨为例

首先我们先看一下使用传统方式如何实现

2.1 创建一个抽象产品类

package factory.simplefactory.pizzastore.pizza;

/**
 * @Date 2020/5/21 下午5:46
 * @Created by zhaoli
 */
public abstract class Pizza {
    protected String name;

    public void setName(String name) {
        this.name = name;
    }

    public abstract void prepare();

    public void bake(){
        System.out.println(name + "正在烘烤");
    }

    public void cut(){
        System.out.println(name + "正在切块");
    }

    public void box(){
        System.out.println(name + "正在打包");
    }
}

2.2 创建两个具体的产品类

package factory.simplefactory.pizzastore.pizza;

/**
 * @Date 2020/5/21 下午5:52
 * @Created by zhaoli
 */
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作奶酪披萨准备原材料");
    }
}

package factory.simplefactory.pizzastore.pizza;

/**
 * @Date 2020/5/21 下午5:53
 * @Created by zhaoli
 */
public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作希腊披萨准备原材料");
    }
}

2.3 创建一个订购披萨类

package factory.simplefactory.pizzastore.order;

import factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @Date 2020/5/21 下午6:06
 * @Created by zhaoli
 */
public class OrderPizza {
      public OrderPizza(){
            Pizza pizza = null;
            String pizzaType;
            do {
                pizzaType = getType();
                if(pizzaType.equals("cheese")){
                    pizza = new CheesePizza();
                    pizza.setName("奶酪披萨");
                }else if(pizzaType.equals("greek")){
                    pizza = new GreekPizza();
                    pizza.setName("希腊披萨");
                }else {
                    break;
                }
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }while (true);
        }
        private String getType() {
            String str ="";
            BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入订购披萨的类型：");
            try {
                str =  bfr.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
    }
}

分析一下传统方式的弊端：
假设我们有多个披萨订购类，这时候我们新加了一种胡椒味的披萨，那么我们就出了添加胡椒披萨实体类之外，还需要在每一个披萨订购类中添加如下代码

if(pizzaType.equals("cheese")){
                    pizza = new PepperPizza();
                    pizza.setName("胡椒披萨");

如果我们100个披萨订购类，那么我们就需要添加一百份这段代码。这无疑是效率极低的。

简单工厂方式

2.4 创建一个简单工厂类

package factory.simplefactory.pizzastore.order;

import factory.simplefactory.pizzastore.pizza.CheesePizza;
import factory.simplefactory.pizzastore.pizza.GreekPizza;
import factory.simplefactory.pizzastore.pizza.Pizza;

/**
 * @Date 2020/5/21 下午6:58
 * @Created by zhaoli
 */
public class SimpleFactory {
    public Pizza createPizza(String pizzaType){
        Pizza pizza = null;
        System.out.println("使用工厂模式");
        if(pizzaType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        }else if(pizzaType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        }

        return pizza;
    }
}

2.4 这时候的披萨订购类‘

 public OrderPizza(SimpleFactory simpleFactory){
            setFactory(simpleFactory);
        }
        private SimpleFactory simpleFactory;
        String pizzaType = "";
        public void setFactory(SimpleFactory simpleFactory){
            this.simpleFactory = simpleFactory;
            do {
                pizzaType = getType();
                //从工厂里面拿
                Pizza pizza = simpleFactory.createPizza(pizzaType);
                if(pizza != null){
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                }else {
                    System.out.println("没有这种pizza");
                    break;
                }

            }while (true);

        }
        private String getType() {
            String str ="";
            BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入订购披萨的类型：");
            try {
                str =  bfr.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
    }

分析一下工厂优势
这时候我们新加了一种胡椒味的披萨，那么我们就除了添加胡椒披萨实体类之外，只需要在工厂类中添加如下代码

if(pizzaType.equals("pepper")){
          pizza = new PepperPizza();
          pizza.setName("胡椒披萨");

所有的披萨订购类无需改动。

另外一种方式，静态工厂

public static Pizza createPizza2(String pizzaType){
        Pizza pizza = null;
        System.out.println("使用工厂模式");
        if(pizzaType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        }else if(pizzaType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        }
        return pizza;
    }

披萨订购类改动

package factory.simplefactory.pizzastore.order;

import factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @Date 2020/5/21 下午6:06
 * @Created by zhaoli
 */
public class OrderPizza2 {
        String pizzaType = "";
        public OrderPizza2(){
            do {
                pizzaType = getType();
                //直接使用工厂类，无需创建工厂实例
                Pizza pizza = SimpleFactory.createPizza2(pizzaType);
                if(pizza != null){
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                }else {
                    System.out.println("没有这种pizza");
                    break;
                }
            }while (true);

        }


        private String getType() {
            String str ="";
            BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入订购披萨的类型：");
            try {
                str =  bfr.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
    }
}

3 优点和缺点

3.1 优点

• 工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。

• 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。

• 通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

3.2 缺点

• 由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

• 使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。

• 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，同样破坏了“开闭原则”；在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

• 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

4 适用环境
在以下情况下可以使用简单工厂模式：

• 工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
• 客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。