工厂方法模式

工厂方法模式

本章导学

工厂方法模式是简单工厂模式的延伸,它继承了简单工厂模式的优点,同时还弥补了简单工厂模式的缺陷,更好地符合开闭原则的要求,在增加新的具体产品对象时不需要对已有的系统做任何修改。
本章将通过如何克服简单工厂模式的不足来引出工厂方法模式,并通过实例来学习工厂方法模式,理解工厂方法模式的结构及特点,学会如何在实际软件项目开发合理地使用工厂方法模式。

本章知识点

  1. 工厂方法模式的定义
  2. 工厂方法模式的结构
  3. 工厂方法模式的实现
  4. 工厂方法模式的应用
  5. 工厂方法模式的优/缺点
  6. 工厂方法模式的适用环境
  7. 配量文件与反射
  8. 工厂方法的重载
  9. 工厂方法的隐藏

工厂方法模式概述

考虑这样一个系统,使用简单工厂模式设计的按钮工厂类可以返回一个具体类型的 按钮实例,例如圆形按钮矩形按钮、菱形按钮等。
在这里插入图片描述
在这个系统中如果需要增加一种新类型的按钮,例如椭圆形按钮,那么除了增加一个新的具体产品类之外还需要修改工厂类的代码,这就使得整个设计在一定程度上违反了开闭原则。
现在对该系统进行修改,不再提供一个按钮工厂类来统一负责所有产品的创建,而是将具体按钮的创建过程交给专门的工厂子类去完成。先定义一个抽象的按钮工厂类,再定义具体的工厂类来生产圆形按钮、矩形按钮、菱形按钮等,它们实现了在抽象按钮工厂类中声明的方法。这种抽象化的结果是使得这种结构可以在不修改具体工厂类的情况下引进新的产品,如果出现新的按钮类型,只需要为这种新类型的按钮定义一个具体的工厂类就可以创建该新按钮的实例,这种改进的设计方案即为工厂方法模式。工厂方法模式通过引入抽象的工厂类,使得它具有超越简单工厂模式的优越性,让系统更加符合开闭原则。
在这里插入图片描述
在工厂方法模式中不再提供一个统一的工厂类来创建所有的产品对象,而是针对不同的产品提供不同的工厂,系统提供一个与产品等级结构对应的工厂等级结构。
工厂方法模式的定义如下:
工厂方法模式:定义一个用于创建对象的接口,但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

工厂方法模式简称为工厂模式( Factory Pattern),又可称作虚拟构造器模式('Virtual
Constructor Pattern)或多态工厂模式( Polymorphic Factory Pattern)。工厂方法模式是种类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类负责生成具体的产品对象,这样做的目的是将产品类的实例操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类

工厂方法模式结构与实现

工厂方法模式结构

工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法,而由其子类来具体实现
工厂方法,创建具体的产品对象。
在这里插入图片描述
工厂方法模式包含以下4个角色。
(1) Product(抽象产品):它是定义产品的接口,是工厂方法模式所创建对象的超类型,也就是产品对象的公共父类
(2) ConcreteProduct(具体产品):它实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,具体工厂和具体产品之间一一对应
(3) Factory(抽象工厂):在抽象工厂类中声明了工厂方法( Factory Method),用于返回一个产品。抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口。
(4) ConcreteFactory(具体工厂):它是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,并可由客户端调用,返回一个具体产品类的实例

工厂方法模式实现

与简单工厂模式相比,工厂方法模式最重要的特点是引入了抽象工厂角色,抽象工厂可以是接口,也可以是抽象类或者具体类。其典型代码如下:

public interface Factory {
	public Product factoryMethod();
}

在抽象工厂中声明了工厂方法但并未实现工厂方法,具体产品对象的创建由其子类负责,客户端针对抽象工厂编程,可在运行时再指定具体工厂类,具体工厂类实现了工厂方法,不同的具体工厂可以创建不同的具体产品。其典型代码如下:

public class ConcreteFactory implements Factory {
	public Product factoryMethod() {
		return new ConcreteProduct();
	}
}

在实际使用时,具体工厂类在实现工厂方法时除了创建具体产品对象之外,还可以负责产品对象的初始化工作以及一些资源和环境配置工作,例如连接数据库、创建文件等。在客户端代码中,开发人员只需关心工厂类即可,不同的具体工厂可以创建不同的产品。典型的客户端代码片段如下:

Factory factory;
//可通过配置文件与反射机制实现
factory = new ConcreteFactory();
Product product;
product= factory.factoryMethod();

可以通过配置文件来存储具体工厂类 ConcreteFactory的类名,再通过反射机制创建具体工厂对象,在更换新的具体工厂时无须修改源代码,系统扩展更为方便

