#yyds干货盘点#-设计模式分享-抽象工厂模式

Posted 2021-12-10 爱搞技术的吴同学

概念

简介

作用及优势

• 将一组创建规则类似的产品分为一家工厂创建，易于管理；这类我们称为产品族；

• 可以减少很多if else，相当于简单工厂的再次抽象；

• 增加新的具体工厂和产品族很方便，无须修改之前已有的逻辑

• 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

不足之处

• 产品族扩展非常困难，要增加一个系列的某一产品，不仅要在抽象工厂里面加类型，还要在加具体工厂，然后再加指定产品；所以这种适合非常明确目标的场景下去初始化建设！

场景

• 一个网站适应所有的浏览器

• 一个应用程序，适用于所有的操作系统

代码

案例描述

工程目录

项目类图

具体实现

屏幕接口（Monitor ）：用于生产屏幕；

/**
 * @author chengxing.wu
 * @date 2021/6/15 17:59
 */
public interface Monitor {
    /**
     * 生产屏幕
     */
    void createMonitor();
}

屏幕具体实现：Ips屏幕和曲面屏；

/**
 * @author chengxing.wu
 * @date 2021/6/15 18:04
 */
public class IpsMonitor implements Monitor {
    @Override
    public void createMonitor() {
        System.out.println("==== 生产ips屏 ====");
    }
}

---------------------------------

/**
 * @author chengxing.wu
 * @date 2021/6/15 18:02
 */
public class QmpMonitor implements Monitor {
    @Override
    public void createMonitor() {
        System.out.println("==== 生产曲面屏 ====");
    }
} 

硬盘抽象类（HardDisk）：用于生产硬盘；

/**
 * @author chengxing.wu
 * @date 2021/6/15 18:05
 */
public interface HardDisk {

    /**
     * 生产硬盘
     */
    void createHardDisk();
}

硬盘具体实现：有固态硬盘和机械硬盘

/**
 * @author chengxing.wu
 * @date 2021/6/15 18:07
 */
public class SSDHardDisk implements HardDisk {
    @Override
    public void createHardDisk() {
        System.out.println("==== 生产ssd硬盘 ====");
    }
}

 ---------------------------------

/**
 * @author [e-mail]
 * @date 2021/6/15 18:06
 */
public class MechanicalHardDisk implements HardDisk {
    @Override
    public void createHardDisk() {
        System.out.println("==== 生产机械硬盘 ====");
    }
}

电脑工厂（抽象工厂ComputerFactory ）:

/**
 * @author chengxing.wu
 * @date 2021/6/15 17:50
 */
public abstract class ComputerFactory {
    /**
     * 抽象工厂，电脑工厂既可以生产屏幕，又可以生产硬盘，但是这些都交给对应的厂商去做，自己不做（有子类工厂去做）
     *
     * @param type
     * @return
     */
    public abstract Monitor getMonitor(String type);

    public abstract HardDisk getHardDisk(String type);
}

电脑工厂：这里只负责去获取对应的具体工厂（具有调用具体逻辑实现能力的工厂== 其实就是一个简单工厂）；而这个抽象工厂之后会有一个工厂创造器去生产指定类型的工厂；这个之后看测试代码就很清晰！

• 比如：ProduceFactory 工厂创造器里面传入hdf 就会生成一个硬盘工厂（HardDiskFactory）ComputerFactory；

• Monitor getMonitor(String type);最后这个返回的对象是由具体对象（HardDiskFactory）生成的；

• 关系：ProduceFactory → ComputerFactory（tips）；→ SSDHardDisk

tips： ComputerFactory的类型是（HardDiskFactory），其实就是（HardDiskFactory instanceof ComputerFactory ）= true

公共继承类(CommonFactory)，去除冗余代码；

/**
 * 项目: question-study-improve
 * <p>
 * 功能描述: 公共工厂
 *
 * @author: WuChengXing
 * @create: 2021-07-09 19:01
 **/
