一文带你搞懂工厂设计模式

更多知识，请移步我的小破站：http://hellofriend.top

什么是工厂设计模式？

对象都需要创建，如果创建的时候直接 new 该对象，就会对该对象严重耦合。

假如我们要更换对象，所有 new 对象的地方都需要修改一遍，显然违背了软件设计的开闭原则（OCP）。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的。

工厂模式最大的优点就是：解耦。

三种工厂设计模式的使用

1. 简单工厂设计模式

定义：一个工厂方法，依据传入的参数，生成对应的产品对象；

角色：

• 抽象产品类
• 具体产品类
• 具体工厂类

使用说明：

• 先将产品类抽象出来，比如，苹果和梨都属于水果。
• 抽象出来一个水果类 Fruit，苹果和梨就是具体的产品类。
• 然后创建一个水果工厂，分别用来创建苹果和梨。
  
  抽象水果类

public abstract class Fruit {
    abstract void getName();
}

具体类 苹果

public class Apple extends Fruit {
    @Override
    public void getName() {
        System.out.println("Apple");
    }
}

具体类 梨

public class Pear extends Fruit {
	@Override
	public void getName() {
		System.out.println("Pear");
	}
}

水果工厂

public class FruitFactory {

    public Fruit createFruit(String type) {
        System.out.println("======SimpleFactory======");

        if (type.equals("apple")) {// 生产苹果
            return new Apple();
        } else if (type.equals("pear")) {// 生产梨
            return new Pear();
        }
        return null;
    }
}

简单工厂使用

public class SimpleFactory {
    public static void main(String[] args) {
        FruitFactory Factory = new FruitFactory();

        Apple apple = (Apple) Factory.createFruit("apple");// 获得苹果
        apple.getName();
        Pear pear = (Pear) Factory.createFruit("pear");// 获得梨
        pear.getName();
    }
}

小结：

• 一个简单工厂设计模式就完成了，但是有问题。如果我想吃香蕉，想吃橘子。这种方式，每当我想添加一种水果，就必然要修改工厂类，这显然也违反了开闭原则，亦不可取；所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说不合适。

2. 工厂方法设计模式

定义：将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定。（具体工厂生产具体类）

角色：

• 抽象产品类
• 具体产品类
• 抽象工厂类
• 具体工厂类
  
  和上例中一样，产品类抽象出来，此例把工厂类也抽象出来，工厂方法模式将对象的实例化推迟到子类。

水果抽象类 苹果类和梨类 代码和上例一样，此处省略。

抽象工厂类

public abstract class FruitFactory {
    public abstract Fruit createFruit();//生产水果
}

具体工厂 苹果工厂

public class AppleFactory extends FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}

具体工厂 梨工厂

public class PearFactory extends FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Pear();
    }
}

工厂方法使用

public class FactoryMethod {
    public static void main(String[] args) {
        System.out.println("======FactoryMethod======");
        AppleFactory appleFactory = new AppleFactory();
        PearFactory pearFactory = new PearFactory();

        Apple apple = (Apple) appleFactory.createFruit();// 获得苹果
        apple.getName();
        Pear pear = (Pear) pearFactory.createFruit();// 获得梨
        pear.getName();
    }
}

小结：

• 以上这种方式，虽然解耦了，也遵循了开闭原则，但是问题根本还是没有解决啊，换汤没换药，如果我需要的产品很多的话，需要创建非常多的工厂，所以这种方式的缺点也很明显。

3. 抽象工厂设计模式

定义：为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要指定它们的具体类。

角色：

• 抽象产品类
• 具体产品类
• 抽象工厂类
• 具体工厂类

抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列。

举个例子，假如生产 Iphone 手机，Iphone 手机有很多系列，Iphone8、IphoneXS等；假如Iphone8生产需要 CPU A11的处理器，LCD屏幕，而 IphoneXS 需要 CPU A12 的处理器和 OLED 屏幕；用抽象工厂来实现：

CPU 抽象类和实现类

public abstract class CPU {
    public abstract void run();
}

public class A11 extends CPU {
    @Override
    public void run() {
        System.out.println("A11");
    }
}

public class A12 extends CPU {
    @Override
    public void run() {
        System.out.println("A12");
    }
}

