工厂模式

作者: 愤怒的奶牛 | 来源:发表于2019-12-15 22:07 被阅读0次

在生活中，我们用的所有东西都是通过工厂生产出来，比如：手机，汽车，电脑等。在面向对象的世界里，对象也是可以通过工厂来创建的。今天我们就来谈论一下创建型模式--工厂设计模式。

1. 案例背景

设计模式一般比较抽象，为了方便理解，我们首先来引用一个生活中的例子-- 消费者去汽车城或者4s 店买汽车。这里有一下对象：1. 消费者； 2. 汽车销售方。 3. 汽车。

2. 不用设计模式

这里我们首先来分析不使用设计模式的情况下，代码的实现方式

Car 接口

生活中汽车销售方一般是4s 店或者汽车经销商，一般都会销售不同品牌或者型号的汽车，但是具体是啥汽车我们不知道，所以设计一个Car 接口，来抽象一下汽车的型号或者品牌

public interface Car {
    /**
     * 驾驶
汽车就一个方法，被被人驾驶
     */
    void drive();
}

汽车

汽车接口设计好了，接下来我们就来设计一下具体的汽车，假设是宝马和奥迪

public class BMWCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶 BMW  ！");
    }
}

public class AODICar implements Car {
    @Override
    public void drive() {
        System.out.println("  驾驶 奥迪  ！");

    }
}

汽车销售对象

汽车有了，接下来我们来设计汽车销售对象。假设该能售卖宝马和奥迪

public class SaleCarStore {

    public Car sale(String carName) {
        Car car = null;
      if ("BMW".equals(carName)) {//宝马汽车
          car = new BMWCar();
      }
      if ("AODI".equals(carName)) {// 奥迪汽车
          car = new AODICar();
      }
      return car;
    }
}

汽车销售方就一个方法，就是 sale 汽车。我们没有使用设计模式的情况下，一般是自己 new 对象。当然实际生活中一般都是汽车工厂生产好汽车，交给4s 店或者其他经销商来卖。后面我们再来分析使用汽车工厂的好处。

消费者

接下来我们只需要设计一个消费者对象，通过汽车消费方去购买汽车即可。

public class CarCustomer {
    private SaleCarStore saleCarStore ;
    CarCustomer(SaleCarStore saleCarStore) {//消费者汽车售卖对象买车
        this.saleCarStore = saleCarStore;
    }

    public Car getCar(String carName) {
        Car car = saleCarStore.sale(carName);
        return car;
    }

    /**
     * 驾驶 买完车之后就 自己开车走了
     * @param car
     */
    public void drive(Car car) {
        car.drive();
    }
    public static void main(String[] args) {
        SaleCarStore saleCarStore = new SaleCarStore();
        CarCustomer carCustomer = new CarCustomer(saleCarStore );// 消费者 通过 SaleCarStore  对象买车
        Car bwm = carCustomer.getCar("BMW");// 假设购买的是 宝马
        carCustomer.drive(bwm);
    }

上面是我们在没有使用工厂设计模式下的代码。消费者成功的购买到了汽车，并开走了。这时候，又有一个消费者要来买汽车了，但是他嫌宝马和奥迪都太贵了，要买五菱宏光，但是这时候汽车销售对象，没有五菱宏光，但是上面的生意不可能不做吧，于是就连夜赶工搞到了一台。于是 SaleCarStore 对象就必须要修改:

public class SaleCarStore {

    public Car sale(String carName) {
        Car car = null;
      if ("BMW".equals(carName)) {//宝马汽车
          car = new BMWCar();
      }
      if ("AODI".equals(carName)) {// 奥迪汽车
          car = new AODICar();
      }
      // add 
      if ("WLHG".equals(carName)) {// 五菱宏光
          car = new WLHGCar();
      }
      return car;
    }
}

----- 购买
public static void main(String[] args) {
        SaleCarStore car4sStore = new SaleCarStore();
        CarCustomer carCustomer = new CarCustomer(car4sStore);
        Car bwm = carCustomer.getCar("WLHG");
        carCustomer.drive(bwm);
    }

好了，钱赚到了。生意越来越好，接下来，买各种各样的车的人都有，比如思域啊，迈锐宝XL 啊，奥迪A4L 啊等等。那么我们这时候如果在原来的基础上满足消费者的需求就要不断的添加如下类似的代码:

// add .......
      if ("WLHG".equals(carName)) {// 五菱宏光
          car = new WLHGCar();
      }
// add .......

这时候，老板就发现，自己不能再这样搞下去了，虽然钱赚到了，自己却累的要死。于是，就想到一个主意：顾客要来买车，就先下个单子，拿到这个单子以后，去联系汽车生产厂商，然他们去生产汽车，自己中间赚差价就好了。于是，代码就可以改成下面的样子：

汽车工厂--简单工厂

public class SimpleCarFactory {

    public Car createCar(String carName) {
        Car car = null;
        if ("BMW".equals(carName)) {//宝马汽车
            car = new BMWCar();
        }
        if ("AODI".equals(carName)) {// 奥迪汽车
            car = new AODICar();
        }
        if ("WLHG".equals(carName)) {// 五菱宏光
            car = new WLHGCar();
        }

        return car;
    }
}
----- SaleCarStore 
public class SaleCarStore {

    private SimpleCarFactory simpleCarFactory;
    SaleCarStore(SimpleCarFactory simpleCarFactory) {
        this.simpleCarFactory = simpleCarFactory;
    }

