工厂模式总结

Posted 2022-08-30 enjoyjava

1.简单工厂——一个工厂创建多类产品（对象）

简单工厂模式（SimpleFactory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于GOF，23种设计模式（参考资料：http://en.wikipedia.org/wiki/Design_Patterns#Patterns_by_Type）。简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数(类的名字，或者类的class对象)，对于如何创建对象的逻辑不需要关心。以课程为例，首先创建接口及其具体的实现：

1 package com.gupaoedu.vip.pattern.factory;
2 
3 public interface ICourse 
4     //录制课程
5     void record();
6 

1 package com.gupaoedu.vip.pattern.factory;
2 
3 public class JavaCourse implements ICourse 
4     @Override
5     public void record() 
6         System.out.println("录制Java课程...");
7     
8 

1 package com.gupaoedu.vip.pattern.factory;
2 
3 public class PythonCourse implements ICourse 
4     @Override
5     public void record() 
6         System.out.println("录制python课程");
7     
8 

简单工厂：

 1 package com.gupaoedu.vip.pattern.factory.simplefactory;
 2 import com.gupaoedu.vip.pattern.factory.ICourse;
 3 import com.gupaoedu.vip.pattern.factory.JavaCourse;
 4 import com.gupaoedu.vip.pattern.factory.PythonCourse;
 5 
 6 /**
 7  * 简单工厂,一个工厂可以创建不同的产品(对象)
 8  */
 9 public class CourseFactory 
10     public ICourse create(String name) 
11         if ("java".equals(name)) 
12             return new JavaCourse();
13          else if("python".equals(name))
14             return new PythonCourse();
15          else 
16             return null;
17         
18     
19 

客户端调用：

 1 package com.gupaoedu.vip.pattern.factory.simplefactory;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 import org.apache.log4j.BasicConfigurator;
 5 import org.slf4j.Logger;
 6 import org.slf4j.LoggerFactory;
 7 
 8 import java.util.Calendar;
 9 
10 /**
11  * 简单工厂模式，
12  * 只适用于产品比较少，创建逻辑比较简单的场景
13  */
14 public class SimpelFactoryTest 
15 
16     public static void main(String[] args) 
17         //创建工厂
18         CourseFactory factory = new CourseFactory();
19         //从工厂获得对象,不必每次都手动new ICourse,缺点，参数传入错误，则获取不到对象
20         ICourse course = factory.create("java");
21         course.record();
22         course = factory.create("python");
23         course.record();
24     
25 

上面的简单工厂存在的问题：如果要新增一个课程，那么工厂类的代码就必须要修改，不符合开闭原则，另外，传入参数错误，将获取不到正确的对象，因此，对工厂类CourseFactory做如下改进：

 1 package com.gupaoedu.vip.pattern.factory.simplefactory;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 
 5 /**
 6  * 简单工厂,一个工厂可以创建不同的产品(对象)
 7  */
 8 public class CourseFactory 
 9    /* public ICourse create(String name) 
10         if ("java".equals(name)) 
11             return new JavaCourse();
12          else if("python".equals(name))
13             return new PythonCourse();
14          else 
15             return null;
16         
17     */
18     //简单工厂的改进，使用反射机制获取对象
19     public ICourse create(Class clazz) 
20         try 
21             if (null != clazz) 
22                 return (ICourse) clazz.newInstance();
23             
24          catch (Exception e) 
25             e.printStackTrace();
26         
27         return null;
28     
29 

调用代码：

 1 package com.gupaoedu.vip.pattern.factory.simplefactory;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 import com.gupaoedu.vip.pattern.factory.JavaCourse;
 5 import com.gupaoedu.vip.pattern.factory.PythonCourse;
 6 
 7 /**
 8  * 简单工厂模式，
 9  * 只适用于产品比较少，创建逻辑比较简单的场景
10  */
11 public class SimpelFactoryTest 
12 
13     public static void main(String[] args) 
14         //创建工厂
15         CourseFactory factory = new CourseFactory();
16         //从工厂获得对象,不必每次都手动new ICourse,缺点，参数传入错误，则获取不到对象
17     /*    ICourse course = factory.create("java");
18         course.record();
19         course = factory.create("python");
20         course.record();*/
21 
22         ICourse javaCourse = factory.create(JavaCourse.class);
23         javaCourse.record();
24         ICourse pythonCourse = factory.create(PythonCourse.class);
25         pythonCourse.record();
26 
27     
28 

2.工厂方法模式（一个工厂只生产一种产品（创建一种对象））

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

 1 package com.gupaoedu.vip.pattern.factory.factorymethod;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 
 5 /**
 6  * 工厂方法模式,一个工厂只能创建一种 产品(返回一种对象)
 7  * 这里接口还可以改为抽象类,把一些公共的处理放到抽象类里面
 8  */
 9 public interface ICourseFactory 
10     ICourse create(); //这个接口不活,让它的子类干活
11 

分别创建2个实现类，返回不同的工厂

 1 package com.gupaoedu.vip.pattern.factory.factorymethod;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 import com.gupaoedu.vip.pattern.factory.JavaCourse;
 5 
 6 /**
 7  * 单一职责,这个工厂只能创建JavaCourse;不同的产品用不同的工厂创建;不同的工厂去负责差异化的创建逻辑
 8  */
 9 public class JavaCourseFactory implements  ICourseFactory 
