工厂设计模式

1、工厂模式

1.1、真传一句话

总结来说一句话：工厂模式实现了创建者和调用者的分离！

• 实例化对象不使用 new，用工厂方法替代
• 将 选择实现类 和 创建对象 统一管理和控制，从而将调用者跟我们的实现类解耦。

1.2、分类

1. 简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要修改已有代码）。
2. 工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品产品）
3. 抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称其他工厂的工厂。

2、实现

2.1 不用工厂模式

创建一个接口类 Car：

public interface Car {
    void name();
}

创建 Car 的实现类：

public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

public class XiaoPeng implements Car {
    @Override
    public void name() {
        System.out.println("小鹏汽车！");
    }
}

消费者要得到一个车，只能通过 new 自己造一个车，费时费力：

public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLing();
        Car car2 = new XiaoPeng();

        car.name();
        car2.name();
    }
}

运行结果：

五菱宏光！
小鹏汽车！

2.2、简单工厂模式

现在我们有了一个 CarFactory 工厂，该工厂对外提供静态方法 getCar ，消费者想要得到车，直接跟工厂要，付钱就完事了，不用在意造车时那些费时费力的参数和细节（工厂替你办了）。

public class CarFactory {
    public static Car getCar(String carName){
        if(carName.equals("五菱")){
            return new WuLing();
        }else if(carName.equals("小鹏")){
            return new XiaoPeng();
        }else{
            return null;
        }
    }
}

public class Consumer {
    public static void main(String[] args) {
        Car car = CarFactory.getCar("五菱");
        Car car2 = CarFactory.getCar("小鹏");

        car.name();
        car2.name();
    }
}

优缺点：简单工厂模式虽然分离了创建者和调用者，但是如果我们想要添加一种品牌的车，就需要修改 CarFactory 中的 getCar 方法，违反了开闭原则。

可能有的人会想到，可以把 getCar 方法分离成不同的 get 方法，例如：

public class CarFactory {
    public static Car getWuLing(){
        return new WuLing();
    }
    
    public static Car getXiaoPeng(){
        return new XiaoPeng();
    }
}

这样就不用修改方法中的代码了，直接在工厂类中扩展方法就可以了。但是，这样会造成方法的繁多，且我们希望的是在扩展时，不要改动 CarFactory 类。

2.3、工厂方法模式

为了满足开闭原则，就诞生了工厂方法模式，其可以实现横向扩展。

这里我们创建两个接口，分别为 Car 和 CarFactory ，因为无论是汽车还是工厂，都要有他们的标准。

public interface Car {
    void name();
}

public interface CarFactory {
    Car getCar();
}

如果像简单工厂模式那样，一个工厂造所有品牌的车，那岂不是这个工厂决定着这些车企的命运，这就是赤裸裸的垄断！有点偏题，其实我想表达的是，自家的车企要有自己的工厂，这样才不会被别人卡脖子。这样消费者要买哪家的车，就去哪家的工厂。这就是工厂方法模式！

public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

public class WuLingFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

public class XiaoPeng implements Car {
    @Override
    public void name() {
        System.out.println("小鹏汽车！");
    }
}

public class XiaoPengFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new XiaoPeng();
    }
}

这样消费者要买哪家的车，就去哪家的工厂：

public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLingFactory().getCar();
        Car car2 = new XiaoPengFactory().getCar();

        car.name();
        car2.name();
    }
}

运行结果：

五菱宏光！
小鹏汽车！

这时，如果别的车企建立了，也要建自己的工厂，这样就实现了横向扩展，而不是修改原来的工厂。例如此时，蔚来车企建立了：

public class WeiLai implements Car {
    @Override
    public void name() {
        System.out.println("蔚来汽车！");
    }
}

public class WeiLaiFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WeiLai();
    }
}

消费者只需：

