Java设计模式-工厂模式（1）简单工厂模式

Java设计模式-工厂模式（1）简单工厂模式)

一、前言

我们先别急着想工厂模式是什么样的啊

先看看下面这个例子啊，怎么设计，如何写，才能更好。

一步一步引出Java工厂模式。

1）例子

需求：设计一个咖啡店点餐系统。

设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。

代码是比较简单的，我这是采取一步一步引入的，如果不喜欢，可以直接看下文。

我们先用曾经的方式来设计和进行代码的编写。

2）类图关系

3）代码实现

我们先用以前的方式来实现一遍哈。

1、先写好Coffee这个抽象类

public abstract class Coffee {
    public abstract void addMilk();
    public abstract void addSugar();
    public abstract String getName();
}

2、再写好美式咖啡和拿铁咖啡继承Coffee抽象类

public class AmericanCoffee extends Coffee {
    
    @Override
    public void addMilk() { System.out.println("给咖啡加奶"); }
    
    @Override
    public void addSugar() { System.out.println("给咖啡加糖"); }
    
    @Override
    public String getName() { return "美式咖啡"; }
}

public class LatteCoffee extends Coffee {

    @Override
    public void addMilk() { System.out.println("给咖啡加奶"); }

    @Override
    public void addSugar() {  System.out.println("给咖啡加糖"); }
 
    @Override
    public String getName() { return "拿铁咖啡"; }
}

3、咖啡店

public class CoffeeStore {

    public Coffee createCoffee(String type){
        Coffee coffee = null;
        if("americano".equals(type)) {
            coffee = new AmericanCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}

4、写个客户端来测试点咖啡哈

public class Client {

    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        Coffee coffee = coffeeStore.createCoffee("americano");
        System.out.println(coffee.getName());
        /**
         * 输出：
         * 给咖啡加奶
         * 给咖啡加糖
         * 美式咖啡
         */
    }
}

其实乍一看没啥问题，但是如果我这个需要增加几种咖啡，你说该如何才合适勒？

是不是需要修改CoffeeStore的代码。又如果要开设美团外卖点单呢？又如何改呢？

在java中，万物皆对象。

如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。（而且这种重复工作简直想死）

如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

接下来就出现了简单工厂模式（简单工厂模式并非23种经典模式之内，更像是一种编程习惯吧）。😁

二、简单工厂模式

2.1、概述：

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

简单工厂包含如下角色：

• 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。 （例子中的咖啡）
• 具体产品 ：实现或者继承抽象产品的子类 （例子中的美式咖啡、拿铁咖啡等）
• 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。 （一个来创建对象的工厂）

使用场景

工厂类负责创建的对象比较少；

客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

2.2、类图关系：

简单来说就是在原有的设计上加了一层（没有什么是加一层解决不了的，不行就加两层（狗头保命））😁

2.3、代码修改：

就在原有基础上做了一些修改：

增加一个SimpleCoffeeFactory类，在这个地方进行对象的创建。😀

public class SimpleCoffeeFactory {

    public Coffee createCoffee(String type) {
        Coffee coffee = null;
        if("americano".equals(type)) {
            coffee = new AmericanCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        return coffee;
    }
}

再修改一下CoffeeStore类

public class CoffeeStore {

    public Coffee createCoffee(String type){
        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        Coffee coffee = factory.createCoffee(type);
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}

看起来好像只是把创建对象的权力给到了SimpleCoffeeFactory，没有什么其他操作，但是就是这个SimpleCoffeeFactory工厂类，已经将CoffeeStore类和Coffee对象解耦了，CoffeeStore不再需要管具体产品对象是如何创建的，只需要负责自己的事情就可以了，明确了各自的职责和权利，有利于整个软件体系结构的优化

总结：

工厂（factory）处理创建对象的细节，有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合，但同时又产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和商品对象的耦合。

后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory的代码，违反了开闭原则。

工厂类的客户端可能有很多，比如创建美团外卖等，这样只需要修改工厂类的代码，省去其他的修改操作。

2.4、优缺点

优点：

封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点：

当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利，违背了“开闭原则”。

2.5、扩展-简单静态工厂

在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下

public class SimpleCoffeeFactory {

    public static Coffee createCoffee(String type) {
        Coffee coffee = null;
        if("americano".equals(type)) {
            coffee = new AmericanoCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        return coffe;
    }
}

2.6、扩展-简单工厂+配置文件解除耦合

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。

在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。

1. 定义一个配置文件 my.properties

   american=com.crush.factory.simple_factory_properties.AmericanCoffee
   latte=com.crush.factory.simple_factory_properties.LatteCoffee
   

2. 改进工厂类

   public class CoffeeFactory {
   
       private static Map<String,Coffee> map = new HashMap();
   
       static {
           Properties p = new Properties();
           InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("my.properties");
           try {
               p.load(is);
               //遍历Properties集合对象
               Set<Object> keys = p.keySet();
               for (Object key : keys) {
                   //根据键获取值（全类名）
                   String className = p.getProperty((String) key);
                   //获取字节码对象
                   Class clazz = Class.forName(className);
                   Coffee obj = (Coffee) clazz.newInstance();
                   map.put((String)key,obj);
               }
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       public static Coffee createCoffee(String name) {
           return map.get(name);
       }
   }
   

   静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象），而读取配置文件以及创建对象写在静态代码块中，目的就是只需要执行一次。

   这种方式用的也很多，常见也很简单。

三、结语

这个简单工厂并不完善，增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”，所以才有了后文的工厂模式、抽象工厂模式。

持续更新中哦。