工厂模式

三种工厂模式

简单工厂模式

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

代码实现：

//1.先定义一个课程接口
public interface ICourse {
	 /** 录制视频 */ 
 	public void record();
}

//2.创建一个 Java 课程的实现 JavaCourse 类：
public class JavaCourse implements ICourse {
	 public void record() { 
	 	System.out.println("录制 Java 课程"); 
	 }
}

//3.客户端调用代码
public static void main(String[] args) {
	 ICourse course = new JavaCourse(); 
	 course.record(); 
}

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

1.先增加课程 PythonCourse 类：

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

2.创建 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; 
		} 
	} 
}

3.修改客户端调用代码：

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

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

工厂方法模式

工厂方法模式（Fatory Method Pattern）是指定义一个创建对象的接口，但让实现这 个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。在工厂 方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的 产品符合开闭原则。
工厂方法模式主要解决产品扩展的问题，在简单工厂中，随着产品链的丰富，如果每个 课程的创建逻辑有区别的话，工厂的职责会变得越来越多，有点像万能工厂，并不便于维护。根据单一职责原则我们将职能继续拆分，专人干专事。Java 课程由 Java 工厂 创建， Python 课程由 Python 工厂创建，对工厂本身也做一个抽象。来看代码，
1.先创建 ICourseFactory 接口：

public interface ICourseFactory {
 ICourse create(); 
}

2.分别创建子工厂，JavaCourseFactory 类：

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

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

3.测试代码

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

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

抽象工厂模式

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

以课程为例，学院第三期课程有了新的标准，每个课程不仅要提供课程的录播视频，而且还要提供老师的课堂笔记。相 当于现在的业务变更为同一个课程不单纯是一个课程信息，要同时包含录播视频、课堂笔记甚至还要提供源码才能构成一个完整的课程。

1.在产品等级中增加两个产品 IVideo 录播视频和 INote 课堂笔记。

//INote 接口：
public interface INote { 
	void edit(); 
}

//IVideo 接口：
public interface IVideo { 
	void record(); 
}

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

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

3.创建 Java 产品族，Java 视频 JavaVideo 类:

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

4.扩展产品等级Java课堂笔记JavaNote类:

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

5.创建 Java 产品族的具体工厂 JavaCourseFactory

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

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

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

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

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

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

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

9.客户端调用

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

上面的代码完整地描述了两个产品族 Java 课程和 Python 课程，也描述了两个产品等级视频和手记。抽象工厂非常完美清晰地描述这样一层复杂的关系。但是，如果我们再继续扩展产品等级，将源码 Source 也加入到课程中，那么我们的代码从抽象工厂，到具体工厂要全部调整，很显然不符合开闭原则。因此抽象工厂也是有缺点的：
1、规定了所有可能被创建的产品集合，产品族中扩展新的产品等级困难，需要修改抽象工 厂的接口。
2、增加了系统的抽象性和理解难度。

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