屏幕 抽象类和实现类

public abstract class Screen {
    public abstract void isScreen();
}

public class LCD extends Screen {
    @Override
    public void isScreen() {
        System.out.println("LCD");
    }
}

public class OLED extends Screen {
    @Override
    public void isScreen() {
        System.out.println("OLED");
    }
}

手机工厂接口

public interface PhoneFactory {
    CPU getCpu();// 使用的cpu
    Screen getScreen();// 使用的屏幕
}

手机工厂实现

public class Iphone8Factory implements PhoneFactory {
    @Override
    public CPU getCpu() {
        return new A11();
    }

    @Override
    public Screen getScreen() {
        return new LCD();
    }
}

public class IphoneXsFactory implements PhoneFactory {
	@Override
	public CPU getCpu() {
		return new A12();
	}

	@Override
	public Screen getScreen() {
		return new OLED();
	}
}

抽象工厂使用

public class AbstractFactory {
    public static void main(String[] args) {

        Iphone8Factory iphone8Factory = new Iphone8Factory();
        IphoneXsFactory iphoneXSFactory = new IphoneXsFactory();

        System.out.println("======iphone8Factory=====");
        CPU cpuA11 = iphone8Factory.getCpu();
        cpuA11.run();
        Screen screenLCD = iphone8Factory.getScreen();
        screenLCD.isScreen();

        System.out.println("======iphoneXsFactory=====");
        CPU cpuA12 = iphoneXSFactory.getCpu();
        cpuA12.run();
        Screen screenOLED = iphoneXSFactory.getScreen();
        screenOLED.isScreen();
    }
}

小结：

• 以上例子可以看出，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的产品，用抽象工厂可以更好的管理和扩展。

三种工厂方式总结

• 对于简单工厂和工厂方法来说，两者的使用方式实际上是一样的，如果对于产品的分类和名称是确定的，数量是相对固定的，推荐使用简单工厂模式。
• 抽象工厂用来解决相对复杂的问题，适用于一系列、大批量的对象生产。

JDK 中工厂设计模式的应用 Calendar 类

下面是 JDK 的源码：

Calendar.getInstance();

public static Calendar getInstance(){
        return createCalendar(TimeZone.getDefault(), 					                              Locale.getDefault(Locale.Category.FORMAT));
}

public static Locale getDefault(Locale.Category category) {
    // do not synchronize this method - see 4071298
    switch (category) {
        case DISPLAY:
            if (defaultDisplayLocale == null) {
                synchronized(Locale.class) {
                    if (defaultDisplayLocale == null) {
                        defaultDisplayLocale = initDefault(category);
                    }
                }
            }
            return defaultDisplayLocale;
        case FORMAT:
            if (defaultFormatLocale == null) {
                synchronized(Locale.class) {
                    if (defaultFormatLocale == null) {
                        defaultFormatLocale = initDefault(category);
                    }
                }
            }
            return defaultFormatLocale;
        default:
            assert false: "Unknown Category";
    }
    return getDefault();
}


private static Calendar createCalendar(TimeZone zone,Locale aLocale){
    CalendarProvider provider =
        LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
        .getCalendarProvider();
    if (provider != null) {
        try {
            return provider.getInstance(zone, aLocale);
        } catch (IllegalArgumentException iae) {
            // fall back to the default instantiation
        }
    }

    Calendar cal = null;

    if (aLocale.hasExtensions()) {
        String caltype = aLocale.getUnicodeLocaleType("ca");
        if (caltype != null) {
            switch (caltype) {
                case "buddhist":
                    cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
            }
        }
    }
    if (cal == null) {
        // If no known calendar type is explicitly specified,
        // perform the traditional way to create a Calendar:
        // create a BuddhistCalendar for th_TH locale,
        // a JapaneseImperialCalendar for ja_JP_JP locale, or
        // a GregorianCalendar for any other locales.
        // NOTE: The language, country and variant strings are interned.
        if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
            cal = new BuddhistCalendar(zone, aLocale);
        } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                   && aLocale.getCountry() == "JP") {
            cal = new JapaneseImperialCalendar(zone, aLocale);
        } else {
            cal = new GregorianCalendar(zone, aLocale);
        }
    }
    return cal;
}