简单工厂模式、工厂方法模式以及抽象工厂模式（详解）

1.简单工厂模式

简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于 GOF，23 种设计模式（参考资料：http://c.biancheng.net/view/1317.html）。简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

• 接下来我们来看代码，还是以课程为例，设有 Java 架构、大数据、人工智能等课程，已经形成了一个生态。我们可以定义一个课程标准 ICourse 接口：

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

• 创建一个 Java 课程的实现 JavaCourse 类：

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

• 客户端调用代码

public static void main(String[] args) {
	ICourse course = new JavaCourse();
	course.record();
}

• 看上面的代码，父类 ICourse 指向子类 JavaCourse 的引用，应用层代码需要依赖 JavaCourse，如果业务扩展，我继续增加 PythonCourse 甚至更多，那么我们客户端的依赖会变得越来越臃肿。因此，我们要想办法把这种依赖减弱，把创建细节隐藏。虽然目前的代码中，我们创建对象的过程并不复杂，但从代码设计角度来讲不易于扩展。
• 现在，我们用简单工厂模式对代码进行优化，先增加课程 PythonCourse 类：

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

• 创建 CourseFactory 工厂类：

public class CourseFactory {
	public ICourse create(String name) {
		if("java".equals(name)) {
			return new JavaCourse();
		}else if("python".equals(name)) {
			return new PythonCourse();
		}else {
			return null;
		}
	}
}

• 修改客户端调用代码：

public class SimpleFactoryTest {
	public static void main(String[] args) {
		CourseFactory factory = new CourseFactory();
		factory.create("java");
	}
}

• 当然，我们为了调用方便，可将 factory 的 create()改为静态方法，下面来看一下类图：
  
• 客户端调用是简单了，但如果我们业务继续扩展，要增加前端课程，那么工厂中的 create() 就要根据产品链的丰富每次都要修改代码逻辑。不符合开闭原则。因此，我们对简单工厂还可以继续优化，可以采用反射技术：

public class CourseFactory {
	public ICourse create(String className) {
		try {
			if (!(null == className || "".equals(className))) {
				return (ICourse) Class.forName(className).newInstance();
			}
		}catch (Exception e) {
			e.printStackTrace();
		}return null;
	}
}

• 修改客户端调用代码：

public static void main(String[] args) {
	CourseFactory factory = new CourseFactory();
	ICourse course = factory.create("com.guang.factory.simplefactory.JavaCourse");
	course.record();
}

• 优化之后，产品不断丰富不需要修改 CourseFactory 中的代码。但是，有个问题是，方法参数是字符串，可控性有待提升，而且还需要强制转型。我们再修改一下代码：

public ICourse create(Class<? extends ICourse> clazz) {
	try {
		if (null != clazz) {
			return clazz.newInstance();
		}
	}catch (Exception e) {
		e.printStackTrace();
	}
	return null;
}

• 优化客户端代码：

public static void main(String[] args) {
	CourseFactory factory = new CourseFactory();
	ICourse course = factory.create(JavaCourse.class);
	course.record();
}

• 再看一下类图：
  
• 简单工厂模式在 JDK 源码也是无处不在，现在我们来举个例子，例如 Calendar 类，看 Calendar.getInstance()方法，下面打开的是 Calendar 的具体创建类：

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

• 还有一个大家经常使用的 logback，我们可以看到 LoggerFactory 中有多个重载的方法 getLogger()：

public static Logger getLogger(String name) {
	ILoggerFactory iLoggerFactory = getILoggerFactory();
	return iLoggerFactory.getLogger(name);
}
public static Logger getLogger(Class clazz) {
	return getLogger(clazz.getName());
}

简单工厂也有它的缺点：工厂类的职责相对过重，不易于扩展过于复杂的产品结构。

2.工厂方法模式

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

• 工厂方法模式主要解决产品扩展的问题，在简单工厂中，随着产品链的丰富，如果每个课程的创建逻辑有区别的话，工厂的职责会变得越来越多，有点像万能工厂，并不便于维护。根据单一职责原则我们将职能继续拆分，专人干专事。Java 课程由 Java 工厂创建，Python 课程由 Python 工厂创建，对工厂本身也做一个抽象。来看代码，先创建 ICourseFactory 接口：

public interface ICourseFactory {
	ICourse create();
}

• 在分别创建子工厂，JavaCourseFactory 类和 PythonCourseFactory 类：

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

public class PythonCourseFactory implements ICourseFactory {
	public ICourse create() {
		return new PythonCourse();
	}
}

