设计模式（创建型模式）工厂模式

最新推荐文章于 2024-07-21 21:10:08 发布
最新推荐文章于 2024-07-21 21:10:08 发布
阅读量1.3k 收藏 12
点赞数 19
分类专栏： 设计模式 文章标签： 设计模式 简单工厂模式 工厂方法模式 抽象工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alian_1223/article/details/135994223
版权

目录

一、简介

  工厂模式我将它分为三类：

  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

  抽象工厂用得比较少，我主要讲解下简单工厂模式和工厂方法模式，假设我们根据配置文件的扩展名（xml、yml、properties）获取到不同的解析器XmlRuleConfigParser、YmlRuleConfigParser、PropertiesRuleConfigParser，从而解析得到结果（RuleConfig），相信大家很简单的就写出了如下的代码：

1.1、接口定义

public class RuleConfig {
    // 属性忽略
}

public interface IRuleConfigParser {
    RuleConfig parse(String configText);
}

public class XmlRuleConfigParser implements IRuleConfigParser {

    @Override
    public RuleConfig parse(String configText) {
        // 实现 XML 配置解析逻辑
        // 返回 RuleConfig 对象
        return new RuleConfig(); // 假设这里返回 RuleConfig 对象
    }
}

public class YmlRuleConfigParser implements IRuleConfigParser {
    
    @Override
    public RuleConfig parse(String configText) {
        // 实现 YML 配置解析逻辑
        // 返回 RuleConfig 对象
        return new RuleConfig(); // 假设这里返回 RuleConfig 对象
    }
}

public class PropertiesRuleConfigParser implements IRuleConfigParser {
    
    @Override
    public RuleConfig parse(String configText) {
        // 实现 Properties 配置解析逻辑
        // 返回 RuleConfig 对象
        return new RuleConfig(); // 假设这里返回 RuleConfig 对象
    }
}

  这里我们定义了一个解析器接口，并且有三个解析都实现了该接口，最终返回解析的结果。

1.2、调用

RuleConfigSource.java

public class RuleConfigSource {

    public RuleConfig loadConfig() {
        String configFilePath = "config.xml"; // 假设配置文件路径
        String fileType = getFileExtension(configFilePath); // 获取文件类型（xml、yml、properties）
        IRuleConfigParser parser=null;
        if ("xml".equalsIgnoreCase(fileType)) {
            parser= new XmlRuleConfigParser();
        } else if ("yml".equalsIgnoreCase(fileType)) {
            parser= new YmlRuleConfigParser();
        } else if ("properties".equalsIgnoreCase(fileType)) {
            parser= new PropertiesRuleConfigParser();
        }else {
            throw new IllegalArgumentException("Unknown file type: " + fileType);
        }
        // 解析配置文件
        RuleConfig ruleConfig = parser.parse(configFilePath);
        // 返回解析后的 ruleConfig 对象
        return ruleConfig;
    }

    private String getFileExtension(String filePath) {
        if (filePath == null || filePath.isEmpty()) {
            throw new IllegalArgumentException("File path is invalid");
        }
        int lastDotIndex = filePath.lastIndexOf('.');
        if (lastDotIndex == -1) {
            throw new IllegalArgumentException("File path does not contain a valid file extension");
        }
        return filePath.substring(lastDotIndex + 1);
    }

}

  我敢肯定的说，绝大部分的小伙伴都是这么写的，完全没毛病，我以前也是这么写过，不过我们今天说的是设计模式，讲的是一个接近规范的方法，而不是说代码可读性什么的。那就看看使用简单工厂模式是什么样的。

二、简单工厂模式

  简单工厂模式（Simple Factory Pattern）是通过一个工厂类来创建不同类型的对象，客户端通过工厂类的静态方法来获取所需的对象。在简单工厂模式中，工厂类负责所有产品的创建。
  首先是要理解为啥要改，一切的依据都是从七大设计原则来探讨设计模式，如果不结合实际业务，确实有点不合适。在我们使用的RuleConfigSource并没有满足单一职责原则，它并不需要知道怎么去获取解析器的详细信息；也不符合开闭原则，所有的逻辑都在这里，修改不便。在接口定义不变的前提下，改造如下：

