我们的项目代码也是由简而繁一步一步迭代而来的，但对于调用者来说却是越来越简单化。
简单工厂模式
简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创建出哪一种产品类的实例。适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。
简单工厂模式的实质是根据传递的参数，决定应该创建哪一类的产品
以课程为例，介绍简单工厂模式
【例1】 简单工厂模式实现课程中心程序
分析：课程中心有Java架构师，大数据，人工智能等课程。实现根据课程名称创建课程。定义一个课程接口(ICourse)
源代码
public interface ICourse{
// 录制的视频
void record();
}
创建一个Java课程的实现JavaCourse类：
public class JavaCourse implements ICourse{
@Override
public void record(){
System.out.println("录制Java课程.");
}
}
看客户端调用代码，我们这么写
public class SimpleFactoryTest{
public static void main(String[] args){
ICourse course = new JavaCourse();
course.record();
}
}
看上面的代码，父类ICourse指向了子类JavaCourse的引用，应用层代码需要依赖JavaCourse，如果业务需要扩展，继续增加PythonCourse甚至更多，那么客户端的依赖会变得越来越臃肿。因此。需要将这种依赖隐藏起来，把创建细节隐藏。虽然，目前的代码中，创建对象的过程并不复杂，但从代码设计角度来讲不易扩展。现在，用简单工厂模式对代码进行优化。
新增加的PythonCourse类
public class PythonCourse implements ICourse {
@Override
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();
ICourse course = factory.create("java");
course.record();
}
}
类图：
客户端调用是简单了，但如果我们业务需要扩展，要增加前端课程，需要对工厂的create()方法就要根据产品链的丰富每次都要修改代码逻辑，不符合开闭原则。因此，需要对简单工厂继续优化，利用反射技术。
public class CourseFactory{
public ICourse create(Class<? extends ICourse> clazz){
try {
if (Objects.nonNull(clazz)) {
return clazz.newInstance();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
客户端调用代码修改：
public class SimpleFactoryTest {
public static void main(String[] args) {
CourseFactory factory = new CourseFactory();
ICourse course = factory.create(JavaCourse.class);
course.record();
}
}
优化之后，产品不断丰富不需要修改CourseFactory中的代码，但是有个问题，就是create()方法参数是字符串，可控性有待提升，而且还需要强制类型转换，在进行优化下：
import java.util.Objects;
public class CourseFactory{
public ICourse create(Class<? extends ICourse> clazz){
try {
if (Objects.nonNull(clazz)) {
return clazz.newInstance();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
优化客户端代码：
public class SimpleFactoryTest {
public static void main(String[] args) {
CourseFactory factory = new CourseFactory();
ICourse course = factory.create(JavaCourse.class);
course.record();
}
}
再看一下类图：
简单工厂模式在JDK中也无处不在，现在举个例子，jdk中的Calendar类，看Calendar.getInstance()方法，下面打开源代码分析下：
public class Calendar{
private static Calendar createCalendar(TimeZone zone, Locale aLocale){
// ...
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;
}
}
- 总结
简单工厂模式中的工厂类职责相对过重，不易扩展过于复杂的产品结构。
工厂方法模式
工厂方法模式(Factory Method Pattern)是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节，而且加入新的产品符合k开闭原则。
工厂方法模式主要解决产品扩展的问题，在简单工厂中，随着产品链的丰富，如果每个课程的创建逻辑有区别的话，工厂的职责会变得越来越多，有点像万能工厂，并不便于维护。根据单一职责原则我们将继续拆分，专人干转事。Java课程有Java工厂创建，Python课程有Python工厂创建，对工厂本身也做了一个抽象。
public interface ICourseFactory{
ICourse create();
}
在分别创建子工厂，JavaCourseFactory类
public class JavaCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new JavaCourse();
}
}
创建PythonCourseFactory类
public class PythonCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new PythonCourse();
}
}
客户端调用
public class FactoryMethodTest {
public static void main(String[] args) {
ICourseFactory factory = new JavaCourseFactory();
factory.create().record();
factory = new JavaCourseFactory();
factory.create().record();
}
}
其类图：
看看logback中工厂方法模式的应用，看看类图就可以：
工厂方法模式适用于：
- 创建对象需要大量重复的代码
- 客户端(应用层)不依赖产品类实例如何被创建，实现等细节。
- 一个类通过子类来指定创建哪个对象。
工厂方法模式的缺点：
- 类的个数容易过多，增加复杂度。
- 增加了系统的抽象性和理解难度。
为了将对接的创建和使用分离，采用工厂模式，即程序将对象的创建和初始化动作交给工厂。
抽象工厂模式
抽象工厂模式(Abstract Factory Pattern)是指提供一个创建一系列相关或者相互依赖对象的接口，无需指定他们的具体实现类。客户端(应用层)不依赖产品类实例如何被创建，实现等细节， 强调的是一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖具体的实现。
需要理解产品族和产品等级结构的概念。比如：美的工厂可以生产洗衣机，空调，冰箱，格力工厂也可以生产洗衣机，空调，冰箱。同一个工厂生产的不同产品代表的是同一个产品族，不同工厂生成的同种产品代表同一个产品等级结构。
下面还是以课程中心为例来介绍抽象工厂模式
【例1】课程中心程序介绍抽象工厂模式
分析：课程不仅提供录播视频，还需要提供课堂笔记，甚至源码才能成为完整的课程。在产品等级中新增两个产品IVideo录播视频和INote课堂笔记。
IVideo录播视频接口
public interface IVideo {
void record();
}
INote课堂笔记接口
public interface INote {
void edit();
}
创建抽象工厂CourseFactory类
public interface CourseFactory {
IVideo createVideo();
INote createNote();
}
创建Java产品族，Java视频JavaVideo类
public class JavaVideo implements IVideo {
@Override
public void record() {
System.out.println("录制java视频");
}
}
扩展产品等级Java课堂笔记JavaNote类
public class JavaNote implements INote {
@Override
public void edit() {
System.out.println("编写Java笔记.");
}
}
创建java产品族的具体工厂JavaCourseFactory类
public class JavaCourseFactory implements CourseFactory {
@Override
public IVideo createVideo() {
return new JavaVideo();
}
@Override
public INote createNote() {
return new JavaNote();
}
}
创建python产品族，python视频PythonVideo类
public class PythonVideo implements IVideo {
@Override
public void record() {
System.out.println("录制python课程.");
}
}
扩展产品等级Python课堂笔记PythonNote类
public class PythonNote implements INote {
@Override
public void edit() {
System.out.println("编写python笔记.");
}
}
创建Python产品族的具体工厂PythonCourseFactory类
public class PythonCourseFactory implements CourseFactory {
@Override
public IVideo createVideo() {
return new PythonVideo();
}
@Override
public INote createNote() {
return new PythonNote();
}
}
客户端调用：
public class AbstractMethodTest {
public static void main(String[] args) {
CourseFactory factory = new JavaCourseFactory();
factory.createVideo().record();
factory.createNote().edit();
}
}
上面的代码完整的描述了两个产品族Java课程和Python课程，也描述了两个产品等级视频和笔记。抽象工厂非常完美清晰的描述这样一层复杂的关系。但是，如果想继续扩展产品等级的。比如将源码Source也加入到课程中的话，那么我们从代码到抽象工厂，到具体的实现类都要全部调整一遍，很显然不符合开闭原则。因此抽象工厂模式也是有缺陷的。
- 规定了所有可能被创建的产品集合，产品族中扩展新产品困难，需要修改抽象工厂接口。
- 增加了系统的抽象性和理解难度。
在实际开发中，不能犯强迫症甚至有洁癖。
,抽象工厂模式，将工厂具有的生产产品的能力定义成抽象方法，产品的具体实现，有基类实现。
