当前位置：首页 > article >正文

设计模式创建型抽象工厂模式（Abstract Factory）与常见技术框架应用解析

article 2025/1/11 18:35:41

在这里插入图片描述

抽象工厂模式（Abstract Factory Pattern）是创建型设计模式之一，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。这种模式强调了族（family）的概念，即一组具有相同主题的产品对象。

抽象工厂模式通过定义一个接口，使得客户端可以在不必指定具体产品的情况下，创建多个产品族中的产品对象。它强调了一组产品的概念，即产品族，这有助于开发人员理解和管理具有复杂关系的产品集。

一、核心思想

抽象工厂模式的核心思想在于定义一个工厂接口，该接口负责创建一系列相关的对象。具体实现这些接口的工厂类则根据实际需求创建特定类型的产品对象。通过这种方式，客户端代码可以与具体的产品解耦，只需依赖于抽象工厂和抽象产品接口进行操作。

二、定义与结构

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

结构：

抽象工厂（Abstract Factory）：声明了一组用于创建产品对象的方法，每个方法对应一种产品类型。
具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体产品对象的实例。
抽象产品（Abstract Product）：定义了产品族中每种产品的公共接口，是所有具体产品类的基类或接口。
具体产品（Concrete Product）：实现了抽象产品接口，是产品族中每种产品的具体实现。

三、角色

在抽象工厂模式中，各个角色负责不同的职责：

抽象工厂：提供创建产品的接口。
具体工厂：实现抽象工厂接口，创建具体产品。
抽象产品：定义产品的规范。
具体产品：实现抽象产品接口，由具体工厂创建。
客户端：使用抽象工厂接口来创建所需的产品对象。

四、实现步骤及代码示例

以Java技术框架为例，展示抽象工厂模式的具体实现步骤和代码示例。

步骤：

定义抽象产品和具体产品。
定义抽象工厂和具体工厂。
客户端使用具体工厂创建所需产品。

代码示例：

// 抽象产品接口：形状
public interface Shape {
    void draw();
}

// 具体产品类：圆形
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

// 具体产品类：矩形
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

// 抽象产品接口：颜色
public interface Color {
    void fill();
}

// 具体产品类：红色
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

// 具体产品类：绿色
public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("Inside Green::fill() method.");
    }
}

// 抽象工厂接口
public abstract class AbstractFactory {
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape);
}

// 具体工厂类：形状工厂
public class ShapeFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        return null; // ShapeFactory不创建颜色对象
    }

    @Override
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

// 具体工厂类：颜色工厂
public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("GREEN")) {
            return new Green();
        }
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        return null; // ColorFactory不创建形状对象
    }
}

// 客户端代码
public class ClientApp {
    public static void main(String[] args) {
        // 创建ShapeFactory对象
        AbstractFactory shapeFactory = new ShapeFactory();

        // 获取形状类型为Circle的对象
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw(); // 输出 Inside Circle::draw() method.

        // 获取形状类型为Rectangle的对象
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        shape2.draw(); // 输出 Inside Rectangle::draw() method.

        // 创建ColorFactory对象
        AbstractFactory colorFactory = new ColorFactory();

        // 获取颜色类型为Red的对象
        Color color1 = colorFactory.getColor("RED");
        color1.fill(); // 输出 Inside Red::fill() method.

        // 获取颜色类型为Green的对象
        Color color2 = colorFactory.getColor("GREEN");
        color2.fill(); // 输出 Inside Green::fill() method.
    }
}

五、常见技术框架应用（前端框架示例）

在前端框架中，抽象工厂模式（Abstract Factory）是一种非常实用的设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。以下是在前端框架中应用抽象工厂模式的几个具体例子：

1、UI组件库的创建

在前端开发中，创建UI组件库是抽象工厂模式的一个典型应用场景。例如，可以定义一个抽象的UIComponentFactory类，它就像一个蓝图或者说规范，定义了创建各种UI组件的方法。然后，可以创建具体的工厂类，如MaterialUIComponentFactory和AntDesignUIComponentFactory，它们继承自UIComponentFactory这个抽象工厂类，并实现创建具体UI组件的方法。

// 抽象工厂
class UIComponentFactory {
    createButton() {}
    createInput() {}
    // 可以继续添加其他创建UI组件的方法
}

// 具体工厂 - Material UI
class MaterialUIComponentFactory extends UIComponentFactory {
    createButton() {
        return new MaterialButton();
    }
    createInput() {
        return new MaterialInput();
    }
    // 实现其他创建UI组件的方法
}

// 具体工厂 - Ant Design
class AntDesignUIComponentFactory extends UIComponentFactory {
    createButton() {
        return new AntDesignButton();
    }
    createInput() {
        return new AntDesignInput();
    }
    // 实现其他创建UI组件的方法
}

在前端项目中，如果要切换不同的UI风格，只需要切换使用不同的具体工厂类即可。这使得代码具有更好的可维护性和扩展性，因为当需要增加新的UI组件或者新的UI库时，只需要按照抽象工厂的规范添加新的具体工厂类和产品类即可。

2、跨浏览器的XHR对象创建

在处理跨浏览器的XMLHttpRequest（XHR）对象创建时，也可以用到抽象工厂模式。不同的浏览器对于XHR对象的创建和使用可能存在差异。这时，可以创建一个抽象的XHRFactory类，它定义了创建XHR对象的抽象方法，例如createXHR。然后，针对不同的浏览器（如Chrome、Firefox、IE等）创建具体的工厂类，这些具体工厂类实现createXHR方法来返回适合该浏览器的XHR对象实例。

// 抽象工厂
class XHRFactory {
    createXHR() {}
}

// 具体工厂 - Chrome
class ChromeXHRFactory extends XHRFactory {
    createXHR() {
        // 返回适合Chrome浏览器的XHR对象实例
        return new XMLHttpRequest(); // 简化示例，实际可能需要更复杂的处理
    }
}

// 具体工厂 - Firefox
class FirefoxXHRFactory extends XHRFactory {
    createXHR() {
        // 返回适合Firefox浏览器的XHR对象实例
        // 注意：现代浏览器通常都支持标准的XMLHttpRequest，这里仅为示例
        return new XMLHttpRequest();
    }
}

// 具体工厂 - IE（假设需要特殊处理）
class IEXHRFactory extends XHRFactory {
    createXHR() {
        // 返回适合IE浏览器的XHR对象实例，可能需要使用ActiveXObject等
        // 这里仅为示例，实际代码可能更复杂
        if (window.ActiveXObject) {
            return new ActiveXObject("Msxml2.XMLHTTP");
        } else {
            return new XMLHttpRequest(); // 兼容性处理，可能不需要
        }
    }
}