10     @Override
11     public ICourse create() 
12         return new JavaCourse(); //这个工厂只能创建JavaCourse,直接new即可
13     
14 

 1 package com.gupaoedu.vip.pattern.factory.factorymethod;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 import com.gupaoedu.vip.pattern.factory.PythonCourse;
 5 
 6 public class PythonCourseFactory implements ICourseFactory 
 7     @Override
 8     public ICourse create() 
 9         return new PythonCourse();
10     
11 

调用：

 1 package com.gupaoedu.vip.pattern.factory.factorymethod;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 
 5 public class FactoryMethodTest 
 6     public static void main(String[] args) 
 7         ICourseFactory  factory = new PythonCourseFactory();
 8         ICourse course = factory.create();
 9         course.record();
10     
11 

 工厂方法适用于以下场景：

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

 三，抽象工厂模式

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

产品等级结构和产品族，看下面的图:

同种类称为同等级，同相同等级的一类产品可以由不同的工厂生产，这些不同工厂生产出来的同一类产品，称之为一个产品等级

同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图 所示的是海尔工厂和 TCL 工厂所生产的电视机与空调对应的关系图。

（图片摘自http://c.biancheng.net/view/1351.html ）

现在假设上面的课程进行了升级，现在的业务变更为同一个课程不单纯是一个课程信息，要同时包含录播视频、课堂笔记，甚至还要提供源码才能构成一个完整的课程。在产品等级中增加两个产品IVideo录播

视频和INote课堂笔记。

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public interface ICourse 
4     //录制课程
5     void record();
6 

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public interface INote 
4     void edit();//记笔记
5 

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public interface IVideo 
4     void record();
5 

 1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 
 5 /**
 6  * 要求所有的子工厂都实现 这个工厂
 7  * 一个品牌的抽象
 8  */
 9 public interface ICourseFactory 
10     ICourse createCourse();
11     //不仅能创建课程,还能创建笔记和视频
12     INote createNote();
13 
14     IVideo createVideo();
15 

实现类：

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public class JavaCourse implements ICourse 
4     @Override
5     public void record() 
6         System.out.println("录制Java课程...");
7     
8 

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public class PythonCourse implements ICourse 
4     @Override
5     public void record() 
6         System.out.println("录制python课程");
7     
8 

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public class JavaNote implements INote 
4     @Override
5     public void edit() 
6         System.out.println("编写java笔记");
7     
8 

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public class PythonNote implements INote 
4     @Override
5     public void edit() 
6         System.out.println("编写python笔记");
7     
8 

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public class JavaVideo implements IVideo 
4     @Override
5     public void record() 
6         System.out.println("录制java视频");
7     
8 

1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
2 
3 public class PythonVideo implements IVideo 
4     @Override
5     public void record() 
6         System.out.println("录制python视频");
7     
8 

工厂的实现类：每个工厂都可以生产三种产品

 1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 import com.gupaoedu.vip.pattern.factory.JavaCourse;
 5 
 6 public class JavaCourseFactory implements ICourseFactory 
 7     @Override
 8     public ICourse createCourse() 
 9         return new JavaCourse();
10     
11 
12     @Override
13     public INote createNote() 
14         return new JavaNote();
15     
16 
17     @Override
18     public IVideo createVideo() 
19         return new JavaVideo();
20     
21 

 1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
 2 
 3 import com.gupaoedu.vip.pattern.factory.ICourse;
 4 import com.gupaoedu.vip.pattern.factory.PythonCourse;
 5 
 6 public class PythonCourseFactory implements ICourseFactory 
 7     @Override
 8     public ICourse createCourse() 
 9         return new PythonCourse();
10     
11 
12     @Override
13     public INote createNote() 
14         return new PythonNote();
15     
16 
17     @Override
18     public IVideo createVideo() 
19         return new PythonVideo();
20     
21 

测试类：

 1 package com.gupaoedu.vip.pattern.factory.abstractfactory;
 2 
 3 public class AbstractFactoryTest 
 4     public static void main(String[] args) 
 5         ICourseFactory factory = new JavaCourseFactory();
 6         //同一个工厂创建多个产品;同一个产品可以被不同的工厂创建
 7          factory.createCourse().record();
 8          factory.createNote().edit();
 9          factory.createVideo().record();
10 
11          //python工厂
12         PythonCourseFactory pythonCourseFactory = new PythonCourseFactory();
13         pythonCourseFactory.createCourse().record();
14         pythonCourseFactory.createNote().edit();
15         pythonCourseFactory.createVideo().record();
16     
17 

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

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

 三种工厂模式UML类图对比：

简单工厂模式： 一个工厂创建所有对象（小作坊，什么都生产，工厂和产品一对多）

工厂方法模式：创建工厂接口/抽象类,让子类去创建对象；一套产品分的零部件由不同的工厂生产，每个工厂只生产一种零部件（创建一类对象）（工厂和产品一对一）

抽象工厂模式：不同工厂可以生产相同 的产品（产品族），一个产品可以给不同工厂去生产（产品等级），工厂和产品之间多对多的关系