• 编写测试代码：

public static void main(String[] args) {
	ICourseFactory factory = new PythonCourseFactory();
	ICourse course = factory.create();
	course.record();
	factory = new JavaCourseFactory();
	course = factory.create();
	course.record();
}

• 现在再来看一下类图：
  
• 再来看看 logback 中工厂方法模式的应用，看看类图就 OK 了：
  

工厂方法适用于以下场景：
1、创建对象需要大量重复的代码。
2、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
3、一个类通过其子类来指定创建哪个对象。
工厂方法也有缺点：
1、类的个数容易过多，增加复杂度。
2、增加了系统的抽象性和理解难度。

3.抽象工厂模式

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

• 讲解抽象工厂之前，我们要了解两个概念产品等级结构和产品族，看下面的图：
  
• 从上图中看出有正方形，圆形和菱形三种图形，相同颜色深浅的就代表同一个产品族，相同形状的代表同一个产品等级结构。同样可以从生活中来举例，比如，美的电器生产多种家用电器。那么上图中，颜色最深的正方形就代表美的洗衣机、颜色最深的圆形代表美的空调、颜色最深的菱形代表美的热水器，颜色最深的一排都属于美的品牌，都是美的电器这个产品族。再看最右侧的菱形，颜色最深的我们指定了代表美的热水器，那么第二排颜色稍微浅一点的菱形，代表海信的热水器。同理，同一产品结构下还有格力热水器，格力空调，格力洗衣机。
• 再看下面的这张图，最左侧的小房子我们就认为具体的工厂，有美的工厂，有海信工厂，有格力工厂。每个品牌的工厂都生产洗衣机、热水器和空调。
  
• 通过上面两张图的对比理解，相信大家对抽象工厂有了非常形象的理解。接下来我们来看一个具体的业务场景而且用代码来实现。还是以课程为例，每个课程不仅要提供课程的录播视频，而且还要提供老师的课堂笔记。相当于现在的业务变更为同一个课程不单纯是一个课程信息，要同时包含录播视频、课堂笔记甚至还要提供源码才能构成一个完整的课程。在产品等级中增加两个产品 IVideo 录播 视频和 INote 课堂笔记。
• IVideo 接口：

public interface IVideo {
	void record();
}

• INote 接口：

public interface INote {
	void edit();
}

• 然后创建一个抽象工厂 CourseFactory 类：

/**
 * 抽象工厂是用户的主入口
 * 在Spring中应用得最为广泛的一种设计模式
 * 易于扩展
 **/
 public interface CourseFactory {
 	INote createNote();
 	IVideo createVideo();
 }

• 接下来，创建 Java 产品族，Java 视频 JavaVideo 类:

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

• 扩展产品等级 Java 课堂笔记 JavaNote 类：

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

• 创建 Java 产品族的具体工厂 JavaCourseFactory:

public class JavaCourseFactory implements CourseFactory {
	public INote createNote() {
		return new JavaNote();
	}
	public IVideo createVideo() {
		return new JavaVideo();
	}
}

• 然后创建 Python 产品，Python 视频 PythonVideo 类：

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

• 扩展产品等级 Python 课堂笔记 PythonNote 类：

public class PythonNote implements INote {
	public void edit() {
		System.out.println("编写 Python 笔记");
	}
}

• 创建 Python 产品族的具体工厂 PythonCourseFactory:

public class PythonCourseFactory implements CourseFactory {
	public INote createNote() {
		return new PythonNote();
	}
	public IVideo createVideo() {
		return new PythonVideo();
	}
}

• 客户端调用：

public static void main(String[] args) {
	JavaCourseFactory factory = new JavaCourseFactory();
	factory.createNote().edit();
	factory.createVideo().record();
}

• 上面的代码完整地描述了两个产品族 Java 课程和 Python 课程，也描述了两个产品等级 视频和手记。抽象工厂非常完美清晰地描述这样一层复杂的关系。但是，不知道大家有没有发现，如果我们再继续扩展产品等级，将源码 Source 也加入到课程中，那么我们的代码从抽象工厂，到具体工厂要全部调整，很显然不符合开闭原则。

因此抽象工厂也是有缺点的：
1、规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
2、增加了系统的抽象性和理解难度。

• 但在实际应用中，我们千万不能犯强迫症甚至有洁癖。在实际需求中产品等级结构升级是非常正常的一件事情。我们可以根据实际情况，只要不是频繁升级，可以不遵循开闭 原则。代码每半年升级一次或者每年升级一次又有何不可呢？