当前位置: 欣欣网 > 码农

最简单的设计模式,抽象工厂模式,是否属于过度设计?

2024-09-14码农

在日常开发中,我们往往忽视了设计模式的重要性。 这可能是因为项目时间紧迫,或者对设计模式理解不深。 其实,很多时候我们可能在不经意间已经使用了某些模式。

重要的是要有意识地学习和应用,让代码更加优雅和高效。也许是时候重新审视我们的编程实践,将设计模式融入其中了。

先从最简单的设计模式【抽象工厂模式】走起,让我们一起「重学设计模式」。

灵魂拷问 新增具体产品时,扩展新的工厂类再在客户端中创建工厂类代码 和 在客户端中直接创建实例代码,有什么本质区别吗?

一、不采用抽象工厂模式

假设你正在设计一套系统,该系统用于创建不同配置的电脑,例如PC和服务器。每种类型的电脑都有不同的CPU和内存。

1、抽象产品

/**
 * 抽象产品 - CPU
 */

publicinterfaceCPU{
voidcompute();
}
/**
 * 抽象产品 - 内存
 */

publicinterfaceMemory{
voidstore();
}

2、具体产品

/**
 * 具体产品 - PC 的 CPU 实现
 */

public classPCCPUimplementsCPU{
@Override
publicvoidcompute(){
System.out.println("PC CPU is computing");
}
}
/**
 * 具体产品 - PC 的内存实现
 */

public classPCMemoryimplementsMemory{
@Override
publicvoidstore(){
System.out.println("PC Memory is storing data");
}
}
/**
 * 具体产品 - 服务器的 CPU 实现
 */

public classServerCPUimplementsCPU{
@Override
publicvoidcompute(){
System.out.println("Server CPU is computing with high performance");
}
}
/**
 * 具体产品 - 服务器的内存实现
 */

public classServerMemoryimplementsMemory{
@Override
publicvoidstore(){
System.out.println("Server Memory is storing data with high capacity");
}
}





3、测试类 ~ 不用抽象工厂模式

/**
 * 不用抽象工厂模式
 */

public classClient{
publicstaticvoidmain(String[] args){
// 创建 PC 的组件
CPU pcCPU = new PCCPU();
Memory pcMemory = new PCMemory();
pcCPU.compute();
pcMemory.store();
// 创建 服务器 的组件
CPU serverCPU = new ServerCPU();
Memory serverMemory = new ServerMemory();
serverCPU.compute();
serverMemory.store();
}
}

4、新增笔记本的CPU和内存

/**
 * 具体产品 - 新增笔记本电脑的 CPU 实现
 */

public classLaptopCPUimplementsCPU{
@Override
publicvoidcompute(){
System.out.println("Laptop CPU is computing efficiently");
}
}
/**
 * 具体产品 - 笔记本电脑的内存实现
 */

public classLaptopMemoryimplementsMemory{
@Override
publicvoidstore(){
System.out.println("Laptop Memory is storing data efficiently");
}
}

5、在Client测试类中新增:

// 创建笔记本的
CPU laptopCPU = new LaptopCPU();
laptopCPU.compute();
LaptopMemory laptopMemory = new LaptopMemory();
laptopMemory.store();

还是很方便的。

二、那么,如果采用抽象工厂模式优化上面代码,要怎么做呢?

抽象工厂模式(Abstract Factory Pattern)是一种创建型设计模式,旨在提供一个接口,用于创建相关或依赖对象的家族,而无需指定它们的具体类。通过抽象工厂模式,客户端可以通过接口创建一系列相关对象,而无需知道这些对象的具体实现。

抽象工厂模式通常包括以下几个部分:

  1. 抽象工厂接口(Abstract Factory):定义创建产品的接口。

  2. 具体工厂类(Concrete Factory):实现抽象工厂接口,生成具体的产品。

  3. 抽象产品接口(Abstract Product):定义产品的接口。

  4. 具体产品类(Concrete Product):实现具体的产品。

  5. 客户端(Client):通过工厂接口来使用产品,而不依赖于具体产品的实现。

1、抽象工厂接口

/**
 * 抽象工厂
 */

publicinterfaceComputerFactory{
CPU createCPU();
Memory createMemory();
}

2、具体工厂类

/**
 * 具体工厂 - PC 工厂
 */

public classPCFactoryimplementsComputerFactory{
@Override
public CPU createCPU(){
returnnew PCCPU();
}
@Override
public Memory createMemory(){
returnnew PCMemory();
}
}
/**
 * 具体工厂 - 服务器工厂
 */

public classServerFactoryimplementsComputerFactory{
@Override
public CPU createCPU(){
returnnew ServerCPU();
}
@Override
public Memory createMemory(){
returnnew ServerMemory();
}
}