public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLingFactory().getCar();
        Car car2 = new XiaoPengFactory().getCar();

        car.name();
        car2.name();

        Car car3 = new WeiLaiFactory().getCar();
        car3.name();
    }
}

运行结果：

五菱宏光！
小鹏汽车！
蔚来汽车！

工厂方法模式虽然符合了开闭原则，但是造成了：创建的类非常多的问题。

和简单工厂模式对比：

• 结构复杂度：简单工厂模式
• 代码复杂度：简单工厂模式
• 编程复杂度：简单工厂模式
• 管理上的复杂度：简单工厂模式

结论：虽然根据设计原则，工厂方法模式更好，但是实际业务还是用简单工厂模式。

2.4、抽象工厂模式

定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们的具体类。（晦涩难懂，看下面的例子）

使用场景：产品种类相对固定的一些产品族，可以考虑抽象工厂模式。如果产品种类频繁变动，就不适用了。

结构图：

2.4.1 实例结构

我们可以这样理解，抽象工厂像是规定工厂中要生产产品的清单，至于生产什么样的、什么品牌的，各个厂家自己去完成。

2.4.2 代码

首先我们先要定一些工厂所生产产品的标准：

public interface PhoneProduct {
    void start();
    void shutdown();
    void call();
    void sendMS();
}

public interface RouterProduct {
    void start();
    void shutdown();
    void openWifi();
    void setting();
}

再定义一下我们的抽象工厂要生产哪些产品（抽象工厂的标准）;

public interface AbstractFactory {
    //生产手机
    PhoneProduct ProductPhone();

    //生产路由器
    RouterProduct ProductRouter();
}

这时，我们的华为公司登场了，他建立工厂造产品：

public class HuaweiPhone implements PhoneProduct {
    @Override
    public void start() {
        System.out.println("开启华为手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }

    @Override
    public void call() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendMS() {
        System.out.println("华为手机发短信");
    }
}

public class HuaweiRouter implements RouterProduct {
    @Override
    public void start() {
        System.out.println("启动华为路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为路由器");
    }

    @Override
    public void openWifi() {
        System.out.println("打开华为路由器Wifi");
    }

    @Override
    public void setting() {
        System.out.println("设置华为路由器");
    }
}

public class HuaweiFactory implements AbstractFactory {
    @Override
    public PhoneProduct ProductPhone() {
        return new HuaweiPhone();
    }

    @Override
    public RouterProduct ProductRouter() {
        return new HuaweiRouter();
    }
}

这时，我们的小米公司也成立了，他也建厂生产产品：

public class XiaomiPhone implements PhoneProduct {
    @Override
    public void start() {
        System.out.println("开启小米手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }

    @Override
    public void call() {
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendMS() {
        System.out.println("小米手机发短信");
    }
}

public class XiaomiRouter implements RouterProduct {
    @Override
    public void start() {
        System.out.println("启动小米路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米路由器");
    }

    @Override
    public void openWifi() {
        System.out.println("打开小米路由器Wifi");
    }

    @Override
    public void setting() {
        System.out.println("设置小米路由器");
    }
}

public class XiaomiFactory implements AbstractFactory {
    @Override
    public PhoneProduct ProductPhone() {
        return new XiaomiPhone();
    }

    @Override
    public RouterProduct ProductRouter() {
        return new XiaomiRouter();
    }
}

到这里，我们的例子就讲完了，如果企业还想生产别的产品，其代码就太多了，所以一般产品种类频繁变动的场景，不适用抽象工厂模式！

UML类图：

3、小结

1. 简单工厂模式：虽然某种程度上不符合设计原则，但实际使用最多！
2. 工厂方法模式：不修改已有类的前提下，通过新的工厂类实现扩展。
3. 抽象工厂模式：不可以增加产品，可以增加产品族。

应用场景：

• JDK中Calendar的getInstance方法
• JDBC中的Connection对象的获取
• Spring中IOC容器创建管理bean对象
• 反射中Class对象的newInstance方法