设计模式笔记_创建型_工厂模式

1. 工厂模式简介

工厂模式是一种创建型设计模式，主要用于创建对象实例。 它通过定义一个接口或抽象类来创建对象，而不是直接实例化具体类，从而将对象的创建过程与使用过程分离。

工厂模式通常分为两种类型：

• 简单工厂模式（Simple Factory）： 这种模式并不是GoF设计模式之一，但在实际应用中非常常见。 简单工厂模式通过一个工厂类来负责创建对象，根据传入的参数的不同，返回不同类型的实例。

• 工厂方法模式（Factory Method）： 工厂方法模式定义一个创建对象的接口，但由子类决定实例化哪个类。这样，工厂方法模式让类的实例化推迟到子类中进行。

2.代码演示

假设我们有一个咖啡店，咖啡店可以制作不同种类的咖啡，如美式咖啡和拿铁咖啡。我们将分别使用简单工厂模式和工厂方法模式来演示创建不同的咖啡。

2.1 共用代码

coffee相关的代码是两种工厂模式共用的，如下：

/** 抽象的Coffee顶层类 */
public abstract class Coffee {
    public abstract void prepare();
}


/** 美式咖啡 */
public class AmericanoCoffee extends Coffee {
    @Override
    public void prepare() {
        System.out.println(" prepare AmericanoCoffee");
    }
}

/** 拿铁咖啡 */
public class LatteCoffee extends Coffee {
    @Override
    public void prepare() {
        System.out.println(" prepare LatteCoffee");
    }
}

2.2 简单工厂模式

/** 
 * 简单工厂模式（Simple Factory）：
 * 简单工厂模式通过一个工厂类来负责创建对象，根据传入的参数的不同，返回不同类型的实例。
 * 这种模式并不是GoF设计模式之一，但在实际应用中非常常见。
*/
public class CoffeeSimpleFactory {
    private static final String AMERICANO = "Americano";
    private static final String LATTE = "Latte";

    public static Coffee createCoffee(String coffeeType) {
        if (AMERICANO.equals(coffeeType)) {
            return new AmericanoCoffee();
        }
        if (LATTE.equals(coffeeType)) {
            return new LatteCoffee();
        }
        return null;
    }
}

简单工厂模式对应的类图：

2.2 工厂方法模式

/**
 * 工厂方法模式（Factory Method）：
 * 定义一个创建对象的接口, 但由子类决定实例化哪个类, 工厂方法模式让类的实例化推迟到子类中进行。
 */
public interface CoffeeFactory {
    /**
     * 创建咖啡
     *
     * @return Coffee
     */
    Coffee createCoffee();
}

/** 美式咖啡工厂 */
public class AmericanoCoffeeFactory implements CoffeeFactory {
    @Override
    public Coffee createCoffee() {
        return new AmericanoCoffee();
    }
}

/** 拿铁咖啡工厂 */
public class LatteCoffeeFactory implements CoffeeFactory {
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

//--------------------------------------------------------

/** 使用咖啡工厂创建咖啡 */
public class CoffeeMainProcess {
    private static final String AMERICANO = "Americano";
    private static final String LATTE = "Latte";

    private static final Map<String, CoffeeFactory> CACHED_COFFEE_FACTORY = new ConcurrentHashMap<>(16);

    static {
        CACHED_COFFEE_FACTORY.put(AMERICANO, new AmericanoCoffeeFactory());
        CACHED_COFFEE_FACTORY.put(LATTE, new LatteCoffeeFactory());
    }

    public static Coffee createCoffee(String coffeeType) {
        if (StringUtils.isEmpty(coffeeType) || !CACHED_COFFEE_FACTORY.containsKey(coffeeType)) {
            return null;
        }
        CoffeeFactory coffeeFactory = CACHED_COFFEE_FACTORY.get(coffeeType);
        return coffeeFactory.createCoffee();
    }
}

工厂方法模式对应的类图：

工厂方法模式的优点：

• 解耦：将对象的创建与使用分离，降低了代码的耦合度。
• 扩展性：新增产品时，只需添加对应的具体产品类和具体工厂类，符合开闭原则。

工厂方法模式的缺点：

• 复杂性增加：需要为每一个产品创建一个具体工厂类，增加了系统的复杂度。
• 类数量增多：可能导致类数量增多，增加维护成本。

工厂方法模式适合场景：

• 在需要灵活创建对象并且对象类型较多的场景中使用。