设计模式-工厂模式Factory

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

b.工厂方法模式 (Factory Method) (重点)

一般情况下,工厂模式分为三种更加细分的类型:简单工厂、工厂方法和抽象工厂。

1) 简单工厂 Simple Factory

简单工厂叫作静态工厂方法模式(Static Factory Method Pattern)

现在有一个场景,需要一个资源加载器,要根据不用的url进行资源加载,但是如果我们将所有的加载实现代码全部封装在了一个load方法中,就会导致一个类很大,同时扩展性也非常差,当想要添加新的前缀解析其他类型的url时,发现需要修改大量的源代码。

定义两个需要之后会用到的类

/**
 * 事实上一个资源类会比这个负责
 */
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Resource {
    private String url;
}
public class ResourceLoader {

    /**
     * 资源加载
     * @param url file:// http:// classpath://
     * @return 资源类
     */
    public Resource load(String url) {
        // 1.根据url获取前缀
        String prefix = getPreFix(url);

        Resource resource = null;

        // 2.根据前缀,处理不同的资源(有很多的分支逻辑)
        if ("http".equals(prefix)){
            // 发起http请求下载资源....(代码复杂)
            return new Resource(url);
        } else if ("file".equals(prefix)) {
            // 建立流,做异常...(代码复杂)
            return new Resource(url);
        } else if ("classpath".equals(prefix)) {
            // ......(代码复杂)
            return new Resource(url);
        }else {
            return new Resource("default");
        }
    }

    /**
     * 获取前缀
     * @param url
     * @return
     */
    private String getPreFix(String url) {
        if (url == null || url.equals("") || !url.contains("://")){
            throw new ResourceLoadException("传入的资源url不合法");
        }
        String[] split = url.split(":");
        return split[0];
    }
}

在上边的案例中,存在很多的if分支,如果分支数量不多,且不需要扩展,这样的编写方式当然没错,然而在实际的工作场景中,我们的业务代码可能会很多,分支逻辑也可能十分复杂,这个时候简单工厂设计模式就要发挥作用了。

只需要创建一个工厂类,将创建资源的能力交给工厂即可:

/**
 * 简单工厂
 */
public class ResourceFactory {

    public static Resource create(String type, String url) {
        if ("http".equals(type)){
            // 发起http请求下载资源....(代码复杂)
            return new Resource(url);
        } else if ("file".equals(type)) {
            // 建立流,做异常...(代码复杂)
            return new Resource(url);
        } else if ("classpath".equals(type)) {
            // ......(代码复杂)
            return new Resource(url);
        }else {
            return new Resource("default");
        }
    }
}

有了工厂之后,我们的主要逻辑就会简化:

public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.根据前缀,处理不同的资源(有很多的分支逻辑)
    return ResourceLoaderFactory.create(prefix, url);
}

1.a) 简单工厂的好处

这就是简单工厂设计模式,提取一个工厂类,工厂会根据传入的不同的类型,创建不同的产品,将创建对象的过程交给工厂类、其他业务需要某个产品时,直接使用create()创建,好处如下:

  • 1.工厂将创建的过程进行封装,不需要关系创建的细节,更加符合面向对象思想
  • 2.主要的业务逻辑不会被创建对象的代码干扰,代码更易阅读
  • 3.产品的创建可以独立测试,更将容易测试
  • 4.独立的工厂类只负责创建产品,更加符合单一原则

2) 工厂方法 Factory Method

对上面的代码进行重构。我们会为每一个 Resource 创建一个独立的工厂类,形成一个个小作坊,将每一个实例的创建过程交给工厂类完成。

2.a) 对工厂进行抽象化 (版本一)

回到的例子中,每一种url加载成不同的资源产品,那每一种资源都可以由一个独立的ResourceFactory生产,需要将生产资源的工厂类进行抽象:

public interface IResourceLoader {
    Resource load(String url);
}

为每一种资源创建与之匹配的实现:

// Http
public class HttpResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

// File
public class FileResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

// Classpath
public class ClasspathResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

// Default
public class DefaultResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

主要逻辑就会简化

private IResourceLoader resourceLoader;

