创建型(一) - 简单工厂模式、工厂方法模式和抽象工厂模式

这篇具有很好参考价值的文章主要介绍了创建型(一) - 简单工厂模式、工厂方法模式和抽象工厂模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

本文使用了王争老师设计模式课程中的例子,写的很清晰,而且中间穿插了代码优化。

由于设计模式就是解决问题的一种思路,所以每个设计模式会从问题出发,这样比较好理解设计模式出现的意义。

一、简单工厂模式

解决问题:在调用时不想判断来实例化哪一个类或者实例化的过程过于复杂。

举个例子:我们读取配置文件,根据配置文件的后缀(json,xml,yaml)来选择不同解析器(JsonRuleConfigParserXmlRuleConfigParserYamlRuleConfigParser),最后将文件解析为RuleConfig格式。这样具体调用的时候我们就不需要管到底实例化哪一个解析器,只需要传入需要解析的文件路径。

1、定义解析器接口

public interface IRuleConfigParser {
}

2、定义各类解析器

public class JsonRuleConfigParser implements IRuleConfigParser{
}

public class XmlRuleConfigParser implements IRuleConfigParser{
}

public class YamlRuleConfigParser implements IRuleConfigParser{
}

3、定义工厂类

public class RuleConfigParserFactory {
    public IRuleConfigParser getParserInstance(String path) {
        //获取文件后缀
        String fileExtension = getFileExtension();
        IRuleConfigParser parser = null;
        if ("json".equals(fileExtension)) {
            parser =  new JsonRuleConfigParser();
        } else if ("xml".equals(fileExtension)) {
            parser = new XmlRuleConfigParser();
        } else if ("yaml".equals(fileExtension)) {
            parser = new YamlRuleConfigParser();
        }
        return parser;
    }
}          

总结:简单工厂模式就是把创建对象的活单独抽出来放一个工厂类中。
优点:对象的创建和使用进行了分离,如果创建方式改了只修改工厂类就可以了。
缺点:扩展性差,加一个新的对象的时候需要修改工厂文件,增加if-else。

二、工厂方法模式

适用工厂方法优化上面例子,代码如下:
1、给每个解析器创建一个工厂类,工厂类又实现了IRuleConfigParserFactory 接口;

public interface IRuleConfigParserFactory {
    IRuleConfigParser createParser();
}

public class JsonRuleConfigParserFactory implements IRuleConfigParserFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new JsonRuleConfigParser();
    }
}

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

public class YamlRuleConfigParserFactory implements IRuleConfigParserFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new YamlRuleConfigParser();
    }
}

2、工厂抽象出来后,看看怎么用:

public class RuleConfigParserFactory {
    public IRuleConfigParser getParserInstance(String path) {
        //获取文件后缀
        String fileExtension = getFileExtension();
        IRuleConfigParserFactory factory= null;
        if ("json".equals(fileExtension)) {
            factory =  new JsonRuleConfigParserFactory();
        } else if ("xml".equals(fileExtension)) {
            factory = new XmlRuleConfigParserFactory();
        } else if ("yaml".equals(fileExtension)) {
            factory = new YamlRuleConfigParserFactory();
        }
        return factory.createParser();
    }
}

看完上面的代码是不是觉得又进入了if-else的圈子。看了王争老师的优化,优化后代码如下,通过单例可以避免if-else,但是这种方法也有局限性,如果每次需要创建不同的新对象,下面的方法就不行了:

public class JsonRuleConfigParserFactoryMap {
    private static final Map<String, IRuleConfigParserFactory> cachedFactory = new HashMap<>();
    static {
        cachedFactory.put("json", new JsonRuleConfigParserFactory());
        cachedFactory.put("xml", new XmlRuleConfigParserFactory());
        cachedFactory.put("yaml", new YamlRuleConfigParserFactory());
    }

    public static IRuleConfigParserFactory getRuleConfigParserFactory(String fileExtension) {
        if (TextUtils.isEmpty(fileExtension)) {
            return null;
        }
        return cachedFactory.get(fileExtension);
    }
}

把每个解析器的创建又封装到了工厂类里,我个人觉得除了代码结构变复杂了,没看到工厂方法比简单工厂好在哪。我看了很多例子,大体都是这样,要么没有写最后的用法,要么僻重就轻把使用改成如下:

