设计模式之工厂模式，史上最强，不服来辩！

设计模式是对大家实际工作中写的各种代码进行高层次抽象的总结，如果设计模式没学会，抽象能力肯定就不会太强。常见的设计模式有 23 种，今天我们只聊最简单的工厂模式。

工厂模式是属于创建型模式的，通过工厂获取一个一个的新对象。说白了，工厂就是用来 new（创建）对象的，因此把它化分到创建型这一类中。

简单工厂模式

简单工厂模式，正如其名，和名字一样简单，非常简单。下面先看一段代码：

public class FoodFactory {
    public static Food makeFood(String name) {
        if ("kuaican".equals(name)) {
            Food kuaican = new KuaiCanFood();
            kuaican.setPrice(20.00);
            return kuaican;
        } 

        if ("hamburger".equals(name)) {
            Food hamburger = new HamburgerFood();
            hamburger.setPrice(22.00);
            hamburger.setMeat("beef");
            return hamburger;
        } 

        // ......

        return new RuntimeException("not food");
    }
}

需要注意的是，上面中的 KuaiCanFood 和 HamburgerFood 都继承自 Food。

简单地说，简单工厂模式通常就是这样，一个工厂类 XxxFactory，里面有一个静态方法，根据我们不同的参数，返回不同的派生自同一个父类（或实现同一接口）的实例对象。

我们强调职责单一原则，一个类只提供一种功能，FoodFactory 的功能就是只要负责生产各种 Food。

Java 各种框架中，简单工厂模式是非常常见的，比如JedisConnectionFactory。

基本上 Java 中需要创建连接的框架，都是用了工厂模式。

工厂模式

简单工厂模式很简单，在一般情况下，它都能满足我们的需要。但是，在某些特殊场景，它就满足不了我们的需求了。还是拿 Redis 为例，Redis 有单机模式，主从模式，哨兵模式，Cluster 模式。每种模式的连接都不一样，因此我们需要引入多个工厂。

这种情况下，就需要引入多个简单工厂模式。比如：JedisConnectionFactory、JredisConnectionFactory、LettuceConnectionFactory、SrpConnectionFactory等等。之所以需要引入工厂模式，是因为我们往往需要使用两个或两个以上的工厂。

还是以 Food 为例。

public interface FoodFactory {
    Food makeFood(String name);
}
public class ChineseFoodFactory implements FoodFactory {
    @Override
    public Food makeFood(String name) {
        if ("套餐A".equals(name)) {
            Food kuaican = new KuaiCanFood();
            kuaican.setPrice(20.00);
            kuaican.setName("快餐");
            return kuaican;
        } 
        
        if ("套餐B".equals(name)) {
            Food mifan = new MiFanFood();
            mifan.setPrice(18.00);
            mifan.setName("五常大米");
            return mifan;
        } 
        
        return null;
    }
}
public class AmericanFoodFactory implements FoodFactory {
    @Override
    public Food makeFood(String name) {
        if ("套餐A".equals(name)) {
            Food hamburger = new HamburgerFood();
            hamburger.setPrice(22.00);
            hamburger.setName("hamburger");
            return hamburger;
        } 
        
        if ("套餐B".equals(name)) {
            Food sandwich = new SandwichFood();
            sandwich.setPrice(25.00);
            sandwich.setName("三明治");
            return sandwich;
        } 
        
        return null;
    }
}

其中，KuaiCanFood、MiFanFood、HamburgerFood、SandwichFood 都派生自 Food。

消费者调用：

public class Consumer {
    public static void main(String[] args) {
        // 先选择一个具体的工厂
        FoodFactory factory = new ChineseFoodFactory();
        // 由选择的工厂产生具体的对象，不同的工厂造出不一样的对象
        Food food = factory.makeFood("套餐A");
    }
}

虽然都是调用 makeFood(“套餐A”) 制作套餐 A，但是，不同的工厂生产出来的完全不一样。

第一步，我们需要选取合适的工厂，然后第二步基本上和简单工厂一样。

核心在于，我们需要在第一步选好我们需要的工厂。比如，我们有 FileFactory 接口，实现类有 AliyunOssFactory 和 TencentCosFactory，分别对应将文件写入阿里云 OSS 和腾讯云 COS 中。很显然，我们客户端或者消费者第一步就需要决定到底要实例化 AliyunOssFactory 还是 TencentCosFactory，这将决定之后的所有的操作。

工厂模式非常简单，我把他们都画到一张图上，希望大家能够看图就会：

现在会了还不是真会，一定要在实践代码中使用，不然过不了多久就会忘记！

抽象工厂模式

有了简单工厂模式，和工厂模式，为什么还有抽象工厂模式？