public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.根据前缀选择不同的工厂,生产独自的产品
    if ("http".equals(prefix)){
        // 发起http请求下载资源....(代码复杂)
        resourceLoader = new HttpResourceLoader();
    } else if ("file".equals(prefix)) {
        // 建立流,做异常...(代码复杂)
        resourceLoader = new FileResourceLoader();
    } else if ("classpath".equals(prefix)) {
        // ......(代码复杂)
        resourceLoader = new ClasspathResourceLoader();
    }else {
        resourceLoader = new DefaultResourceLoader();
    }

    return resourceLoader.load(url);
}

当我们新增一种读取资源的方式时,只需要新增一个实现,并实现 IResourceLoader 接口即可。所以,工厂方法模式比起简单工厂模式更加符合开闭原则。

2.b) 对工厂进行缓存 (版本二)

们为每个产品引入了工厂,却发现需要为创建工厂这个行为付出代价,在创建工厂这件事上,仍然不符合开闭原则

为了解决上述的问题我们又不得不去创建一个工厂的缓存来统一管理工厂实例,以后使用工厂会更加的简单

主要业务逻辑优化为:使用静态代码块和Map进行缓存

// 略....
private static Map<String, IResourceLoader> resourceLoaderCache = new HashMap<>();

static {
    resourceLoaderCache.put("http", new HttpResourceLoader());
    resourceLoaderCache.put("file", new FileResourceLoader());
    resourceLoaderCache.put("classpath", new ClasspathResourceLoader());
    resourceLoaderCache.put("default", new DefaultResourceLoader());
}

/**
 * 资源加载
 * @param url file:// http:// classpath://
 * @return 资源类
 */
public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2
    return resourceLoaderCache.get(prefix).load(url);
}
// 略....

2.c) 加载配置文件到缓存中 (版本三)

但是,当修改需求还是不够灵活,仍然需要修改static中的代码,将工厂类进行配置,加载配置文件到缓存中

创建resourceLoad.properties

http=com.dcy.factoryMethod.resourceFactory.impl.HttpResourceLoader
file=com.dcy.factoryMethod.resourceFactory.impl.FileResourceLoader
classpath=com.dcy.factoryMethod.resourceFactory.impl.ClasspathResourceLoader
default=com.dcy.factoryMethod.resourceFactory.impl.DefaultResourceLoader

主要业务逻辑优化为:

// 略...
private static Map<String, IResourceLoader> resourceLoaderCache = new HashMap<>();

static {
    InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("resourceLoad.properties");
    Properties properties = new Properties();
    try {
        properties.load(inputStream);

        for (Map.Entry<Object, Object> entry : properties.entrySet()) {
            String key = entry.getKey().toString();
            Class<?> clazz = Class.forName(entry.getValue().toString());
            IResourceLoader loader = (IResourceLoader) clazz.getConstructor().newInstance();
            resourceLoaderCache.put(key, loader);
        }

    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.
    return resourceLoaderCache.get(prefix).load(url);
}

// 略...

好处:

  • 1.完成满足开闭原则。当需要扩充需求是,只需要新增实现和修改配置文件,不需要修改一行代码
  • 2.完全解耦
c.1) 产品线

事实上,在工作中,我们的产品可能是及其复杂的,我们同样需要对整个产品线进行抽象

public abstract class AbstractResource {

    private String url;

    public AbstractResource() {
    }

    public AbstractResource(String url) {
        this.url = url;
    }

    protected void shared() {
        System.out.println("这是共享方法");
    }

    /**
     * 每个子类需要独自实现的方法
     * @return 字节流
     */
    public abstract InputStream getInputStream();

}

为每一种产品创建与之匹配的实现:

// classpath
public class ClasspathResource extends AbstractResource {
    public ClasspathResource() {
    }

    public ClasspathResource(String url) {
        super(url);
    }

    @Override
    public InputStream getInputStream() {
        return null;
    }
}

// Http
public class HttpResource extends AbstractResource {
    public HttpResource() {
    }

    public HttpResource(String url) {
        super(url);
    }

    @Override
    public InputStream getInputStream() {
        return null;
    }
}

// Default
public class DefaultResource extends AbstractResource {
    public DefaultResource() {
    }

    public DefaultResource(String url) {
        super(url);
    }

    @Override
    public InputStream getInputStream() {
        return null;
    }
}