2.1、解析工厂

RuleConfigParserFactory.java

import java.util.HashMap;
import java.util.Map;

public class RuleConfigParserFactory {

    private static final Map<String, RuleConfigParser> PARSER_MAP = new HashMap<>();

    static {
        PARSER_MAP.put("xml", new XmlRuleConfigParser());
        PARSER_MAP.put("yml", new YmlRuleConfigParser());
        PARSER_MAP.put("properties", new PropertiesRuleConfigParser());
    }

    public static RuleConfigParser createParser(String fileExtension) {
        if (PARSER_MAP.containsKey(fileExtension)) {
            return PARSER_MAP.get(fileExtension);
        }
        return null;
    }

}

2.2、调用

public class RuleConfigSource {

public RuleConfig loadConfig() {
        String configFilePath = "config.xml"; // 假设配置文件路径
        // 获取文件后缀（可以放到工具类）
        String fileExtension = getFileExtension(configFilePath);
        // 获取解析器
        RuleConfigParser parser = RuleConfigParserFactory.createParser(fileExtension);
        if (parser==null){
            throw new IllegalArgumentException("Unknown file type: " + fileExtension);
        }
        // 解析配置文件
        RuleConfig ruleConfig = parser.parse(configFilePath);
        // 返回解析后的 ruleConfig 对象
        return ruleConfig;
    }

    private static String getFileExtension(String filePath) {
        // 从文件路径中提取文件类型（后缀）
        if (filePath == null || filePath.isEmpty()) {
            throw new IllegalArgumentException("File path is invalid");
        }
        int lastDotIndex = filePath.lastIndexOf('.');
        if (lastDotIndex == -1) {
            throw new IllegalArgumentException("File path does not contain a valid file extension");
        }
        return filePath.substring(lastDotIndex + 1);
    }

}

  这里的RuleConfigSource就不会涉及到具体解析器的构建和解析，并且增加一个也与它没关系，只需要改动RuleConfigParserFactory，有些人说，这也违反了开闭原则？实际上如果不是很频繁的添加新的解析器，只是偶尔修改RuleConfigParserFactory的代码，即便不符合开闭原则，也是可以被接受的。并且这里通过静态代码块，节省了内存和对象创建的开销。

三、工厂方法模式

  工厂方法模式（Factory Method Pattern）则是将对象的创建推迟到具体工厂类中，定义一个抽象的工厂接口，每个具体工厂类都实现这个接口，负责创建特定的对象。每个具体工厂类只负责创建单一类型的对象。
  还是用之前的示例来改造成工厂方法模式，理论上工厂方法模式比简单工厂模式更加符合开闭原则。

3.1、解析器接口定义

public class RuleConfig {
    // 属性忽略
}

public interface IRuleConfigParser {
    RuleConfig parse(String configText);
}

public class XmlRuleConfigParser implements IRuleConfigParser {

    @Override
    public RuleConfig parse(String configText) {
        // 实现 XML 配置解析逻辑
        // 返回 RuleConfig 对象
        return new RuleConfig(); // 假设这里返回 RuleConfig 对象
    }
}

public class YmlRuleConfigParser implements IRuleConfigParser {
    @Override
    public RuleConfig parse(String configText) {
        // 实现 YML 配置解析逻辑
        // 返回 RuleConfig 对象
        return new RuleConfig(); // 假设这里返回 RuleConfig 对象
    }
}

public class PropertiesRuleConfigParser implements IRuleConfigParser {

    @Override
    public RuleConfig parse(String configText) {
        // 实现 Properties 配置解析逻辑
        // 返回 RuleConfig 对象
        return new RuleConfig(); // 假设这里返回 RuleConfig 对象
    }
}

3.2、解析工厂接口定义

  我们需要给每个解析器都增加一个工厂类。

public interface IRuleConfigParserFactory {
    IRuleConfigParser createParser();
}

public class XmlRuleConfigParserFactory implements IRuleConfigParserFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new XmlRuleConfigParser();
    }
}

public class YmlRuleConfigParserFactory implements IRuleConfigParserFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new YmlRuleConfigParser();
    }
}