JsonRuleConfigParserFactory jsonParserFactory = new JsonRuleConfigParserFactory();
IRuleConfigParser jsonParser = jsonParserFactory.createParser();

所以学到这里,工厂方法的优势没有get到,最终的使用还是要if-else判断,并且每增加一个解析器就会增加一个Factory类。

看王争老师总结之所以会有上面的疑惑是因为:这种简单的使用场景其实并不适合使用工厂方法,因为这个例子中,工厂方法需要额外建Factory类,并且类里就一句new对象代码,没必要设计成独立类,所以对于这个例子,简单工厂比工厂方法更适合。

工厂方法适用场景:对象的创建比较复杂,不只是简单new,例如还要组合其他类,做各种初始化操作,这种才比较适合工厂方法场景。

下面是刚才简单工厂获取解析器的逻辑,如果获取parser的方式比较复杂,还需要组合其他类,做各种不同的初始化操作,这样getParserInstance函数逻辑就会比较复杂,就需要单独拆出工厂类去创建才会更合理。

public class RuleConfigParserFactory {
    public IRuleConfigParser getParserInstance(String path) {
        //获取文件后缀
        String fileExtension = getFileExtension();
        IRuleConfigParser parser = null;
        if ("json".equals(fileExtension)) {
            parser =  new JsonRuleConfigParser();
        } else if ("xml".equals(fileExtension)) {
            parser = new XmlRuleConfigParser();
        } else if ("yaml".equals(fileExtension)) {
            parser = new YamlRuleConfigParser();
        }
        return parser;
    }
}   

三、抽象工厂

抽象工厂主要在工厂方法的基础上解决多分类问题,前面我们获取解析器是通过RuleConfig规则来区分的,如果再加一个分类,要通过系统配置规则来区分的呢?使用工厂方法模式,我们需要添加三个解析器,再加三个工厂类。扩展的时候太过繁琐,为解决这个问题,可以再抽象出一个接口。

JsonRuleConfigParser()
XmlRuleConfigParser()
YamlRuleConfigParser()
//需要增加的
JsonSystemConfigParser()
XmlSystemConfigParser()
YamlSystemConfigParser()

抽象工厂:

public interface IConfigParserFactory {
    IRuleConfigParser createRuleConfigParser();
    ISystemConfigParser createSystemConfigParser();
    //扩展分类方式
}

public class JsonConfigParserFactory implements IConfigParserFactory {
    @Override
    public IRuleConfigParser createRuleConfigParser() {
        return new JsonRuleConfigParser();
    }
    @Override
    public ISystemConfigParser createSystemConfigParser() {
        return new JsonSystemConfigParser();
    }
}

public class XmlConfigParserFactory implements IConfigParserFactory {
    @Override
    public IRuleConfigParser createRuleConfigParser() {
        return new XmlRuleConfigParser();
    }
    @Override
    public ISystemConfigParser createSystemConfigParser() {
        return new XmlSystemConfigParser();
    }
}

public class YamConfigParserFactory implements IConfigParserFactory {
    @Override
    public IRuleConfigParser createRuleConfigParser() {
        return new YamRuleConfigParser();
    }
    @Override
    public ISystemConfigParser createSystemConfigParser() {
        return new YamSystemConfigParser();
    }
}

按照上面抽象工厂的方式,无论添加多少分类方式,这三个工厂类就可以满足。

四:JDK中工厂使用

DateFormat:使用的是简单工厂,只需要提供DateStyleTimeStyle,可快速得到一个DateFormat 对象。

public final static DateFormat getDateInstance();  
public final static DateFormat getDateInstance(int style);  
public final static DateFormat getDateInstance(int style,Locale aLocale);
//使用
public static void main(String[] args) {
		DateFormat format = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT);
		String now = format.format(new Date());
		System.out.println(now);
	}

参考文章:
简单工厂模式、工厂方法模式和抽象工厂模式有何区别?
极客时间《设计模式》(王争)文章来源地址https://www.toymoban.com/news/detail-663131.html