3、测试类 ~ 抽象工厂模式

public classAbstractFactoryClient{
publicstaticvoidmain(String[] args){
// 使用 PC 工厂创建 PC 组件
ComputerFactory pcFactory = new PCFactory();
CPU pcCPU = pcFactory.createCPU();
Memory pcMemory = pcFactory.createMemory();
pcCPU.compute();
pcMemory.store();
// 使用服务器工厂创建服务器组件
ComputerFactory serverFactory = new ServerFactory();
CPU serverCPU = serverFactory.createCPU();
Memory serverMemory = serverFactory.createMemory();
serverCPU.compute();
serverMemory.store();
}
}


使用抽象工厂模式时,新增笔记本电脑,如何实现?

4、新增笔记本电脑的具体工厂类

public classLaptopFactoryimplementsComputerFactory{
@Override
public CPU createCPU(){
returnnew LaptopCPU();
}
@Override
public Memory createMemory(){
returnnew LaptopMemory();
}
}

5、在测试类中新增

// 使用笔记本工厂
ComputerFactory laptopFactory = new LaptopFactory();
CPU laptopCPU = laptopFactory.createCPU();
Memory laptopMemory = laptopFactory.createMemory();
laptopCPU.compute();
laptopMemory.store();

三、新增具体产品时,扩展新的工厂类再在客户端中创建工厂类代码 和 在客户端中直接创建实例代码,有什么本质区别吗?

1、解耦

问题: 在不使用抽象工厂模式的实现中,客户端代码(Client)直接依赖于具体的产品类(如 PCCPU、PCMemory、ServerCPU 等)。当需要增加新类型的电脑或更改现有的电脑配置时,客户端代码必须修改。

抽象工厂模式引入了工厂接口(ComputerFactory),客户端通过工厂接口创建对象,而不是直接实例化具体类。这样客户端与具体的产品实现解耦,客户端不需要知道具体的产品类名,只需要依赖工厂接口。代码更加灵活,可以支持不同的产品家族(PC、服务器、笔记本、工作站等)而无需修改客户端代码。

产品创建逻辑都集中在具体工厂中,客户端只关心如何使用产品,而不关心它们是如何创建的。

2、扩展性

问题: 如果要在不使用工厂模式的代码中增加一个新产品(例如,平板电脑的CPU和内存),需要修改客户端代码,增加新产品的实例化逻辑。这违反了开闭原则(对扩展开放,对修改关闭)。

抽象工厂模式允许我们通过创建新的工厂(例如 LaptopFactory)来生成新产品,而无需修改客户端代码。只需在新工厂中提供相应的产品(CPU和Memory),然后将工厂传递给客户端。

支持开闭原则:新增产品只需增加新的工厂类,不需要修改已有代码,减少了风险和维护成本。

方便维护:如果产品发生变化(比如某种CPU规格变动),只需要在工厂中修改,不必修改所有调用代码,系统的灵活性显著提高。

3、单一职责原则

问题: 客户端代码不仅负责业务逻辑,还负责产品的创建逻辑,违反了单一职责原则。

在客户端中创建工厂类:客户端的职责更加单一,只负责业务逻辑处理,产品的创建则完全由工厂负责。通过将产品的创建与使用分离,代码变得更加清晰、职责分明。

优点:遵循单一职责原则,产品创建逻辑集中在工厂中,客户端只处理与产品的使用有关的业务逻辑。

四、在jdk源码中,哪些地方应用了抽象工厂模式

在 JDK 的源码中,抽象工厂模式被广泛应用于创建不同类型的对象家族。

一个典型的例子是 javax.xml.parsers.DocumentBuilderFactory 和 javax.xml.parsers.SAXParserFactory,它们都是 JDK 中使用抽象工厂模式的具体实现。这些工厂用于创建与 XML 解析相关的对象,如 DocumentBuilder 和 SAXParser,而客户端不需要关心这些对象的具体实现。

1、DocumentBuilderFactory 在 JDK 中的应用

(1)抽象工厂类:DocumentBuilderFactory

DocumentBuilderFactory 是一个抽象工厂,用于创建 DocumentBuilder,它负责解析 XML 文档。

newInstance() 方法会返回一个具体的工厂实现(如 org.apache.xerces.jaxp.DocumentBuilderFactoryImpl),该工厂实现负责创建具体的 DocumentBuilder 对象。

package javax.xml.parsers;
publicabstract classDocumentBuilderFactory{
// 用于创建 DocumentBuilder 实例
publicabstract DocumentBuilder newDocumentBuilder()throws ParserConfigurationException;
// 工厂方法,用于获取 DocumentBuilderFactory 的实例
publicstatic DocumentBuilderFactory newInstance(){
return FactoryFinder.find(DocumentBuilderFactory. class, "org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");
}
}