    public Car sale(String carName) {
//        Car car = null;
////      if ("BMW".equals(carName)) {//宝马汽车
////          car = new BMWCar();
////      }
////      if ("AODI".equals(carName)) {// 奥迪汽车
////          car = new AODICar();
////      }
////      // add
////      if ("WLHG".equals(carName)) {// 五菱宏光
////          car = new WLHGCar();
////      }
        // 简单工厂创建Car 对象
        Car car = simpleCarFactory.createCar(carName);
        return car;
    }
}
---- CarCustomer#main
 public static void main(String[] args) {
// 简单工厂
        SimpleCarFactory simpleCarFactory = new SimpleCarFactory();
        SaleCarStore saleCarStore = new SaleCarStore(simpleCarFactory);
        CarCustomer carCustomer = new CarCustomer(saleCarStore);
        Car bwm = carCustomer.getCar("WLHG");
        carCustomer.drive(bwm);
    }

好了，现在汽车经销商老板轻松了，不管顾客需要什么样的汽车，都可以交给 SimpleCarFactory 工厂来生产了。

注意：简单工厂模式原本是不属于常用23中设计模式中的，在《Head First》中有解释，上面的案例也是从这本书中演变来的，书中是披萨案例。

工厂方法

承接上一个案例，虽然顾客对汽车的需求加大，各种汽车都要满足，于是 SimpleCarFactory 汽车工厂必须扩展自己的 createCar 方法，随着工厂规模的发展出现了以下代码：

 public Car createCar(String carName) {
        Car car = null;
        if ("BMW".equals(carName)) {//宝马汽车
            car = new BMWCar();
        }
        if ("AODI".equals(carName)) {// 奥迪汽车
            car = new AODICar();
        }
        if ("WLHG".equals(carName)) {// 五菱宏光
            car = new WLHGCar();
        }
       // add if()........
       // add if()........
       // add if()........
        return car;
    }

我们发现，要是无限添加 if ，createCar 方法会变得难以维护。作为工厂老板，就想了一个办法，把 createCar （）拆开，分成不同的生产小组，生产各自的汽车，于是代码就变成了这样：

public class CarFactoryMethod  {

    //生产宝马
    public BMWCar createBMWCar() {
        return new BMWCar();
    }

    // 生产奥迪
    public AODICar createAODICar() {
        return new AODICar();
    }

    //生产五菱宏光
    public WLHGCar createWLHGCar() {
        return new WLHGCar();
    }
}

上面这个模式就被叫做工厂方法。如果，现在新增一个汽车，只需要添加一个方法，来创建即可。

抽象工厂

随着工厂的发展，宝马车出现了不同的车系，如X1，X6 等，奥迪出现了 A3，A4L，A6L等，于是，宝马和奥迪工厂就独立出来了，单独生产这几种车系。

public class BMWFactoryMethod {

    public BMWCarX1 X1() {
        return new BMWCarX1();
    }

    public BMWCarX5 X5() {
        return new BMWCarX5();
    }
}

------- 奥迪车系
public class AODIFactoryMethod {

    public AODICarA3 aodiCarA3() {
        return new AODICarA3();
    }
    
    public AODICarA4L aodiCarA4L() {
        return new AODICarA4L();
    }
}

首先，要说明一个问题，抽象工厂，不是对代码的抽象，也就说在代码里面我们不需要将工厂用 abstract 修饰，抽象工厂，是从《Head First》中翻译过来的，抽象工厂是对工厂方法的延伸，抽象工厂可以生产一系列相关的产品，比如宝马系列，奥迪系列。这里就是国内经常有人说的产品到产品族的概念。注意，这里为了描述简单，并没有抽取接口，重要的是编程思想，我们从工厂方法，生产单个汽车产品，到扩展到一个工厂可以生产一系列相关的系列汽车产品，也就是从工厂方法扩展到了抽象工厂。那么抽象就应该是对事物扩展的抽象了，而不是具体对代码的抽象，并不强制你对代码进行抽象。比如，扩展宝马车系，对不可预见的车系进行抽象，因为我并不知道，下一个宝马车系是啥，但是一旦确定了，就可以直接在工厂中添加方法创建即可，所以，这里的抽象应该是对事物的抽象。

在我们明白了产品到产品系列的概念后，可以对抽象工厂进行接口设计。

CarFactory

/**
 * car 工厂定义
 */
public interface CarFactory {

    Car createCar(String type);
}

----- car 
public class BMWCarX1 implements Car {

    public BMWCarX1() {
        System.out.println("X1");
    }

    @Override
    public void drive() {
        System.out.println("drive X1");
    }
}

public class BMWCarX5 implements Car {

    public BMWCarX5() {
        System.out.println("X5");
    }

    @Override
    public void drive() {
        System.out.println("drive X5");
    }
}

------- BMWCarFactoryMethod 抽象工厂
public class BMWCarFactoryMethod implements CarFactory {
    @Override
    public Car createCar(String type) {
        switch (type) {
            case "X1":
                return bmwCarX1();
            case "X5":
                return bmwCarX5();
        }
        return null;
    }

    private BMWCarX1 bmwCarX1() {
        return new BMWCarX1();
    }
    private BMWCarX5 bmwCarX5() {
        return new BMWCarX5();
    }
}

到这里我们就分析了工厂模式中的简单工厂，工厂方法和抽象工厂的设计思想。我们可以发现一个问题，工厂模式是不符合开闭原则的，但是比较符合单一职责原则，工厂模式实现方式可以有多中，不必纠结固定的实现方式。

工厂模式

1. 案例背景

2. 不用设计模式

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

设计模式