创建型设计模式之工厂模式

---

一、工厂设计模式

工厂模式就类比实际生活中的工厂，在实际生活中，用户从来不会关系一个物品的详细制造过程，只会直接购买最终的成品。工厂设计模式的出发点也是如此。不同的是，现在要站在工厂的角度来进行考虑问题。工厂模式可以分为简单工厂模式，工厂方法模式和抽象工厂模式

二、工厂设计模式详解

1.简单工厂模式

简单工厂模式，就是直接根据传递的参数进行实际对象的创建，代码示例如下：

public class SimpleFactory {
    /**
     * @author yongrenyue
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    public Food create(String name) throws ClassNotFoundException {
        switch (name){
            case "cookie":
                return new Cookie(name);
            case "bread":
                return new Bread(name);
            default:
                throw new ClassNotFoundException("Factory can not produce!");
        }
    }
}

可能会有人问，这跟直接new一个对象的区别不就是简单的封装了一下吗，感觉反而复杂了。但是不要忘记，实际场景下，新建一个对象可能会有依赖，代码示例如下：

public class SimpleFactory2 {
    /**
     * @author yongrenyue
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    public Food create(String name) throws ClassNotFoundException {
        switch (name){
            case "noodles":
                Flour flour = new Flour("yongrenyue", 231);
                Oil oil = new Oil("yongrenyue", 123);
                return new Noodles("lanzhou" , flour, oil);
            case "steamedbread":
                Flour flo = new Flour("yongrenyue", 231);
                return new SteamedBread(name, flo);
            default:
                throw new ClassNotFoundException("Factory can not produce!");
        }
    }
}

这种情况下，创建noodles对象需要flour和oil对象，而创建steamedbread需要flour对象。如果自己创建这两个对象的话，创建1个还可以接受，如果创建100个呢？是不是对工厂模式有了一点点体会。
但是这种简单的工厂模式有很大弊端，如果后期要增加新的对象，则必须要修改SimpleFactory类。而且随着要创建对象的增加，工厂类也会变得越来越庞大。设计模式中的开闭原则要求对修改封闭，对扩展开发，这很明显违反了这个原则。因此又有了以下工厂方法模式和抽象工厂方法模式。

2. 工厂方法模式

上面的简单工厂方法模式是一个工厂可以创建所有对象，但是对于有新增对象的场景并不友好，显式的违反了开闭原则。而工厂方法模式则是削弱工厂的能力，对要创建的每个对象都新建一个工厂类，即从什么对象都可以创建的工厂转变为专一的工厂，noodles工厂只生成noodles，而bread工厂只生产bread。代码示例如下：

//Noodles Factory
public class NoodlesFactory {
    public Noodles createFactory(){
        Flour fo = new Flour("yongrenyue", 123);
        Oil oil = new Oil("yongrenyue", 321);
        return new Noodles("lanzhou", fo, oil);
    }
}
//Bread Factory
public class BreadFactory {
    public Bread crateBread(String name){
        return new Bread("yongrenyue");
    }
}

使用时首先创建一个要生产对象的工厂实例，然后即可通过对应的工厂创建对应的对象。工厂方法模式主要解决的问题就是简单工厂违反的开闭原则。如果要新增种类，只需要创建对应的工厂类，而不需要修改已有的工厂类，很好的符合了开闭原则。工厂方法模式使用示例如下：

public static void main(String[] args) throws ClassNotFoundException {
        //FactoryMethod demo
        NoodlesFactory noodleFactory = new NoodlesFactory();
        noodleFactory.createNoodles().show();
        System.out.println("--------------------------------------");
        BreadFactory breadFactory = new BreadFactory();
        breadFactory.crateBread().show();

    }

3. 抽象工厂模式

抽象工厂模式则是在工厂方法模式上的进一步抽象，提取出Factory接口，然后通过实现接口实现对应的工厂。

public interface Factory {
    Food create();
}

public class CookieFactory implements Factory{
    @Override
    public Food create() {
        return new Cookie("yongrenyue");
    }
}

public class SteamedBreadFactory implements Factory{
    @Override
    public Food create() {
        return new SteamedBread("yongrenyue", new Flour("yongrenyue", 123));
    }
}

使用时：

public static void main(String[] args) throws ClassNotFoundException {
        //FactoryMethod demo
       Factory factory = new SteamedBreadFactory();
       factory.create().show();
       System.out.println("--------------------------------------");
       factory = new CookieFactory();
       factory.create().show();
    }

抽象工厂在工厂方法模式的基础上又进行了一层抽象，所以在使用的时候更加方便，顶层接口都是相同的，可以很方便的替换创建对象的工厂。但是抽象工厂也有缺点，如果工厂接口需要增加新的功能，则同时需要修改接口以及所有实现该接口的工厂。所以抽象工厂适用于同类工厂的横向扩展。

---

总结

以上就是创建型设计模式中的工厂模式，涉及到的代码：https://gitee.com/yongrenyue/design-pattern。
如有错误，恳请大家批评指正，日拱一卒，功不唐捐。