(2)具体工厂类:DocumentBuilderFactoryImpl

DocumentBuilderFactoryImpl 是 DocumentBuilderFactory 的一个具体实现,它定义了如何创建 DocumentBuilder。

newDocumentBuilder() 返回一个 DocumentBuilderImpl 实例,具体负责解析 XML。

package org.apache.xerces.jaxp;
public classDocumentBuilderFactoryImplextendsDocumentBuilderFactory{
@Override
public DocumentBuilder newDocumentBuilder()throws ParserConfigurationException {
returnnew DocumentBuilderImpl();
}
}

(3)客户端使用

在客户端代码中,使用 DocumentBuilderFactory 创建 DocumentBuilder 对象,而不需要关心具体实现。

通过 DocumentBuilderFactory.newInstance(),客户端获取了一个具体的 DocumentBuilderFactory 实例,然后使用该工厂创建 DocumentBuilder 对象。

客户端不关心 DocumentBuilder 的具体实现,只依赖于抽象工厂接口,符合抽象工厂模式的设计思想。

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
public classXMLParserExample{
publicstaticvoidmain(String[] args){
try {
// 获取 DocumentBuilderFactory 实例(抽象工厂)
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 使用工厂创建 DocumentBuilder(具体产品)
DocumentBuilder builder = factory.newDocumentBuilder();
// 使用 DocumentBuilder 解析 XML 文档
// 示例代码忽略了具体 XML 文件的解析逻辑
System.out.println("DocumentBuilder created successfully!");
catch (Exception e) {
e.printStackTrace();
}
}
}


2、SAXParserFactory 的应用

SAXParserFactory 是 JDK 中另一个典型的抽象工厂模式实现,它用于创建 SAXParser 对象,解析 XML 文档。

(1)抽象工厂类:SAXParserFactory

SAXParserFactory 是抽象工厂类,定义了创建 SAXParser 的方法。

package javax.xml.parsers;
publicabstract classSAXParserFactory{
// 创建 SAXParser 的抽象方法
publicabstract SAXParser newSAXParser()throws ParserConfigurationException, SAXException;
// 获取 SAXParserFactory 实例
publicstatic SAXParserFactory newInstance(){
return FactoryFinder.find(SAXParserFactory. class, "org.apache.xerces.jaxp.SAXParserFactoryImpl");
}
}

(2)具体工厂类:SAXParserFactoryImpl

SAXParserFactoryImpl 是 SAXParserFactory 的具体实现,负责创建 SAXParser。

package org.apache.xerces.jaxp;
public classSAXParserFactoryImplextendsSAXParserFactory{
@Override
public SAXParser newSAXParser()throws ParserConfigurationException, SAXException {
returnnew SAXParserImpl();
}
}

(3)客户端使用

客户端通过 SAXParserFactory 来创建 SAXParser,解析 XML 文档。

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
public classSAXParserExample{
publicstaticvoidmain(String[] args){
try {
// 获取 SAXParserFactory 实例(抽象工厂)
SAXParserFactory factory = SAXParserFactory.newInstance();
// 使用工厂创建 SAXParser(具体产品)
SAXParser parser = factory.newSAXParser();
// 使用 SAXParser 解析 XML 文档
// 示例代码忽略了具体 XML 文件的解析逻辑
System.out.println("SAXParser created successfully!");
catch (Exception e) {
e.printStackTrace();
}
}
}


3、这些应用解决了什么问题?

解耦客户端与具体实现: 客户端代码不需要知道 DocumentBuilder 或 SAXParser 的具体实现类,只依赖于抽象工厂类和抽象产品类。这样,XML 解析库可以随时切换实现(例如从 Apache Xerces 切换到其他实现),而无需修改客户端代码。

易于扩展: 当需要增加新的 DocumentBuilder 或 SAXParser 实现时,只需增加新的工厂类,而不需要修改客户端。通过使用抽象工厂模式,可以很容易地扩展和适应新的需求。

集中控制对象创建: 使用工厂类来管理对象的创建,统一了对象的创建逻辑,避免了客户端直接负责实例化的复杂性,使代码更加灵活和可维护。

4、总结

在 JDK 中,诸如 DocumentBuilderFactory 和 SAXParserFactory 的类广泛应用了抽象工厂模式。这种模式确保了客户端代码与具体实现的解耦,并增强了系统的可扩展性和灵活性。通过使用抽象工厂模式,JDK 能够在不同的 XML 解析器之间自由切换,而不影响客户端代码。


- EOF -

推荐阅读点击标题可跳转

·················END·················

看完本文有收获?请转发分享给更多人

关注「哪吒编程」,提升Java技能

点赞和在看就是最大的支持❤️