public class PropertiesRuleConfigParserFactory implements IRuleConfigParserFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new PropertiesRuleConfigParser();
    }
}

3.3、解析器工厂的工厂

  然后管理这些工程类，也就是建立一个工厂的工厂。

import java.util.HashMap;
import java.util.Map;

public class RuleConfigParserFactoryMap {

    private static final Map<String, IRuleConfigParserFactory> PARSER_MAP = new HashMap<>();

    static {
        PARSER_MAP.put("xml", new XmlRuleConfigParserFactory());
        PARSER_MAP.put("yml", new YmlRuleConfigParserFactory());
        PARSER_MAP.put("properties", new PropertiesRuleConfigParserFactory());
    }

    public static IRuleConfigParserFactory getParserFactory(String fileExtension) {
        // 获取解析工厂
        if (PARSER_MAP.containsKey(fileExtension)) {
            return PARSER_MAP.get(fileExtension);
        }
        return null;
    }

}

3.4、调用

public class RuleConfigSource {

    public RuleConfig loadConfig() {
        String configFilePath = "config.xml"; // 假设配置文件路径
        String fileExtension = getFileExtension(configFilePath);// 获取文件类型（xml、yml、properties）
        // 获取解析器
        IRuleConfigParserFactory parserFactory = RuleConfigParserFactoryMap.getParserFactory(fileExtension);
        if (parserFactory == null) {
            throw new IllegalArgumentException("未找到解析工厂");
        }
        IRuleConfigParser parser = parserFactory.createParser();
        // 返回解析后的 ruleConfig 对象
        return parser.parse(configFilePath);
    }

    private static String getFileExtension(String filePath) {
        // 从文件路径中提取文件类型（后缀）
        // 这里假设实现获取文件类型的逻辑
        if (filePath == null || filePath.isEmpty()) {
            throw new IllegalArgumentException("File path is invalid");
        }
        int lastDotIndex = filePath.lastIndexOf('.');
        if (lastDotIndex == -1) {
            throw new IllegalArgumentException("File path does not contain a valid file extension");
        }
        return filePath.substring(lastDotIndex + 1);
    }

}

  当我们需要新的解析器时，只需要定义新的解析器对应的类和工厂类，并且缓存起来，这样代码也改得很少，基本符合开闭原则。但是和简单工厂方法相比，实现上差不多，反而增加了代码的复杂度，尤其是在工厂类的实现非常简单的情况下，有点过渡设计了，这时使用简单工厂方法就可以了如果每个解析对象的创建逻辑都比较的复杂，需要组合其他的组件，那么可以考虑工厂方法模式。

四、抽象工厂模式

  抽象工厂模式（Abstract Factory Pattern）用于创建一组相关或相互依赖的对象，它通过提供一个创建一系列相关对象的接口，可以创建不同类型的对象组。
  工厂方法模式已经复杂起来了，抽象工厂模式很大程度是在这个基础上演变的。比如我们是之前是按照后缀名解析的，假设我们同时需要按照内容格式来解析呢？那工程类就变成6个了，这个时候就可以使用抽象工厂模式了。

4.1、内容解析器

  假设我们增加解析器
内容解析器

public interface IContentConfigParser {
    RuleConfig parse(String configText);
}

public class XmlContentConfigParser implements IContentConfigParser {
    @Override
    public RuleConfig parse(String configText) {
        return new RuleConfig();
    }
}

public class YmlContentConfigParser implements IContentConfigParser {
    @Override
    public RuleConfig parse(String configText) {
        return new RuleConfig();
    }
}

public class PropertiesContentConfigParser implements IContentConfigParser {
    @Override
    public RuleConfig parse(String configText) {
        return new RuleConfig();
    }
}

4.2、工厂类

public interface IConfigParserFactory {

    IRuleConfigParser createRuleParser();

    IContentConfigParser createContentParser();
}

public class XmlConfigParserFactory implements IConfigParserFactory {
    @Override
    public IRuleConfigParser createRuleParser() {
        return new XmlRuleConfigParser();
    }

    @Override
    public IContentConfigParser createContentParser() {
        return new XmlContentConfigParser();
    }
}

