详谈工厂模式

工厂模式相信大家都不陌生，是非常常用也是Spring框架中用的最多的设计模式之一，工厂模式分为三种：
1、简单工厂模式
2、工厂方法模式
3、抽象工厂模式

下面且听我一一道来。

咳咳！很久很久以前，人类还在原始时期的时候，为了维持温饱只能通过以物换物的方式去获取想要的东西。大家手里都知道一种东西的制作方法，否则就会饿死。
用代码来表示：

public interface Meat {

    String getMeat();

}

public class Beef implements Meat {

    @Override
    public String getMeat() {
        return "牛肉";
    }
}

public class Mutton implements Meat {

    @Override
    public String getMeat() {
        return "羊肉";
    }
}

public class Pork implements Meat {

    @Override
    public String getMeat() {
        return "猪肉";
    }
}

public class SimpleFactoryTest {

    public static void main(String[] args) {

        System.out.println(new Beef.getMeat());
    }
}

我这里我用牛肉来举例，人们想要获得牛肉就必须自己去做，也就是new一个牛肉出来。这个过程是很麻烦的，需要知道牛肉的制作全过程。

随着社会的进步，小作坊横空出世，只要你有钱就可以来我这个小作坊买肉。

简单工厂模式

public class Factory {

    public Meat getMilk(String name){

        if("羊肉".equals(name)){
            return new Mutton();
        } else if ("牛肉".equals(name)){
            return new Beef();
        } else if ("猪肉".equals(name)){
            return new Pork();
        } else {
            System.out.println("没有该肉品");
            return null;
        }
    }
}

public class SimpleFactoryTest {

    public static void main(String[] args) {

        Factory factory = new Factory();

        System.out.println(factory.getMeat("牛肉"));
    }
}

我们可以看到，运用了简单工厂模式之后，用户只要有钱就可以去作坊买相应的肉种，不用再自己去制作。

随着社会持续进步，小作坊的弊端也慢慢显露出来。首先简单工厂模式违背了开闭原则，假如作坊要添加狗肉的生产，就要多加一层ifelse语句。其次我们一个小作坊同时要生产牛肉，猪肉，羊肉，肯定在质量方面达不到国际标准。工厂方法模式应运而生。
工厂方法模式

public interface Factory {

    Meat getMeat();
    
}

我们先有一个工厂的接口

public class BeafFactory implements Factory {

    @Override
    public Meat getMeat() {
        return new Beef();
    }
}

public class MuttonFactory implements Factory {
    @Override
    public Meat getMeat() {
        return new Mutton();
    }
}

public class PorkFactory implements Factory {
    @Override
    public Meat getMeat() {
        return new Pork();
    }
}

public class MethodFactoryTest {

    public static void main(String[] args) {

        Factory factory = new BeafFactory();

        System.out.println(factory.getMeat());
    }
}

这里分别创建了生产相应肉种的工厂，是不是觉得更标准化了。现在用户想要牛肉只需要到生产牛肉的工厂就可以了。

随着业务的不对扩张，可能市场上需要非常多种的肉类，鸡肉，鸭肉，鱼肉…，这个时候问题又来了，如果是工厂方法模式，这势必会导致创建了太多的工厂，这样用户想要买一种肉类就要到相应的工厂去购买，用户会觉得很麻烦。这个时候更高级的抽象工厂模式就生效了。

抽象工厂模式

public abstract class AbstractFactory{

    public abstract Meat getBeaf();

    public abstract Meat getPork();

    public abstract Meat getMutton();
}

定义一个抽象工厂类

public class AbstractFactoryImpl extends AbstractFactory {


    @Override
    public Meat getBeaf() {
        return new BeafFactory().getMeat();
    }

    @Override
    public Meat getPork() {
        return new PorkFactory().getMeat();
    }

    @Override
    public Meat getMutton() {
        return new MuttonFactory().getMeat();
    }
}

public class AbstractFactoryTest {

    public static void main(String[] args) {

        AbstractFactory factory = new AbstractFactoryImpl();

        System.out.println(factory.getBeaf());
    }
}

这样是不是就更加标准化了呢，用户只需要知道这样一个工厂就可以了，而且我们把这个工厂能生产的所有肉种都可以给用户看到，用户只需要get就行了，同时满足了开闭原则，即使要加鳄鱼肉，鲨鱼肉我们只需要在内部加入就可以了。

总结：三种工厂模式没有说哪一个更好，哪一个更差，看你在实际项目中需要用到那种，就像我最近做的一个导出Excel表格的功能，我就用了简单工厂模式。