设计模式（三）——工厂模式详解

壹升茉莉清

于 2022-09-05 14:29:42 发布

阅读量296

点赞数 1

分类专栏：设计模式文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/weixin_40920359/article/details/126698208

版权

设计模式专栏收录该内容

24 篇文章 0 订阅 ¥9.90 ¥99.00

订阅专栏

超级会员免费看

设计模式（二）——工厂模式详解

概述
简单工厂模式
简单工厂+配置文件解除耦合
工厂方法模式
- 优缺点
抽象工厂模式
- 优缺点
JDK源码中的工厂模式

概述

假如我们要实现一个奶茶店的点餐系统，首先有一个奶茶类，还有两个子类珍珠奶茶和魔芋奶茶，还要有一奶茶店类，奶茶店可以点奶茶。

在使用java开发时，在上边的场景中，我们需要对每一个对象进行创建，如果在创建的时候都进行new对象，对象之间都会严重耦合，假如对象之间的关系变了，new对象的地方就要修改，显然不符合开闭原则。

如果我们使用工厂来创建对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换对象就好了，达到了与对象之间的解耦目的。所以说工厂模式最大的优点是：解耦。

在本篇文章中将介绍三种工厂的使用:

简单工厂模式（不属于GOF的23种经典设计模式）
工厂方法模式
抽象工厂模式

简单工厂模式

简单工厂并不属于GOF的23种经典设计模式，更像是一种编程习惯。

简单工厂包含如下角色：

抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
具体商品：实现或继承抽象产品的子类
具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。

代码实现

以上边的手机案例编写代码：

商品类：

// 抽象产品 手机类
public class Phone {
}
//具体商品 小米手机
public class Xiaomi extends Phone{
}

//具体商品 苹果手机
public class Apple extends Phone{
}

工厂类：


public class SimplePhoneFactory {
    public Phone create(String type) {
        Phone phone = null;
        if("apple".equals(type)) {
            phone = new Phone();
        } else if("xiaomi".equals(type)) {
            phone = new Xiaomi();
        }
        return phone;
    }
}

手机店类：

public class PhoneShop {
    public void buy(String type) {
        SimplePhoneFactory factory = new SimplePhoneFactory();
        Phone phone = factory.create(type);
    }
}

工厂处理创建对象的细节，将创建对象的任务交给工厂，手机店想要获得手机对象不用自己去创建，直接从工厂获取就好了。这样就解除了和手机的耦合，但也产生了新的耦合，手机店和工厂的耦合，工厂和商品的耦合。
假如后期再加上一个华为手机，我们是必须要修改工厂的代码的违反了开闭原则。

优缺点

优点：

封装了创建对象的过程，通过参数创建对象。吧对象创建和业务逻辑层分开，这样就避免了修改客户代码，如果要实现新产品就修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能，更加容易拓展。

缺点：

增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

静态工厂

在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下：

public class SimplePhoneFactory {
    public static Phone create(String type) {
        Phone phone = null;
        if("apple".equals(type)) {
            phone = new Phone();
        } else if("xiaomi".equals(type)) {
            phone = new Xiaomi();
        }
        return phone;
    }
}

简单工厂+配置文件解除耦合

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。

第一步：定义配置文件

为了演示方便，我们使用properties文件作为配置文件，名称为bean.properties

apple=com.test.factory.test.Apple
xiaomi=com.test.factory.test.Xiaomi

第二步：改进工厂类

public class SimplePhoneFactory {

    private static Map<String,Phone> map = new HashMap();

    static {
        Properties p = new Properties();
        InputStream is = SimplePhoneFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            p.load(is);
            //遍历Properties集合对象
            Set<Object> keys = p.keySet();
            for (Object key : keys) {
                //根据键获取值（全类名）
                String className = p.getProperty((String) key);
                //获取字节码对象
                Class clazz = Class.forName(className);
                Phone obj = (Phone) clazz.newInstance();
                map.put((String)key,obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Phone create(String name) {
        return map.get(name);
    }
}

静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象），而读取配置文件以及创建对象写在静态代码块中，目的就是只需要执行一次。

工厂方法模式

针对上边例子的缺点，使用工厂方法模式就可以解决，完全遵循开闭原则。

定义一个创建对象的接口，让子类决定去实例化哪个产品类对象。工厂方法是一个产品类的实例化延迟到其子类工厂。

工厂方法模式角色：

抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
具体工厂：主要实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

代码实现：

抽象工厂：

public interface PhoneFactory {
    Phone create(String type);
}

具体工厂：

public class XiaomiPhoneFactory implements PhoneFactory{
    @Override
    public Phone create(String type) {
        return new Xiaomi();
    }
}

手机店类：

public class PhoneShop {
    private PhoneFactory factory;

    public PhoneShop(PhoneFactory factory) {
        this.factory = factory;
    }

    public void buy(String type) {
        factory.create(type);
    }
}

从上边的代码可以看到，要增加产品类也要增加对应的工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。
工厂方法模式是简单工厂的进一步抽象，由于使用了多态性，工厂方法模式保持了简单工厂的优点，也克服了它的缺点。

优缺点

优点：

用户只需要知道对应产品的工厂名称就可以创建商品对象，无需知道产品的创建过程。
在系统增加新的产品时，只需要添加具体产品类和对应的工厂类，无需对原工厂进行任何修改，满足开闭原则。

缺点：

每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

抽象工厂模式

前面介绍的工厂只能生产同一类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类）的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。
抽象工厂模式将考虑多级产品的生产，我们将同一个具体工厂生产的不同等级的产品称为一个产品族。
在这里插入图片描述

抽象工厂模式是一种为访问类提供的创建一组或相互依赖对象的接口，且访问类无需指定所要产品的具体类就能得到同族的不同等级的模式结构。

抽象工厂模式的主要角色如下：

抽象工厂：提供创建产品的接口，包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂：主要是实现抽象工厂中多个抽象方法，完成具体产品的创建。
抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

假如现在业务拓展，苹果公司新增了mac笔记本电脑，小米公司新增了RedMi笔记本电脑。我们来实现这个功能。

电脑及其子类：

//电脑类：父类
public class Computer {
}

// 苹果公司电脑MAC 
public class Mac extends Computer{
}

// 小米公司电脑RedMi
public class RedMi extends Computer{
}

抽象工厂类：

public interface ElectricalFactory {

    /**
     * 创建手机
     * @return
     */
    Phone createPhone();

    /**
     * 创建电脑
     * @return
     */
    Computer createComputer();

}

具体工厂类：

// 苹果工厂：对应产品族
public class AppleFactory implements ElectricalFactory {

	// 制造苹果手机
    @Override
    public Phone createPhone() {
        return new Apple();
    }

	// 制造苹果电脑
    @Override
    public Computer createComputer() {
        return new Mac();
    }
}

// 小米工厂：对应产品族
public class XiaomiFactory implements ElectricalFactory{

	// 制造小米手机
    @Override
    public Phone createPhone() {
        return new Xiaomi();
    }
	
	// 制造小米电脑
    @Override
    public Computer createComputer() {
        return new RedMi();
    }
}