到了这里,关于创建型(一) - 简单工厂模式、工厂方法模式和抽象工厂模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • [设计模式]创建型模式-抽象工厂模式

    抽象工厂模式是一种创建型设计模式,它提供了一种创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。抽象工厂模式将一组具有共同主题的单个工厂封装起来,它提供接口用于创建相关或依赖对象的家族,而不需要指定具体的类。 抽象工厂模式包含以下几个

    2024年03月08日
    浏览(41)
  • 创建型设计模式05-抽象工厂模式

    ✨作者:猫十二懿 ❤️‍🔥账号:CSDN 、掘金 、个人博客 、Github 🎉公众号:猫十二懿 抽象工厂模式(Abstract Factory Pattern)是一种创建型设计模式,围绕一个超级工厂创建其他工厂,也称作为工厂的工厂(大工厂里的小工厂)。在抽象工厂模式中, 接口负责创建一组相关对

    2024年02月07日
    浏览(40)
  • JavaScript设计模式(二)——简单工厂模式、抽象工厂模式、建造者模式

    个人简介 👀 个人主页: 前端杂货铺 🙋‍♂️ 学习方向: 主攻前端方向,正逐渐往全干发展 📃 个人状态: 研发工程师,现效力于中国工业软件事业 🚀 人生格言: 积跬步至千里,积小流成江海 🥇 推荐学习:🍍前端面试宝典 🍉Vue2 🍋Vue3 🍓Vue2/3项目实战 🥝Node.js🍒

    2024年02月10日
    浏览(47)
  • 【Java 设计模式】创建型之抽象工厂模式

    在软件开发中,抽象工厂模式是一种常见的创建型设计模式, 它提供了一种创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类 。抽象工厂模式的核心思想是将一组相关的产品组合成一个工厂,客户端通过工厂接口创建一系列产品。在本文中,我们将介绍 Jav

    2024年01月17日
    浏览(74)
  • 设计模式-创建型模式之抽象工厂模式(Abstract Factory)

    在工厂方法模式中具体工厂负责生产具体的产品,每一个具体工厂对应一种具体产品,工厂方法也具有唯一性,一般情况下,一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要 一个工厂可以提供多个产品对象 ,而不是单一的产品对象。 为了更

    2023年04月20日
    浏览(40)
  • 【java设计模式】创建型模式介绍(工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式)

    简介 本文介绍Java设计模式中创建型模式的五种 一、工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工

    2024年02月16日
    浏览(45)
  • 【设计模式】单例模式、工厂方法模式、抽象工厂模式

    1. 单例模式 (Singleton Pattern): 场景: 在一个应用程序中,需要一个全局唯一的配置管理器,确保配置信息只有一个实例。 2. 工厂方法模式 (Factory Method Pattern): 场景: 创建一组具有相似功能但具体实现不同的日志记录器。 3. 抽象工厂模式 (Abstract Factory Pattern): 场景: 创建不同

    2024年01月15日
    浏览(57)
  • [设计模式Java实现附plantuml源码~创建型] 产品族的创建——抽象工厂模式

    前言: 为什么之前写过Golang 版的设计模式,还在重新写 Java 版? 答:因为对于我而言,当然也希望对正在学习的大伙有帮助。Java作为一门纯面向对象的语言,更适合用于学习设计模式。 为什么类图要附上uml 因为很多人学习有做笔记的习惯,如果单纯的只是放一张图片,那

    2024年01月22日
    浏览(62)
  • 常用设计模式(工厂方法,抽象工厂,责任链,装饰器模式)

    有关设计模式的其他常用模式请参考 单例模式的实现 常见的设计模式(模板与方法,观察者模式,策略模式) 定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类。 ——《设计模式》GoF 解决创建过程比较复杂,希望对外隐藏

    2024年01月22日
    浏览(47)
  • 创建型(一) - 简单工厂模式、工厂方法模式和抽象工厂模式

    本文使用了王争老师设计模式课程中的例子,写的很清晰,而且中间穿插了代码优化。 由于设计模式就是解决问题的一种思路,所以每个设计模式会从问题出发,这样比较好理解设计模式出现的意义。 一、简单工厂模式 解决问题:在调用时不想判断来实例化哪一个类或者实

    2024年02月12日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包