简述

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一，它通过定义一个创建对象的接口来让子类决定实例化哪个类，使得创建对象的过程更加灵活和可扩展。本文将详细介绍工厂模式的概念、类型以及实际应用示例。

设计模式样例：https://gitee.com/lhdxhl/design-pattern-example.git

什么是工厂模式

工厂模式是一种创建型设计模式，主要用来封装对象的创建过程。它将实例化对象的代码从使用者中分离出来，遵循 "开放-关闭原则" 和 "单一职责原则"。

常见的工厂模式分为三种类型：

[微风] 简单工厂模式（Simple Factory）

[微风] 工厂方法模式（Factory Method）

?[微风] 抽象工厂模式（Abstract Factory）

实际案例

?[微风] 封装性好：创建逻辑集中在工厂类中，简化了客户端代码。

?[微风] 可扩展性强：新增产品类时，只需扩展工厂类即可。

?[微风] 减少耦合：客户端代码与具体产品类解耦。

简单工厂模式

简单工厂模式是最基本的工厂模式，通过一个工厂类，根据传入的参数来决定创建哪种具体对象。假设我们需要一个形状工厂，用于创建不同的形状对象。

// 形状接口
public interface Shape {
    void draw();
}

// 圆形实现类
public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 矩形实现类
public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}

// 工厂类
public class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        switch (shapeType) {
            case "CIRCLE":
                return new Circle();
            case "RECTANGLE":
                return new Rectangle();
            default:
                throw new IllegalArgumentException("Unknown shape type: " + shapeType);
        }
    }
}

// 测试类
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw();
    }
}

输出：

Drawing a Circle
Drawing a Rectangle

工厂方法模式

工厂方法模式通过定义一个抽象工厂接口，将对象的创建过程延迟到子类实现。相比简单工厂模式，工厂方法模式符合开闭原则。

// 形状接口
public interface Shape {
    void draw();
}

// 圆形实现类
public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 矩形实现类
public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}

// 工厂接口
public interface ShapeFactory {
    Shape createShape();
}

// 圆形工厂
public class CircleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Circle();
    }
}

// 矩形工厂
public class RectangleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Rectangle();
    }
}

// 测试类
public class FactoryMethodDemo {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw();
    }
}

输出：

Drawing a Circle
Drawing a Rectangle

抽象工厂模式

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。它是一种工厂的工厂。

// 形状接口
public interface Shape {
    void draw();
}

// 颜色接口
public interface Color {
    void fill();
}

// 圆形实现类
public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 红色实现类
public class Red implements Color {
    public void fill() {
        System.out.println("Filling with Red color");
    }
}

// 抽象工厂
public interface AbstractFactory {
    Shape getShape();
    Color getColor();
}

// 形状工厂
public class ShapeFactory implements AbstractFactory {
    public Shape getShape() {
        return new Circle();
    }

    public Color getColor() {
        return null; // 不支持颜色
    }
}

// 颜色工厂
public class ColorFactory implements AbstractFactory {
    public Shape getShape() {
        return null; // 不支持形状
    }

    public Color getColor() {
        return new Red();
    }
}

// 测试类
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = new ShapeFactory();
        Shape circle = shapeFactory.getShape();
        circle.draw();

        AbstractFactory colorFactory = new ColorFactory();
        Color red = colorFactory.getColor();
        red.fill();
    }
}

输出：

Drawing a Circle
Filling with Red color

应用场景

?[微风] 日志框架：如 SLF4J 中的 Logger 工厂。

?[微风] 数据库连接：如 JDBC 中的 `DriverManager.getConnection()`。

?[微风] XML 解析：如 DOM 和 SAX 的解析器工厂。

?[微风] Spring 框架：如 BeanFactory 和 ApplicationContext。

总结

工厂模式是 Java 开发中不可或缺的设计模式，能够显著提高代码的可扩展性和可维护性。在实际开发中，根据需求选择合适的工厂模式能够有效解决对象创建的复杂性问题。

希望本文对您理解工厂模式有所帮助！如果有任何问题，欢迎讨论交流！