工厂方法模式应用实例

下面通过一个应用实例来进一步学习和理解工厂方法模式。

  1. 实例说明

某系统运行日志记录器( Logger)可以通过多种途径保存系统的运行日志,例如通过文件记录或数据库记录,用户可以通过修改配置文件灵活地更换日志记录方式。在设计各类日志记录器时,开发人员发现需要对日志记录器进行一些初始化工作,初始化参数的设置过程较为复杂,而且某些参数的设置有严格的先后次序,否则可能会发生记录失败。 为了更好地封装记录器的初始化过程并保证多种记录器切换的灵活性,现使用工厂方法模式设计该系统(注:在Java中常用的日志记录工具有SLF4J、Log4、GCLog Viewer、Logstash等)。
2.实力类图
通过分析,本实例结构图如下
在这里插入图片描述
在图4-4中, Logger接口充当抽象产品,其子类 FileLogger和 DatabaseLogger充当具体产品, LoggerFactory接口充当抽象工厂,其子类 FileLoggerFactory和DatabaseLoggerFactory充当具体工厂。

3.实例代码
(1)Logger:日志记录器接口,充当抽象产品角色。

//desagmpatterns.factorymethod Logger. Java
package designpatterns. factorymethod;

public interface Logger {
	public void writeLog();
}

(2) DatabaseLogger:数据库日志记录器,充当具体产品角色

//designpatterns.factorymethod. DatabaseLogger.java
package designpatterns.factorymethod