修改IResourceLoader接口,将返回一个产品的资源

public interface IResourceLoader {
    AbstractResource load(String url);
}

修改实现工厂的方法

public class ClasspathResourceLoader implements IResourceLoader {
    @Override
    public AbstractResource load(String url) {
        // 省略复杂处理的创建过程
        return new ClasspathResource(url);
    }
}

主要 加载资源load()业务逻辑修改为

public AbstractResource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.
    return resourceLoaderCache.get(prefix).load(url);
}

设计模式-工厂模式Factory,设计模式,设计模式,java,spring,架构,中间件,微服务,spring cloud

c.抽象工厂模式 (Abstract Factory)

重要性比不上简单工厂和工厂方法

抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种、业务分类时,通过抽象工厂模式生产需要的对象是一种不错的解决方案。

多种类型的产品,即增加产品族。如:抽象多种产品类型

public interface Resource {
    InputStream getInputStream();
}
// 抽象文本类型
public abstract class AbstractTextResource implements Resource {
    // 略....
}

// 抽象图片类型
public abstract class AbstractPictureResource implements Resource {
	// 略....
}

// 抽象视频资源
public abstract class AbstractVideoResource implements Resource {
    // 略....
}

每一个工厂实例都可以生产一个产品族

/**
 * IResourceFactory,每一个工厂实例都可以生产一个产品族
 */
public interface IResourceLoader {
    /**
     * 加载图片资源的工厂方法
     * @param url 资源路径
     * @return 图片资源
     */
    AbstractPictureResource loadPicture(String url);

    /**
     * 加载视频资源的工厂方法
     * @param url 资源路径
     * @return 视频资源
     */
    AbstractVideoResource loadVideo(String url);

    /**
     * 加载文本资源的工厂方法
     * @param url 资源路径
     * @return 文本资源
     */
    AbstractTextResource loadText(String url);
}

每一个工厂都对应各自的产品生产线

// Classpath
public class ClasspathResourceLoader implements IResourceLoader {

    @Override
    public AbstractPictureResource loadPicture(String url) {
        return new ClasspathPictureResource(url);
    }

    @Override
    public AbstractVideoResource loadVideo(String url) {
        return new ClasspathVideoResource(url);
    }

    @Override
    public AbstractTextResource loadText(String url) {
        return new ClasspathTextResource(url);
    }
}
// Default
public class DefaultResourceLoader implements IResourceLoader {
    @Override
    public AbstractPictureResource loadPicture(String url) {
        return new DefaultPictureResource(url);
    }

    @Override
    public AbstractVideoResource loadVideo(String url) {
        return new DefaultVideoResource(url);
    }

    @Override
    public AbstractTextResource loadText(String url) {
        return new DefaultTextResource(url);
    }
}
// Http
public class HttpResourceLoader implements IResourceLoader {
    @Override
    public AbstractPictureResource loadPicture(String url) {
        return new HttpPictureResource(url);
    }

    @Override
    public AbstractVideoResource loadVideo(String url) {
        return new HttpVideoResource(url);
    }

    @Override
    public AbstractTextResource loadText(String url) {
        return new HttpTextResource(url);
    }
}

设计模式-工厂模式Factory,设计模式,设计模式,java,spring,架构,中间件,微服务,spring cloud

总结:3种工厂模式

简单工厂:一个工厂生产不同产品

静态资源工厂(工厂方法):一个工厂生产一个产品

抽象工厂:一个工厂生产一个产品族,每一个产品族之间可能会有共享或交叉

当创建逻辑比较复杂,是一个“大工程”的时候,我们就应该考虑使用工厂模式,封装对象的创建过程,将对象的创建和使用相分离

何为创建逻辑比较复杂呢?

  • 类似规则配置解析的例子,代码中存在 if-else 分支判断。将这一大坨 if-else 创建对象的代码抽离出来,放到工厂类中。
  • 单个对象本身的**创建过程比较复杂,**比如前面提到的要组合其他类对象,做各种初始化操作。在这种情况下,我们也可以考虑使用工厂模式,将对象的创建过程封装到工厂类中。

