设计模式之工厂模式

1 引入

以简单的咖啡店点餐为例. 有一个咖啡类,美式咖啡类, 拿铁咖啡类,咖啡店类. 此时各个耦合比较严重,如果新增一个咖啡类型,需要改动很多代码.

1 咖啡类

public abstract class Coffee {

    public abstract String getName();

    public void addSugar() {
        System.out.println("加糖");
    }

    public void addMilk() {
        System.out.println("加牛奶");
    }

}

2 美式咖啡类

public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

3 拿铁咖啡类

public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

4 咖啡店类

public class CoffeeStore {

    public Coffee orderCoffee(String type){
        // 声明咖啡类型
        Coffee coffee = null;

        if ("americano".equals(type)){
            coffee = new AmericanCoffee();
        }else if ("latte".equals(type)){
            coffee = new LatteCoffee();
        }else {
            throw new RuntimeException("没有该类型咖啡");
        }

        coffee.addMilk();
        coffee.addSugar();

        return coffee;
    }
}

5 测试类

public class Client {
    public static void main(String[] args) {
        CoffeeStore store = new CoffeeStore();
//        Coffee coffee = store.orderCoffee("latte");
        Coffee coffee = store.orderCoffee("americano");
        System.out.println(coffee.getName());

    }

}
// 结果
加牛奶
加糖
拿铁咖啡
==========
加牛奶
加糖
美式咖啡

2 简单工厂模式

简单工厂不属于一种设计模式,是一种比较简单的方法.

1 结构

简单工厂包含如下角色：

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

2 实现

简单工厂类

public class SimpleCoffeeFactory {

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

工厂（factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。解除了和Coffee实现类的耦合，同时又产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合.后续新增咖啡,也需要修改工厂代码, 违背开闭原则.

简单工厂扩展, 即使用静态工厂,更加方便对象的创建获取.

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;
    }
}

3 工厂方法模式

1 说明

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

2 结构

工厂方法模式的主要角色：

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

3 实现

抽象工厂

public interface CoffeeFactory {

    Coffee createCoffee();
}

具体工厂

public class LatteCoffeeFactory implements CoffeeFactory {

    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

public class AmericanCoffeeFactory implements CoffeeFactory {

    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}

咖啡店

public class CoffeeStore {

    private CoffeeFactory factory;

    public CoffeeStore(CoffeeFactory factory) {
        this.factory = factory;
    }

    public Coffee orderCoffee(String type) {
        Coffee coffee = factory.createCoffee();
        coffee.addMilk();
        coffee.addsugar();
        return coffee;
    }
}

新增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了, 解决简单工厂模式的问题. 但没新增一个产品就要增加具体产品类和具体工厂类,增加了系统复杂度.

4抽象工厂模式

1 说明

抽象工厂是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构.

2 结构

抽象工厂模式的主要角色如下：

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

3 实现

抽象工厂

public interface DessertFactory {

    Coffee createCoffee();

    Dessert createDessert();
}

具体工厂

//  美式甜点工厂
public class AmericanDessertFactory implements DessertFactory {

    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    public Dessert createDessert() {
        return new MatchaMousse();
    }
}
//  意大利风味甜点工厂
public class ItalyDessertFactory implements DessertFactory {

    public Coffee createCoffee() {
        return new LatteCoffee();
    }

    public Dessert createDessert() {
        return new Tiramisu();
    }
}

如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类. 缺点也很明显,就是当这类产品中新增一个时,所有工厂类要修改.

5 扩展使用

通过简单工厂和配置文件的方式,进行解耦合操作.

1 配置文件

american=com.cf.factory.config_factory.AmericanCoffee
latte=com.cf.factory.config_factory.LatteCoffee

2 工厂类

public class CoffeeFactory {

    private static Map<String,Coffee> map = new HashMap();

    static {
        Properties p = new Properties();
        InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.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);
    }
}

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

6 JDK源码说明

JDK中集合Collection对象的iterator方法,查看类的UML图可知:

其中Collection接口是抽象工厂类，ArrayList是具体的工厂类；Iterator接口是抽象商品类，ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象

tips:

​ 1 DateForamt类中的getInstance()方法使用的是工厂模式；

​ 2 Calendar类中的getInstance()方法使用的是工厂模式；