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

哪 吒2024-11-23 3:05

目录

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

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

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

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

一、不采用抽象工厂模式

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

1、抽象产品

java 复制代码 
/**
 * 抽象产品 - CPU
 */
public interface CPU {

    void compute();
}

/**
 * 抽象产品 - 内存
 */
public interface Memory {

    void store();
}

2、具体产品

java 复制代码 
/**
 * 具体产品 - PC 的 CPU 实现
 */
public class PCCPU implements CPU {

    @Override
    public void compute() {
        System.out.println("PC CPU is computing");
    }
}

/**
 * 具体产品 - PC 的内存实现
 */
public class PCMemory implements Memory {

    @Override
    public void store() {
        System.out.println("PC Memory is storing data");
    }
}

/**
 * 具体产品 - 服务器的 CPU 实现
 */
public class ServerCPU implements CPU {

    @Override
    public void compute() {
        System.out.println("Server CPU is computing with high performance");
    }
}

/**
 * 具体产品 - 服务器的内存实现
 */
public class ServerMemory implements Memory {

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

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

java 复制代码 
/**
 * 不用抽象工厂模式
 */
public class Client {
    public static void main(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和内存

java 复制代码 
/**
 * 具体产品 - 新增笔记本电脑的 CPU 实现
 */
public class LaptopCPU implements CPU {

    @Override
    public void compute() {
        System.out.println("Laptop CPU is computing efficiently");
    }
}

/**
 * 具体产品 - 笔记本电脑的内存实现
 */
public class LaptopMemory implements Memory {

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

5、在Client测试类中新增：

java 复制代码 
// 创建笔记本的
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、抽象工厂接口

java 复制代码 
/**
 * 抽象工厂
 */
public interface ComputerFactory {

    CPU createCPU();

    Memory createMemory();
}

2、具体工厂类

java 复制代码 
/**
 * 具体工厂 - PC 工厂
 */
public class PCFactory implements ComputerFactory {

    @Override
    public CPU createCPU() {
        return new PCCPU();
    }

    @Override
    public Memory createMemory() {
        return new PCMemory();
    }
}

/**
 * 具体工厂 - 服务器工厂
 */
public class ServerFactory implements ComputerFactory {

    @Override
    public CPU createCPU() {
        return new ServerCPU();
    }

    @Override
    public Memory createMemory() {
        return new ServerMemory();
    }
}

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

java 复制代码 
public class AbstractFactoryClient {

    public static void main(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、新增笔记本电脑的具体工厂类

java 复制代码 
public class LaptopFactory implements ComputerFactory {

    @Override
    public CPU createCPU() {
        return new LaptopCPU();
    }

    @Override
    public Memory createMemory() {
        return new LaptopMemory();
    }
}

5、在测试类中新增

java 复制代码 
// 使用笔记本工厂
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 对象。

java 复制代码 
package javax.xml.parsers;

public abstract class DocumentBuilderFactory {
    // 用于创建 DocumentBuilder 实例
    public abstract DocumentBuilder newDocumentBuilder() throws ParserConfigurationException;

    // 工厂方法，用于获取 DocumentBuilderFactory 的实例
    public static DocumentBuilderFactory newInstance() {
        return FactoryFinder.find(DocumentBuilderFactory.class, "org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");
    }
}

（2）具体工厂类：DocumentBuilderFactoryImpl

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

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

java 复制代码 
package org.apache.xerces.jaxp;

public class DocumentBuilderFactoryImpl extends DocumentBuilderFactory {

    @Override
    public DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
        return new DocumentBuilderImpl();
    }
}

（3）客户端使用

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

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

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

java 复制代码 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

public class XMLParserExample {
    public static void main(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 的方法。

java 复制代码 
package javax.xml.parsers;

public abstract class SAXParserFactory {
    // 创建 SAXParser 的抽象方法
    public abstract SAXParser newSAXParser() throws ParserConfigurationException, SAXException;

    // 获取 SAXParserFactory 实例
    public static SAXParserFactory newInstance() {
        return FactoryFinder.find(SAXParserFactory.class, "org.apache.xerces.jaxp.SAXParserFactoryImpl");
    }
}

（2）具体工厂类：SAXParserFactoryImpl

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

java 复制代码 
package org.apache.xerces.jaxp;

public class SAXParserFactoryImpl extends SAXParserFactory {
    
    @Override
    public SAXParser newSAXParser() throws ParserConfigurationException, SAXException {
        return new SAXParserImpl();
    }
}

（3）客户端使用

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

java 复制代码 
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

public class SAXParserExample {
    public static void main(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 解析器之间自由切换，而不影响客户端代码。

👉 GPT功能：

  1. GPT-4o知识问答：世界目前最强AI大模型，没有之一
  2. 最强代码大模型Code Copilot：代码自动补全、代码优化建议、代码重构等
  3. DALL-E AI绘画：AI绘画 + 剪辑 = 自媒体新时代
  4. 私信哪吒，直接使用GPT-4o

🏆文章收录于：100天精通Java从入门到就业

全网最细Java零基础手把手入门教程，系列课程包括：Java基础、Java8新特性、Java集合、高并发、性能优化等，适合零基础和进阶提升的同学。

🏆哪吒多年工作总结：Java学习路线总结，搬砖工逆袭Java架构师。

华为OD机试 2023B卷题库疯狂收录中，刷题++点这里++

刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
点击下方名片，回复1024，获取《10万字208道Java经典面试题总结(2024修订版).pdf 》

相关推荐
aaasssdddd962 小时前
C++的封装(十四)：《设计模式》这本书
数据结构·c++·设计模式
T1an-12 小时前
设计模式之【观察者模式】
观察者模式·设计模式
思忖小下4 小时前
梳理你的思路(从OOP到架构设计)_设计模式Factory Method模式
设计模式·工厂方法模式·eit
霁月风5 小时前
设计模式——工厂方法模式
c++·设计模式·工厂方法模式
发飙的蜗牛'7 小时前
23种设计模式
android·java·设计模式
NorthCastle17 小时前
设计模式-创建型模式-简单工厂模式详解
设计模式·简单工厂模式
越甲八千19 小时前
重拾设计模式-外观模式和适配器模式的异同
设计模式·适配器模式·外观模式
越甲八千19 小时前
重拾设计模式--适配器模式
设计模式·适配器模式
越甲八千1 天前
重拾设计模式--外观模式
c++·设计模式·外观模式
西岭千秋雪_1 天前
设计模式の享元&模板&代理模式
java·设计模式·代理模式·享元模式·模板方法模式
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04SQL 主从数据库实时备份05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07VSCode插件 —— Cody AI （免费AI助手！）08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10组基轨迹建模 GBTM的介绍与实现（Stata 或 R）