工厂模式的作用:文章来源地址https://www.toymoban.com/news/detail-697363.html

  • 1.封装变化:创建逻辑有可能变化,封装成工厂类之后,创建逻辑的变更对调用者透明。
  • 2.代码复用:创建代码抽离到独立的工厂类之后可以复用。
  • 3.隔离复杂性:封装复杂的创建逻辑,调用者无需了解如何创建对象。
  • 4.控制复杂度:将创建代码抽离出来,让原本的函数或类职责更单一,代码更简洁,测试更方便

到了这里,关于设计模式-工厂模式Factory的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • 设计模式-创建型模式之抽象工厂模式(Abstract Factory)

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

    2023年04月20日
    浏览(39)
  • C++11 设计模式4. 抽象工厂(Abstract Factory)模式

    从前面我们已经使用了工厂方法模式 解决了一些问题。 现在 策划又提出了新的需求:对于各个怪物,在不同的场景下,怪物的面板数值会发生变化,     //怪物分类:亡灵类,元素类,机械类     //战斗场景分类:沼泽地区,山脉地区,城镇。 那么就有9类怪物====沼泽地

    2024年04月14日
    浏览(42)
  • 大话设计模式——2.简单工厂模式(Simple Factory Pattern)

    定义:又称静态工厂方法,可以根据参数的不同返回不同类的实例,专门定义一个类(工厂类)来负责创建其他类的实例可通过类名直接调用,被创建的实例通常具有共同的父类。 UML图: 例子: 计算器中的加减乘除,可将不同的运算看成不同的对象,通过工厂类进行构建,

    2024年02月22日
    浏览(43)
  • 设计模式详解(一):工厂方法——Factory Method

    工厂方法是一种创建型设计模式。所谓创建型设计模式是说针对创建对象方面的设计模式。在面向对象的编程语言里,我们通过对象间的相互协作,共同完成复杂的业务逻辑,因而对象之间存在着依赖关系。 当对象A依赖对象B时,我们不采取直接创建对象B的方式,即 B produ

    2024年02月16日
    浏览(37)
  • 《golang设计模式》第一部分·创建型模式-04-抽象工厂模式(Abstract Factory)

    在不具体指定产品类的情况下,为相互关联的产品簇或产品集提供创建接口,并向客户隐藏具体产品创建的细节或表示的对象。 AbstractFactory(抽象工厂):它声明了一组用于创建产品的方法,每一个方法对应一种产品。 ConcreteFactory(具体工厂):它实现了在抽象工厂中声明

    2024年02月14日
    浏览(43)
  • 设计模式-抽象工厂模式(Abstract Factory Pattern)结构|原理|优缺点|场景|示例

     目录         设计模式(分类)        设计模式(六大原则)        创建型         工厂方法         抽象工厂模式        单例模式        建造者模式        原型模式      结构型         适配器模式        装饰器模式      

    2024年04月22日
    浏览(37)
  • Abstract Factory Pattern 抽象工厂模式简介与 C# 示例【创建型】【设计模式来了】

    一句话解释:   提供一个接口,以创建一系列相关或相互依赖的抽象对象,而无需指定它们具体的类。 (将一系列抽象类装进接口,一次接口实现,就必须实例化这一系列抽象类) 抽象工厂模式(Abstract Factory Pattern)是一种创建型模式。它用于创建一组相关对象的家族。

    2024年02月07日
    浏览(41)
  • Factory Method Pattern 工厂方法模式简介与 C# 示例【创建型】【设计模式来了】

    一句话解释:   实体类和工厂类均为单独实现,不影响已实现的类,方便扩展。 工厂方法模式(Factory Method Pattern)是一种创建型模式,它允许客户端通过工厂方法来创建对象,而不是直接使用构造函数。这样可以让客户端代码更加灵活,同时保持实现的独立性。工厂方法

    2024年02月06日
    浏览(41)
  • Simple Factory Pattern 简单工厂模式简介与 C# 示例【创建型】【设计模式来了】

    一句话解释:   客户类和工厂类严格分工,客户类只需知道怎么用,处理逻辑交给工厂类。 简单工厂模式(Simple Factory Pattern)是日常开发中常用的设计模式。其是一种简单的创建型模式,它通过一个工厂类来创建对象,客户端只需要知道如何使用工厂类,而不需要知道对

    2024年02月06日
    浏览(50)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包