public class CommonFactory extends ComputerFactory{
    @Override
    public Monitor getMonitor(String type) {
        return null;
    }

    @Override
    public HardDisk getHardDisk(String type) {
        return null;
    }
}

硬盘生产工厂（HardDiskFactory ）

 /**
 * @author chengxing.wu
 * @date 2021/6/15 18:10
 */
public class HardDiskFactory extends CommonFactory {

    /**
     * 这里不关心屏幕的生产
     *
     * @param type
     * @return
     */
    @Override
    public HardDisk getHardDisk(String type) {
        if ("m".equals(type)) {
            System.out.println("xxxxxxxx 准备生产机械硬盘 xxxxxxxx");
            return new MechanicalHardDisk();
        } else if ("s".equals(type)) {
            System.out.println("xxxxxxxx 准备生产机SSD硬盘 xxxxxxxx");
            return new SSDHardDisk();
        }
        return null;
    }
}

硬盘生产工厂，这里就是个简单工厂，根据传入的类型，去生产指定的产品；但是这里生产的产品，在抽象工厂里，是一系列类似的东西；而这个工厂也是一个具体工厂；

• HardDiskFactory 是一个具体工厂，其实就是一个简单工厂的实现

• ComputerFactory.getHardDisk(String type); → HardDiskFactory → SSDHardDisk；这整个链路连在一起就叫产品族；所以说新增一个产品会很麻烦，需要加一条链路；

屏幕生产工厂：跟硬盘的差不多：

/**
 * @author chengxing.wu
 * @date 2021/6/15 17:58
 */
public class MonitorFactory extends CommonFactory {

    @Override
    public Monitor getMonitor(String type) {
        if ("q".equals(type)) {
            System.out.println("xxxxxxxx 准备生产曲面屏 xxxxxxxx");
            return new QmpMonitor();
        } else if ("i".equals(type)) {
            System.out.println("xxxxxxxx 准备生产IPS屏 xxxxxxxx");
            return new IpsMonitor();
        }
        return null;
    }
}

工厂创造器：这通过传入指定工厂的类型，去获取对应工厂；

/**
 * @author chengxing.wu
 * @date 2021/6/15 18:16
 */
public class ProduceFactory {

    public static ComputerFactory create(String type) {
        if ("mf".equals(type)) {
            System.out.println("-------- 联系屏幕工厂 --------");
            return new MonitorFactory();
        } else if ("hdf".equals(type)) {
            System.out.println("-------- 联系硬盘工厂 --------");
            return new HardDiskFactory();
        }
        return null;
    }
}

测试

/**
 * @author [e-mail]
 * @date 2021/6/15 18:19
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        // 获取到 屏幕的生产工厂
        ComputerFactory monitorFactory = ProduceFactory.create("mf");
        // 获取到 曲面屏
        Monitor qmp = monitorFactory.getMonitor("q");
        //开始生产
        qmp.createMonitor();
        Monitor ips = monitorFactory.getMonitor("i");
        ips.createMonitor();

        ComputerFactory hardDiskFactory = ProduceFactory.create("hdf");
        HardDisk mechanicalHardDisk = hardDiskFactory.getHardDisk("m");
        mechanicalHardDisk.createHardDisk();
        HardDisk ssdHardDisk = hardDiskFactory.getHardDisk("s");
        ssdHardDisk.createHardDisk();
    }
}

结果：

-------- 联系屏幕工厂 --------
xxxxxxxx 准备生产曲面屏 xxxxxxxx
==== 生产曲面屏 ====
xxxxxxxx 准备生产IPS屏 xxxxxxxx
==== 生产ips屏 ====
-------- 联系硬盘工厂 --------
xxxxxxxx 准备生产机械硬盘 xxxxxxxx
==== 生产机械硬盘 ====
xxxxxxxx 准备生产机SSD硬盘 xxxxxxxx
==== 生产ssd硬盘 ====