简单工厂，工厂方法，抽象工厂 简单工厂和抽象工厂

Simple Factory Pattern

简单工厂模式

简单工厂模式定义

简单工厂模式是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于GOF23种设计模式。简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

在JDK源码中，Calendar来就用了简单工厂。通过getInstance()的几种重载方法得到一个Calendar的实例。但是创建Calendar类实例的逻辑都在createCalendar方法中。我们可以看一下它的实现代码:

/**
 * Gets a calendar with the specified time zone and locale.
 * The <code>Calendar</code> returned is based on the current time
 * in the given time zone with the given locale.
 *
 * @param zone the time zone to use
 * @param aLocale the locale for the week data
 * @return a Calendar.
 */
public static Calendar getInstance(TimeZone zone,
                                   Locale aLocale)
{
    return createCalendar(zone, aLocale);
}

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;
}

这几个Calendar实例类的关系如下：

简单工厂的缺点

工厂类的职责相对过重，不易于扩展过于复杂的产品结构。

Factory Method Pattern

工厂方法模式

工厂方法模式定义

工厂方法模式是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中，用户只需要关心所需产品对应的工厂，无须关系创建细节，而且加入新的产品符合开闭原则。

我们用代码来实现一下工厂方法。首先我们定义JavaCourse和PythonCourse,因为课程遵循统一的规范，所以定义一个ICourse接口

public interface ICourse {
    /**
     * 录制视频
     * @return
     */
    void record();
}

public class JavaCourse implements ICourse {

    public void record() {
        System.out.println("录制Java课程");
    }
}

public class PythonCourse implements ICourse {

    public void record() {
        System.out.println("录制Python课程");
    }
}

当用户需要用到某个课程实例时，我们依然交给工厂去创建。和简单工厂不是，我们给每门课都创建一个对应的工厂，课程的实例化放到对应的工厂里面，而这些工厂都实现同一个工厂接口。当用户需要获取课程的实例时，只需要指定工厂，就可以得到对应的课程实例了。

/**
 * 工厂模型
 * Created by Zerlinda.
 */
public interface ICourseFactory {

    ICourse create();
}

public class JavaCourseFactory implements ICourseFactory {
    public ICourse create() {
        return new JavaCourse();
    }
}

public class PythonCourseFactory implements ICourseFactory {

    public ICourse create() {
        return new PythonCourse();
    }
}

这就是一个工厂方法模式的实现。

通过类图关系，我们可以更清晰的看清楚它们的关系：

工厂方法适用场景

1. 创建对象需要大量重复的代码。
   
2. 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
3. 一个类通过其子类来指定创建哪个对象

工厂方法缺点

1. 类的个数容易过多，增加复杂度。
   
2. 增加了系统的抽象性和理解难度。

Abastract Factory Pattern

抽象工厂模式

抽象工厂模式定义

抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

产品等级结构和产品族图

在第二张图里面的x轴表示产品族，y轴表示产品等级。在产品族为西数CPU工厂上，可以看到对应的产品等级有西数主板、西数硬盘、西数CPU。同样的，在三星CPU工厂上，对应的产品等级有三星主板、三星硬盘、三星CPU。所以产品族指某具体工厂（如三星，西数，希捷等）所生产的一系列的产品，产品等级指的是同一工厂，生产的不同类型的产品（如主板，硬盘，CPU等）。

弄清楚了产品等级和产品族，再来看抽象工厂模式。一个工厂就是一个对外的接口，它提供了创建一系列相关或相互依赖的对象的口子。用户通过选择不同的工厂，就可以得到对应工厂的产品族的对象了。

抽象工厂缺点

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
• 增加了系统的抽象性和理解难度。
  

在实际需求中产品等级结构升级是非常正常的一件事情。我们可以根据实际情况，只要不是频繁升级，可以不遵循开闭原则。代码每半年升级一次或者每年升级一次又有何不可呢？

在简单工厂里面，一个工厂就可以返回不同的产品。而在工厂方法里面，由用户指定工厂，一个工厂只返回一种特定的产品。可以说简单工厂是产品的工厂，工厂方法是简单工厂的工厂。那么抽象工厂是什么呢？抽象工厂可以说是工厂方法的工厂。抽象工厂的实现工厂类里面，可以提供一系列相关或相互依赖的产品。简单工厂，工厂方法，抽象工厂，它们是层层递进的关系。它们的相同点都是用户不需要关心具体的实现细节，不同点是，工厂提供的产品实例是不断扩大的。

我们来看看抽象工厂的代码实现。我们的业务里面包括Java课程系列和Python课程系列。每一个课程系列里面包含课堂直播Course,笔记Note和录播视频Video。那么我们这里的产品等级就包括Course，Note，Video。产品族就是Java和Python。由于每一个产品都有统一的规范，所以我们先为每类产品定义一个接口规范。

public interface ICourse {
    /**
     * 录制视频
     * @return
     */
    void record();
}/**
 * 课堂笔记
 * Created by Zerlinda.
 */
public interface INote {
    void edit();
}
/**
 * 录播视频
 * Created by Zerlinda.
 */
public interface IVideo {
    void record();
}

接着为每个产品族各自的产品，这里我们只把Java族的产品实现代码贴出来

public class JavaCourse implements ICourse {

    public void record() {
        System.out.println("录制Java课程");
    }
}

public class JavaNote implements INote {

    public void edit() {
        System.out.println("编写Java笔记");
    }
}

public class JavaVideo implements IVideo {
    public void record() {
        System.out.println("录制Java视频");
    }
}

类似的，Ptyhon族也有自己的产品实现。

接着我们来创建抽象工厂，也就是创建一个提供一系列相关或者相互依赖的产品的接口。

/**
 * 抽象工厂是用户的主入口
 * 在Spring中应用得最为广泛的一种设计模式
 * 易于扩展
 * Created by Zerlinda.
 */
public abstract class CourseFactory {

    public void init(){
        System.out.println("初始化基础数据");
    }

    protected abstract INote createNote();
    protected abstract IVideo createVideo();
}

每个产品族有对应的工厂来实现这个抽象工厂，并提供该产品族一系列的产品。

public class JavaCourseFactory extends CourseFactory {

    public INote createNote() {
        super.init();
        return new JavaNote();
    }

    public IVideo createVideo() {
        super.init();
        return new JavaVideo();
    }
}

public class PythonCourseFactory extends CourseFactory {

    public INote createNote() {
        super.init();
        return new PythonNote();
    }


    public IVideo createVideo() {
        super.init();
        return new PythonVideo();
    }
}

到这里，大家对简单工厂，工厂方法，抽象工厂是不是有了一个清晰的认识呢？欢迎大家留言共同探讨！