public class DatabaseLogger implements Logger {
	public void writeLog() {
		System.out.println("数据库日志记录");
	}

(3) Filelogger:文件日志记录器,充当具体产品角色。

public class FileLogger implements Logger {
	public void writeLog() {
		System.out.printin("文件日志记录");
	}
}

(4) LoggerFactory:日志记录器工厂接口,充当抽象工厂角色

public interface LoggerFactory {
	public Logger createLogger(); // 抽象工厂方法
}

(5) DatabaseFactory:数据库日志记录器工厂类,充当具体工厂色

public class DatabaseLoggerFactory implements LoggerFactory {
	public Logger createLogger(){
		//连接数据库,代码省略
		//创建数据库日志记录器对象
		Logger logger= new DatabaseLogger();
		//初始化数据库日志记录器,代码省略
		return logger;
	}
}

(6) FileLoggerFactory:文件日志记录器工厂类,充当具体工厂角色

public class FileLoggerFactory implements LoggerFactory{
	public Logger createlogger() {
		// 创建文件日志记录器对象
		Logger logger= new FileLogger();
		//创建文件,代码省略
		
		return logger;
	}
} 

(7) Client:客户端测试类

public class Client {
	public static vold main(string []args){
		LoggerFactory factory;
		Logger logger;
		factory = new FileloggerFactory();//可引入配置文件和反射机制实现
		logger = factory.createlogger();
		logger.writeLog();
	}
}

结果及分析
编译并运行程序,输出结果如下

文件日志记录

如果需要更换日志记录器,只需要修改客户端代码中的具体工厂类的类名即可,例如将FileLoggerFactory改为 DatabaseLoggerFactory,此时输出结果如下:

数据库日志记录

如果需要增加并使用新的日志记录器,只需要对应增加一个新的具体工厂类,然后在客户端代码中修改具体工厂类的类名,原有类库的源代码无须做任何修改。通过引入配置文件并使用反射机制可以实现在不修改客户端代码的基础上更换具体工厂类,在下面将详细说明其实现过程,让系统更加符合开闭原则,具备更好的灵活性和可扩展性。

反射机制与配置文件

在上一节的日志记录器实例中,在更换日志记录器时需要修改客户端代码,对于客户端而言并不符合开闭原则,本节将介绍如何在不修改任何客户端代码的基础上更换或增加新的日志记录方式。
在实际应用开发中可以对具体工厂类的实例化过程进行改进,在客户端代码中不直接使用new关键字来创建工厂对象,而是通过Java反射机制结合配置文件(例如XML文件)来生成具体工厂对象。在整个实现过程中需要用到两个技术,即Java反射机制与配置文件。
1.Java反射机制
Java反射( Java Reflection)是指在程序运行时获取已知名称的类或已有对象的相关信息的一种机制,包括类的方法、属性、父类等信息,还包括实例的创建和实例类型的判断等。在反射中使用最多的类是 Class, Class类的实例表示正在运行的Java应用程序中的类和接口,其 forName(String className)方法可以返回与带有给定字符串名的类或接口相关联的Class对象,再通过 Class对象的 newInstance()方法创建此对象所表示的类的一个新实例,即通过一个类名字符串得到类的实例。例如创建一个字符串类型的对象,其代码如下:

//通过类名生成实例对象并将其返回
Class c = Class.forName("java.lang.String");
Object obj = c .newInstance();
return obj;

此外,在JDK中还提供了java.lang.reflect包,封装了其他与反射相关的类,在本书中只用到上述简单的反射代码,在此不予扩展。
2.配置文件
软件系统的配置文件通常为XML文件,可以使用DOM( Document Object Model)、SAX( Simple API for XMl.)、StAx( Streaming API for XML.)等技术来处理XML文件。在软件开发中可以把类名存储到XML配置文件中,再读取配置文件获取类名字符串,然后通过Java反射机制来创建对象。例如将上一小节的具体日志记录器工厂类类名FileLoggerFactory存储在如下XML格式的配置文件 c

<!-- config.xml -->
<?xml version ="1.0"?>
<config>
<className>designpatterns.factorymethod.FileLoggerFactory</className>
</config>

在该文件中, designpatterns.factorymethod为具体工厂类所在的包名, FileLoggerFactory 为具体工厂类的类名。
为了读取该配置文件,并通过存储在其中的类名字符串反射生成对象,可以创建一个工具类XMLUtil,其详细代码如下

package design.simplefactory;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XMLUtil {
	public static Object getBean() {
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = null;
		try {
			builder = factory.newDocumentBuilder();
			
			Document document = builder.parse("src/design/config.xml");
			
			// 获取包含类名的文本节点
			NodeList list = document.getElementsByTagName("className");
			Node classNode = list.item(0).getFirstChild();
			String cName = classNode.getNodeValue().trim();
			Class c = Class.forName(cName);
			Object obj = c.newInstance();
			return obj;
		} catch (ParserConfigurationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SAXException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return null;
	}

}

注:在后续的设计模式学习过程中将多次重用该类。
有了 XMLUtiI类之后,可以对日志记录器的客户端代码进行修改,不再直接使用new关键字来创建具体的工厂类,而是将具体工厂类的类名存储在XML文件中,再通过XMLUtil类的静态工厂方法 getBean()进行对象的实例化,将代码修改如下:

public class Client {
	public static vold main(string []args){
		LoggerFactory factory;
		Logger logger;
		// getBean()的返回值类型为Object,需要进行强制类型转换
		factory = (LoggerFactory) XMLUtil.getBean();
		logger = factory.createlogger();
		logger.writeLog();
	}
}

在引入 XMLUti类和XM配置文件之后,如果需要增加一种新类型的日志记录方式只需要执行以下4个步:
(1)新的日志记录器需要继承抽象日志记录器 Logger
(2)对应增加一个新的具体日志记录器工厂,继承抽象日志记录器工厂LoggerFacto
ry,并实现其中的工厂方法 createLogger(),设置好初始化参数和环境变量,返回具体日志记录器对象。
(3)修改配置文件 config.xml,用新增的具体日志记录器工厂类的类名字符替换原有工厂类的类名字符串
(4)编译新增的具体日志记录器类和具体日志记录器工厂类,运行客户端测试类即可使用新的日志记录方式,而原有类库代码无须做任何修改,完全符合开闭原则

通过上述重构可以使系统更加灵活,由于很多设计模式都关注系统的可扩展性和灵活性,因此都定义了抽象层,在抽象层中声明业务方法,而将具体业务方法的实现放在实现层中。为了更好地体现这些设计模式的特点,本书在很多设计模式中都使用XML配置文件和Java反射机制来创建对象。

工厂方法的重载

在某些情况下,可以通过多种方式来初始化同一个产品类。例如上面所提到的日志记录器类,可以为各种日志记录器提供默认实现;还可以为数据库日志记录器提供数据库连接字符串,为文件日志记录器提供文件路径;也可以将相关参数封装在一个 Object类型的对象中,通过 Object对象将配置参数传入工厂类。此时可以提供一组重载的工厂方法,以不同的方式对产品对象进行创建。当然,对于同一个具体工厂而言,无论使用哪个工厂方法,所创建的产品类型均要相同。重载的工厂方法结构图如图所示。
在这里插入图片描述

引入重载方法后,抽象工厂类LoggerFactory的代码修改如下:

public interface LoggerFactory{
	public Logger createLogger();
	public Logger createLogger(String args);
	public Logger createLogger(Object obj);
}

具体工厂类 DatabaseLoggerFactory的代码修改如下

public class DatabaseLoggerFactory implements LoggerFactory{
	public Logger createLogger(){
			//使用默认方式连接数据库,代码省略
			Logger logger = new DatabaseLogger();
			//初始化数据库日志记录器,代码省略
			return logger;
	}
	public Logger createLogger(String args){
		//使用参数args作为连接字符串来连接数据库,代码省略
		Logger logger = new DatabaseLogger();
		//初始化数据库日志记录器,代码省略
		return logger;
	}
	public Logger createLogger(Object obj){
		//使用封装在参数objb中的连接字符串来连接数据库,代码省略
		Logger logger = new DatabaseLogger();
		//使用封装在参数obj中的数据来初始化数据库志记录器,代码省略
		return logger;
	}
	
}
	//其他具体工厂类代码省略

在抽象工厂中声明了多个重载的厂方法,在具体工厂中实现了这些工了方法,这些方法可以包含不同的业务逻辑,以满足产品对象的多样化创建需求。

工厂方法的隐藏

有时候,为了进一步简化客户端的使用,还可以对客户端隐藏工厂方法,此时在工厂类中直接调用产品类的业务方法,客户端无须调用工厂方法创建产品对象,直接使用工厂对象即可调用所创建的产品对象中的业务方法。
如果对客户端隐藏工厂方法,那么如图4-4所示的日志记录器结构图可修改为如图所示的结构图

在这里插入图片描述
在图4-6中,抽象工厂类 LoggerFactory的代码修改如下:

//将接口改为抽象类
public abstract class LoggerFactory{
	//在工厂类中直接调用日志记录器类的业务方法 
	public void writeLog(){
		Logger logger = this.createLogger();
		logger.writeLog();
	}
	public abstract logger createLogger();
}

客户端代码修改如下:

public class Client{
	public static void main(String [] args) {
		LoggerFactory factory;
		factory = (LoggerFactory) XMLUtil.getBean();
		//直接使用工厂对象来调用产品对象的业务方法
		factory.writeLog();
	}
}

通过把业务方法的调用移至工厂类中,可以直接使用工厂对象来调用产品对象的业务方法,客户端无须使用工厂方法来创建产品对象。在某些情况下可以使用这种设计方案。

工厂方法模式优/缺点与适用环境

工厂方法模式是简单工厂模式的延伸,它继承了简单厂模式的优点,同时还弥补了简单工厂模式的不足。工厂方法模式是使用频率最高的设计模式之一,是很多开源框架和API类库的核心模式。
工厂方法模式优点
(1)在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无需知道具体产品类的类名。
(2)基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够让工厂自主确定创建何种产品对象,而如何创建这个对象的细节完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,正是因为所有的具体工厂类都具有同一抽象父类。
(3)使用工厂方法模式的另一个优点是在系统中加入新产品时无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,只需要添加一个具体工厂和具体产品即可,这样系统的可扩展性也就变得非常好,完全符合开闭原则。
工厂方法模式缺点
工厂方法模式的缺点主要如下:
(1)在添加新产品时需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。
(2)由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度。
工厂方法模式适用环境
在以下情况下可以考虑使用工厂方法模式:
(1)客户端不知道它所需要的对象的类。在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体产品对象由具体工厂类创建,可将具体工厂类的类名存储在配置文件或数据库中。
(2)抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时子类对象将覆盖父类对象,从而使得系统更容易扩展。

本章小结

  1. 在工厂方法模式中定义一个用于创建对象的接口,但是让子类决定将哪一个类实化。工厂方法模式让一个类的实例化延迟到其子类,它是一种类创建型模式。
  2. 工厂方法模式包含抽象产品、具体产品、抽象工厂和具体工厂4个角色。其中,抽产品是定义产品的接口;具体产品实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建;抽象工厂声明了工厂方法,用于返回一个产品;具体工厂是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,返回一个具体产品类的实例。
  3. 工厂方法模式的优点主要是提供了专门的工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节;它能够让工厂自主确定创建何种产品对象,而如何创建这个对象的细节完全封装在具体工厂内部;在系统中加入新产品时完全符合开闭原则。其缺点主要是系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,会给系统带来一些额外的开销;增加了系统的抽象性和理解难度。
  4. 工厂方法模式适用于以下环境:客户端不知道它所需要的对象的类;抽象工厂类通过其子类来指定创建哪个对象。
  5. 通过引入配置文件和反射机制将具体工厂类的类名存储在配置文件中,然后使用反射来生成工厂对象,使得系统可以在不修改任何已有代码的基础上能够增加新的产品类,完全符合开闭原则。
  6. 在抽象工厂中可以声明多个重载的工厂方法,在具体工厂中实现了这些工厂方法,这些方法可以包含不同的业务逻辑,以满足产品对象的多样化创建需求
  7. 在工厂类中可以直接调用产品类的业务方法,客户端无须调用工厂方法创建产品对象,直接使用工厂对象即可调用所创建的产品对象中的业务方法,实现对工厂方法的隐藏。
原文链接:加载失败,请重新获取