工厂模式的简单实例

工厂模式在软件设计中运用非常广泛，这篇文章就记录一个工厂模式的简单例子。

黑马程序员Java设计模式详解，全网最全23种Java设计模式（图解+框架源码分析+实战）_哔哩哔哩_bilibili

首先是一些准备工作，设计一个咖啡抽象类，然后有两个类继承这个抽象类，分别是美式咖啡类和拿铁咖啡类。

public abstract class Coffee {

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

    // 加奶
    public void addmilk(){
        System.out.println("加奶");
    }

    public abstract String getname();

}

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

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

简单工厂

public class SimpleCoffeeFactory {

    public Coffee create(String type){
        Coffee coffee = null;
        if("american".equals(type)){
            coffee = new AmericanCoffee();
        } else if("latte".equals(type)){
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("没有这个类型的咖啡");
        }
        return coffee;
    }

}

静态工厂

public class StaticCoffeeFactory {

    public static Coffee create(String type){
        Coffee coffee = null;
        if("american".equals(type)){
            coffee = new AmericanCoffee();
        } else if("latte".equals(type)){
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("没有这个类型的咖啡");
        }
        return coffee;
    }

}

工厂方法模式

首先定义抽象工厂

public interface CoffeeFactory {

    public Coffee create();

}

然后定义两个咖啡工厂

public class AmericanFactory implements CoffeeFactory{
    public Coffee create() {
        return new AmericanCoffee();
    }
}

public class LatteCoffeeFactory implements CoffeeFactory{
    public Coffee create() {
        return new LatteCoffee();
    }
}

在咖啡店里点咖啡

public class CoffeeStore {

    private CoffeeFactory factory;

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

    public Coffee orderCoffee(){
        Coffee coffee = factory.create();
        coffee.addsugar();
        coffee.addmilk();
        return coffee;
    }
    
}

在测试的时候需要实例化对应的工厂

public class PatternMain {

    @Test
    public void test() {
        CoffeeFactory factory = new AmericanFactory();
        CoffeeStore coffeeStore = new CoffeeStore(factory);
        Coffee coffee = coffeeStore.orderCoffee();
        System.out.println(coffee.getname());
    }

}

抽象工厂模式

一个工厂生产一个类别的产品

定义一个抽象工厂，可以生产甜品和咖啡

public interface DessertFactory {

    public Dessert createDessert();

    public Coffee createCoffee();

}

两个风格的甜品工厂

public class TiramisuDessertFactory implements DessertFactory{
    public Dessert createDessert() {
        return new Tiramisu();
    }

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

public class MatchMoussDessertFactory implements DessertFactory{
    public Dessert createDessert() {
        return new MatchaMousse();
    }

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

简单工厂+配置文件

我们使用配置文件记录工厂的类路径，然后使用反射实例化具体的工厂对象

我们先写一个配置文件

american = PATTERN.AmericanCoffee
latte = PATTERN.LatteCoffee

然后定义一个简单工厂

public class CoffeeFactoryPlus {

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

    static {
        Properties properties = new Properties();
        InputStream is = CoffeeFactoryPlus.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            properties.load(is);
            // 遍历properties集合对象
            Set<Object> keys = properties.keySet();
            for(Object key : keys){

                String classname = properties.getProperty((String) key);
                Class clazz = Class.forName(classname);

                Coffee coffee = (Coffee)clazz.newInstance();
                map.put((String)key, coffee);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public Coffee create(String type){
        if(!map.containsKey(type)){
            throw new RuntimeException("没有这个类型的咖啡");
        }
        Coffee coffee = map.get(type);
        coffee.addsugar();
        coffee.addmilk();
        return coffee;
    }

}

我们传入参数即可很容易获取到相应的咖啡

public class PatternMain {

    @Test
    public void test() {
        CoffeeFactoryPlus coffeeFactoryPlus = new CoffeeFactoryPlus();
        Coffee coffee = coffeeFactoryPlus.create("american");
        System.out.println(coffee.getname());
    }

}