设计模式 | 工厂模式

Posted 2021-12-15 结构化思维wz

工厂模式

文章目录

• • • 工厂模式
    • • 问题引入：
      • 1.简单工厂模式
      • 2.工厂方法模式
      • 3.抽象工厂模式
      • 4.工厂+ 配置文件

问题引入：

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

设计一个咖啡类，并定义两个子类(美式咖啡，拿铁咖啡)；再设计一个咖啡店类，咖啡店具有点咖啡的功能。

问题：如果我们要添加别的类型的咖啡，还得修改咖啡店中的代码。违背了开闭原则。如果创建对象用new的方法还会造成耦合的问题。

解决方案：使用工厂来生产对象，我们只需要和工厂打交道，如果需要更换对象直接在工厂中更换即可。

1.简单工厂模式

简单工厂不是一种设计模式，反而是一种编程习惯。

结构：

• 抽象产品：定义了产品的规范，描述了产品的主要特征和功能
• 具体产品：实现或者继承抽象产品的子类
• 具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。

package com.wangze.pattern.singleton.Coffee;

/**
 * @ClassName: SimpleCoffeeFactory
 * @Description: 简单咖啡工厂类，用来生产咖啡
 * @author: 结构化思维wz
 * @date: 2021/11/21 15:04
 */


public class SimpleCoffeeFactory 
    public Coffee createCoffee(String type)
        //声明一个Coffee类型的变量，根据不同类型创建不同的Coffee子类对象
        Coffee coffee =null;
        if("american".equals(type))
            coffee = new AmericanCoffee();
        
        else if("latte".equals(type))
            coffee = new LatteCoffee();
        
        else 
            throw new RuntimeException("暂时不生产所需咖啡");
        
        return coffee;
    

package com.wangze.pattern.singleton.Coffee;

/**
 * @ClassName: CoffeeStore
 * @Description: 咖啡店
 * @author: 结构化思维wz
 * @date: 2021/11/21 14:27
 */


public class CoffeeStore  
    public Coffee orderCoffee(String type)
        //声明一个Coffee类型的变量，根据不同类型创建不同的Coffee子类对象
        Coffee coffee =null;
        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        coffee = factory.createCoffee(type);
        //加配料
        coffee.addMike();
        coffee.addSugar();
        return coffee;
    

package com.wangze.pattern.singleton.Coffee;

/**
 * @ClassName: Customer
 * @Description: 顾客来买咖啡
 * @author: 结构化思维wz
 * @date: 2021/11/21 14:32
 */


public class Customer 
    public static void main(String[] args) 
        //创建咖啡店
        CoffeeStore coffeeStore = new CoffeeStore();
        //点咖啡
        Coffee coffee =  coffeeStore.orderCoffee("latte");

        System.out.println(coffee.getName());
    

封装了创建对象的过程，但是如果还想新增新产品还得修改工厂代码，违反开闭原则。

2.工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪个对象的产品类对象。工厂方法使一个产品类的实例化延迟到其他工厂的子类。

结构：

• 抽象工厂：提供了创建产品的接口，调用者通过她访问具体工厂的工厂方法来创建产品。
• 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品：定义产品的规范，描述了产品的主要特性和功能。
• 具体产品：实现了抽象产品中所定义的接口，由具体的工厂来创建，它同具体工厂之间一一对应。

优缺点：

优点：

• 用户只需要知道具体工厂的名称就可以得到所要的产品，不许知道产品的具体创建过程。
• 在系统增加新的产品时，只需添加具体产品类和对应的具体工厂类，无需对原工厂进行任何修改，满足开闭原则。

缺点：

• 每增加一个产品就要增加一个具体产品的类和一个对应的具体工厂类，这增加了系统的复杂度。

3.抽象工厂模式

之前的工厂模式只考虑同一类产品的生产。但是在显示生活中工厂可以生产多类别多级别的产品，电器厂可以生产好多电器…

概念：

抽象工厂模式可以生产多个等级的产品。

结构:

• 抽象工厂：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
• 具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
• 具体产品：实现了抽象产品角色锁定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

实现：

现在咖啡店的业务发生改变，不仅仅要生产咖啡还要生产甜点，提拉米苏等等。按照工厂模式，需要创建很多工厂类，很麻烦。

4.工厂+ 配置文件

通过这种方式可以接触工厂对象和产品对象的耦合。

1️⃣定义配置文件

american = com.wangze.Coffee.AmericanCoffee
latte = com.wangze.Coffee.LatteCoffee

2️⃣改进工厂类

package com.wangze.factory;

import com.wangze.Coffee.Coffee;

import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * @ClassName: Factory
 * @Description: 工厂类
 * @author: 结构化思维wz
 * @date: 2021/11/21 18:37
 */


public class Factory 
    private static Map<String, Coffee> map = new HashMap<>();
    static 
        Properties properties = new Properties();
        InputStream inputStream = Factory.class.getClassLoader().getResourceAsStream("bean.properties");
        try 
            properties.load(inputStream);
            Set<Object> keys = properties.keySet();
            for (Object key : keys)
                String className = properties.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);
    

---