public class YmlConfigParserFactory implements IConfigParserFactory {
    @Override
    public IRuleConfigParser createRuleParser() {
        return new YmlRuleConfigParser();
    }

    @Override
    public IContentConfigParser createContentParser() {
        return new YmlContentConfigParser();
    }
}

public class PropertiesConfigParserFactory implements IConfigParserFactory {
    @Override
    public IRuleConfigParser createRuleParser() {
        return new PropertiesRuleConfigParser();
    }

    @Override
    public IContentConfigParser createContentParser() {
        return new PropertiesContentConfigParser();
    }
}

  从而达到减少工厂类的个数，不过实际中抽象工厂模式用得比较少。可能很多小伙伴还是觉得这个工厂模式有问题，比如本文中的工厂或者工厂的工厂缓存，可以使用配置文件+反射去掉，完全适合开闭原则，每个设计模式都有自己的特色和缺点，就看是否被接受。遵循一些原则的同时，需要考虑代码的复杂度，清晰度。

三、优点与缺点

简单工厂模式：

优点：

  • 实现简单，易于理解和使用。
  • 将对象的创建过程封装在工厂类中，客户端无需了解对象创建的具体逻辑。

缺点：

  • 工厂类集中了所有对象的创建逻辑，如果需要添加新产品，可能需要修改工厂类的逻辑，不符合开闭原则。
  • 不符合单一职责原则，因为工厂类既要负责对象的创建，又要负责选择创建哪个对象。

工厂方法模式：

优点：

  • 每个具体工厂只负责创建特定的对象，符合单一职责原则。

  • 可以通过扩展具体工厂类来添加新产品，无需修改现有代码，符合开闭原则。
    缺点：

  • 增加了系统中类的个数，增加了系统的复杂度。

  • 客户端需要知道所使用的具体工厂类，导致与具体工厂类耦合。

抽象工厂模式：

优点：

  • 具有工厂方法模式的所有优点，同时能够创建一组相关的产品对象，形成产品族。
  • 客户端与具体产品的实现解耦，更符合依赖倒置原则。

缺点：

  • 添加新产品族比较复杂，需要修改抽象工厂接口及其所有实现类。
  • 增加系统的抽象性和理解难度，需要同时理解多个抽象类和接口。

  根据实际需求选择适合的工厂模式是非常重要的，简单工厂适用于对象较少且创建逻辑不复杂的情况；工厂方法适用于需要创建多种类型对象的情况；而抽象工厂适用于创建一组相关对象的场景，但要考虑到增加产品的复杂度。

