【设计模式】-工厂模式(简单工厂、工厂方法、抽象工厂)

工厂模式(简单工厂、工厂方法、抽象工厂)

介绍

简单工厂模式

简单工厂模式不属于23种GoF设计模式之一，但它是一种常见的设计模式。它提供了一种创建对象的接口，但由子类决定要实例化的类是哪一个。这样，工厂方法模式让类的实例化推迟到子类。

优点：允许客户端通过一个共同的接口来创建对象，隐藏了实例化的过程。
缺点：新增产品时需要修改工厂代码，违反开闭原则。
框架应用
JDBC 的 DriverManager：根据数据库 URL 返回对应的 Connection 对象。

工厂方法模式（Factory Method Pattern）

工厂方法模式定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。工厂方法使得一个类的实例化延迟到其子类。

优点：符合开闭原则，可以在不修改工厂的情况下增加新的产品。
缺点：每增加一种产品，就需要增加相应的具体工厂类，增加了系统的复杂度。
简单工厂模式相比于工厂方法模式比较简单，管理不太复杂，所以在很多项目中也不会完全设计原则编写代码，很多地方还是采用了简单工厂模式
框架应用
Spring 的 BeanFactory：通过 ApplicationContext（子类）动态创建和管理 Bean。
MyBatis：SqlSessionFactory负责创建SqlSession实例，这里的SqlSessionFactory就是一个典型的工厂角色。

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供了一组接口，用于创建相关或依赖对象的家族，而不需要明确指定具体的类。它是工厂方法模式的进一步扩展。

优点：可以很容易地在一组相关的产品中切换实现（产品族）。
缺点：当产品族中加入新产品时，所有工厂类都需要修改（在产品族数量长期稳定的时候建议使用）。

–

代码实现

简单工厂模式

在这个例子中，我们将创建一个简单的工厂用于生成不同品牌的汽车实例。

// 汽车接口
interface Car {
    void drive();
}

// 宝马汽车
class BMW implements Car {
    public void drive() {
        System.out.println("Driving a BMW.");
    }
}

// 奔驰汽车
class Mercedes implements Car {
    public void drive() {
        System.out.println("Driving a Mercedes.");
    }
}

// 简单汽车工厂
class SimpleCarFactory {
    public static Car createCar(String type) {
        if ("BMW".equalsIgnoreCase(type)) {
            return new BMW();
        } else if ("Mercedes".equalsIgnoreCase(type)) {
            return new Mercedes();
        }
        return null;
    }
}

// 客户端代码
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Car car = SimpleCarFactory.createCar("BMW");
        if (car != null) {
            car.drive();
        }
    }
}

类图

在这里插入图片描述

工厂方法模式

这里，我们将使用工厂方法模式，每个具体的工厂负责创建特定类型的汽车。

// 汽车接口
interface Car {
    void drive();
}

// 宝马汽车
class BMW implements Car {
    public void drive() {
        System.out.println("Driving a BMW.");
    }
}

// 奔驰汽车
class Mercedes implements Car {
    public void drive() {
        System.out.println("Driving a Mercedes.");
    }
}

// 抽象工厂接口
interface CarFactory {
    Car createCar();
}

// 宝马工厂
class BMWFactory implements CarFactory {
    public Car createCar() {
        return new BMW();
    }
}

// 奔驰工厂
class MercedesFactory implements CarFactory {
    public Car createCar() {
        return new Mercedes();
    }
}

// 客户端代码
public class FactoryMethodDemo {
    public static void main(String[] args) {
        CarFactory factory = new BMWFactory();
        Car car = factory.createCar();
        car.drive();
    }
}

类图

在这里插入图片描述

抽象工厂模式

在抽象工厂模式的例子中，我们将创建一个家族的产品（比如汽车及其配件）。

// 抽象产品A - 车身
interface Body {
    void design();
}

// 具体车身A1 - 宝马车身
class BMWBody implements Body {
    public void design() {
        System.out.println("Designing BMW body.");
    }
}

// 具体车身A2 - 奔驰车身
class MercedesBody implements Body {
    public void design() {
        System.out.println("Designing Mercedes body.");
    }
}

// 抽象产品B - 引擎
interface Engine {
    void build();
}

// 具体引擎B1 - 宝马引擎
class BMWEngine implements Engine {
    public void build() {
        System.out.println("Building BMW engine.");
    }
}

// 具体引擎B2 - 奔驰引擎
class MercedesEngine implements Engine {
    public void build() {
        System.out.println("Building Mercedes engine.");
    }
}

// 抽象工厂
interface CarFactory {
    Body createBody();
    Engine createEngine();
}

// 宝马工厂
class BMWFactory implements CarFactory {
    public Body createBody() { return new BMWBody(); }
    public Engine createEngine() { return new BMWEngine(); }
}

// 奔驰工厂
class MercedesFactory implements CarFactory {
    public Body createBody() { return new MercedesBody(); }
    public Engine createEngine() { return new MercedesEngine(); }
}

// 客户端代码
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        CarFactory factory = new BMWFactory();
        Body body = factory.createBody();
        Engine engine = factory.createEngine();
        body.design();
        engine.build();
    }
}