我们的项目代码也是由简而繁一步一步迭代而来的,但对于调用者来说却是越来越简单化。

简单工厂模式

简单工厂模式(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(); } }

类图:

简单工厂模式(1.工厂模式详解)(1)

客户端调用是简单了,但如果我们业务需要扩展,要增加前端课程,需要对工厂的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(); } }

再看一下类图:

简单工厂模式(1.工厂模式详解)(2)

简单工厂模式在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(); } }

其类图:

简单工厂模式(1.工厂模式详解)(3)

看看logback中工厂方法模式的应用,看看类图就可以:

简单工厂模式(1.工厂模式详解)(4)

简单工厂模式(1.工厂模式详解)(5)

工厂方法模式适用于:

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

工厂方法模式的缺点:

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

为了将对接的创建和使用分离,采用工厂模式,即程序将对象的创建和初始化动作交给工厂。

抽象工厂模式

抽象工厂模式(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也加入到课程中的话,那么我们从代码到抽象工厂,到具体的实现类都要全部调整一遍,很显然不符合开闭原则。因此抽象工厂模式也是有缺陷的。

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

在实际开发中,不能犯强迫症甚至有洁癖。

抽象工厂模式,将工厂具有的生产产品的能力定义成抽象方法,产品的具体实现,有基类实现。

,