嘉禾嘉宁papa
关注
  • 19
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式创建型——工厂模式
tszc95的博客
04-04 4245
工程模式是通过工厂获取一个一个的新对象。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
设计模式创建型——抽象工厂模式
tszc95的博客
04-06 8272
抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
【Java 设计模式】创建型之抽象工厂模式
好久不见的流星
01-17 1254
抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式将一组相关的产品组合成一个工厂，客户端通过工厂接口创建一系列产品。这有助于实现产品族的概念，其中产品族是指一组相关的产品，例如不同品牌的汽车。抽象工厂模式是一种常见且实用的设计模式，它通过定义一个工厂接口，将一系列相关或相互依赖的对象的创建延迟到具体工厂的实现类中，从而实现了客户端和具体类的解耦。在实际开发中，抽象工厂模式常用于创建一系列相关的产品，如美食店中的可乐、汉堡包等。
设计模式——创建型模式
m0_52457734的博客
06-19 1328
创建型设计模式
【Java 设计模式】创建型之工厂方法模式
好久不见的流星
01-15 2015
工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是将对象的实例化延迟到子类中。这样，在实际使用时，客户端代码不需要关心具体实例是哪个类，只需通过工厂方法获取对象即可。工厂方法模式通过解耦了客户端和具体类的关系，使系统更加灵活。工厂方法模式是一种常见且实用的设计模式，它通过定义一个工厂方法接口，将对象的实例化延迟到子类中，从而实现了客户端和具体类的解耦。在实际开发中，工厂方法模式常用于创建复杂对象、管理对象的生命周期等场景。通过灵活使用工厂方法模式，可以使系统更容易扩展和维护。
C++设计模式 - 创建型模式之工厂模式
kakaka666的博客
06-11 1627
工厂模式最直观的理解是，减少new创建对象的方式，用接口的方式来返回一个对象，而new创建的方式被封装了简单工厂：调用者只需使用单例工厂就可获取同一范畴的所有产品工厂方法：调用者并不知道它在运行时会获取何种产品，只知道某个特定的工厂能生成出满足需求的产品抽象工厂：调用者可以在运行时从特定的工厂中获得所有信息相关的产品簇(可以对产品进行组合)
创建型设计模式——抽象工厂模式
★★光亭★★
02-11 6159
创建型设计模式——抽象工厂模式
创建型设计模式（5种）
qq_52793248的博客
12-09 2964
创建型设计模式（5种）
创建型设计模式——工厂方法模式
★★光亭★★
02-10 6881
创建型设计模式——工厂方法模式
创建型设计模式
shaofei_huai的博客
03-01 4028
创建型设计模式共5种，分别为工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 一、工厂方法模式 工厂方法模式指定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。 在工厂方法模式中存在四种角色，分别为抽象工厂，具体工厂，抽象产品，具体产品。具体工厂及具体产品是对抽象工厂及抽象产品的实现。使用抽象工厂可以对业务进行解耦，提升灵活性，屏蔽工厂内产品细节，但每增加一种产品都需要增加对应的具体产品及具体工厂，代码复用性...
(一)js前端开发中设计模式前篇之对象
峰会路转的博客
07-17 295
改进版与基础版要分开测试，不然会互相影响到。
DP学习——中介者模式
huibin.yun的博客
07-21 197
学而时习之，温故而知新。
编程中的智慧五：工厂设计模式
Jeremy程序员
07-21 606
结合Spring阐述工厂设计模式的运用
设计模式实战：在线购物系统的设计与实现
qq_40254606的博客
07-20 788
本篇文章将介绍如何设计一个在线购物系统，系统包括购物车、订单处理、支付等功能。我们将通过这一项目，应用组合模式、命令模式、策略模式和观察者模式来解决具体的设计问题。通过本项目，我们综合应用了组合模式、命令模式、策略模式和观察者模式，解决了在线购物系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
(四)js前端开发中设计模式之简单工厂模式
峰会路转的博客
07-21 89
简单工厂模式,又叫静态工厂方法，由一个工厂对象决定创建出哪一种产品类的实例，主要用来创建同一类对象。
(三)js前端开发中设计模式之工厂模式
峰会路转的博客
07-17 322
工厂模式是一种创建型设计模式，它可以帮助我们根据需求创建对象。
设计模式学习[2]---策略模式+简单工厂回顾
最新发布
Edwinwzy的博客
07-21 604
上一篇讲到简单工厂模式。在我的理解中工厂的存在就是，为了实例化对象。根据不同条件实例化不同的对象的作用。这篇博客写的策略模式，可以说是把这个根据不同情况实例化不同对象的这个过程再一次封装了。简而言之就是，策略模式对变化进行了封装。有点迷。且听我娓娓道来。在看策略模式的时候，我其实挺奇怪它和简单工厂有什么区别。因为看书中的代码感觉变化不是很大。
java设计模式：02-创建型设计模式-概览
Mr_Air_Boy的博客
07-17 393
创建型模式（Creational Patterns）主要用于处理对象创建的机制，旨在以适当的方式创建对象。这些模式的目的是将对象的创建过程与系统的其他部分分离，以提高系统的灵活性和可扩展性。通过使用创建型模式，可以使系统在创建对象时更加灵活，减少耦合，提高代码的可维护性。
(二)js前端开发中设计模式之单例模式
峰会路转的博客
07-17 496
保证一个类仅有一个实例，并提供一个访问它的全局访问点。基本的单例模式，就是对象字面量。
设计模式原理与应用之创建型模式详解
设计模式原理与应用中提到的创建型模式主要包括Singleton（单例）、Prototype（原型）、Factory Method（工厂方法）、Abstract Factory（抽象工厂）和Builder（生成器）等几种模式。 Singleton模式是创建型模式中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值