这就是当涉及到产品族的时候，就需要引入抽象工厂模式了。当一个产品族，存在多个不同类型的产品(比如我上面列举的 Redis 连接工厂)情况下，不同架构模式，选择不同的连接工厂的问题。而这种场景在业务开发中也是非常多见的，只不过可能有时候没有将它们抽象化出来。

RedisConnectionFactory的例子，我就不在多说了，建议spring-data-redis中的源码多看几遍。下面我再列举一个生活中的经典的例子，就是造一台手机。我们先不引入抽象工厂模式，看看怎么实现。

因为手机是由许多的构件组成的，我们将处理器 CPU 和主板 Board 进行抽象，然后 CPU 由 CpuFactory 生产，主板由 MainBoardFactory 生产。然后，我们再将 CPU 和主板搭配起来组合在一起，如下图：

这个时候的如果需要手机产品，只需这样调用：

public class Phone {
    private Cpu cpu;
    private MainBoard mainBoard;
    public Phone(Cpu cpu, MainBoard mainBoard){
        this.cpu = cpu;
        this.mainBoard = mainBoard;
    }
    public static void main(String[] args) {
        // 得到华为的处理器
        CpuFactory KirinFactory = new HuaweiCpuFactory();
        Cpu cpu = KirinFactory.getCpu();
        // 得到华为的主板
        MainBoardFactory mainBoardFactory = new HuaweiMainBoardFactory();
        MainBoard mainBoard = mainBoardFactory.getMainBoard();
        // 组装手机CPU和主板
        Phone huaweiMate = new Phone(cpu, mainBoard);
    }
}

单独看处理器 CPU 工厂和主板工厂，它们分别是前面我们说的工厂模式。这种方式也容易扩展，因为要给手机加配件的话，只需要加一个 XxxFactory 和相应的实现即可，不需要修改现有的工厂。

但是，这种方式有一个问题，那就是如果苹果🍎家产的 CPU 和华为产的主板不能兼容使用，因此不能出现随意组合。这就是产品族的概念，它代表了组成某个产品的一系列配件的集合。

当涉及到这种产品族的问题的时候，就需要抽象工厂模式来支持了。我们不再定义 CPU 工厂、主板工厂、OS 工厂、显示屏工厂等等，我们直接定义手机工厂，每个手机工厂负责生产所有的设备，这样能保证肯定不存在兼容问题。

public interface PhoneFactory {
    Cpu getCpu();
    MainBoard getMainBord();
    Display getDisplay();
}
public class HuaweiPhoneFactory implements PhoneFactory {
    @Override
    public Cpu getCpu() {
        return new HuaweiCpu();
    }
    @Override
    public MainBoard getMainBord() {
        return new HuaweiMainBoard();
    }
    @Override
    public Display getDisplay() {
        return new BoeDisplay();
    }
}
public class XiaomiPhoneFactory implements PhoneFactory {
    @Override
    public Cpu getCpu() {
        return new HuaweiCpu();
    }
    @Override
    public MainBoard getMainBord() {
        return new XiaomiMainBoard();
    }
    @Override
    public Display getDisplay() {
        return new VisionoxDisplay();
    }
}

这种情况下，对于生产来说，不再需要单独挑选 CPU 厂商、显示屏厂商等，直接选择一家品牌工厂，品牌工厂会负责生产所有的东西，而且能保证肯定是兼容可用的。

public class Test {
    public static void main(String[] args) {
        // 第一步就要选定一个“大品牌工厂”
        PhoneFactory factory = new HuaweiPhoneFactory();
        // 从这个大厂设计制造CPU
        Cpu cpu = factory.getCpu();
        // 从这个大厂生产手机主板
        MainBoard board = factory.getMainBord();
        // 从这个大厂生产手机显示屏
        Display boeDisplay = factory.getDisplay();
        // 生产一个华为 Mete 40 手机
        Phone huaweiMete40 = new Phone(cpu, board, boeDisplay);
    }
}

这样一个抽象工厂的代码和案例就讲完了，如果还有不懂的，我下次再拿我们现在生产项目中的案例给大家讲解！

最后总结一下，功能模式根据需求和功能的不同，你可以选择对应的简单工厂，普通工厂，和抽象工厂。抽象工厂看起来比较抽象，它暴露的问题也是显而易见的，比如我们要加个 NFC 模块，就需要修改所有的工厂，给所有的工厂都加上制造显示器的方法。这有点违反了对修改关闭，对扩展开放这个设计原则。但也不要完全照搬设计原则，毕竟有时候是需要打破原则，不是吗？比如在电商系统中的一些反范式设计等。原文：https://mp.weixin.qq.com/s/H_kb_BObQVkTYcrF6orkPw

： » 设计模式之工厂模式，史上最强，不服来辩！