设计模式之工厂模式

---

前言

工厂模式（Factory Pattern）作为一种创建型设计模式，致力于解决对象创建问题，并将对象的创建过程与使用过程分离开来。其核心意义在于提高代码的灵活性、可扩展性与可维护性。通过深入理解其作用和优点，可以更好地在软件开发中应用这一模式。

---

一、工厂模式的意义和优点

1、解耦创建和使用（Separation of Concerns）

工厂模式将对象的创建逻辑从使用逻辑中解耦。客户端无需知道具体的对象创建过程，只需依赖工厂来获取对象实例。这提升了代码的模块化程度，使得系统中的各部分变得更加独立和容易维护。

示例：在复杂系统中，业务逻辑层和数据访问层的代码可以通过工厂模式进行隔离。业务逻辑层无需关心具体的数据库连接和数据结构，只需通过工厂类获取所需的对象。

2、 遵循“开闭原则”（Open/Closed Principle）

工厂模式有助于遵循SOLID原则中的开闭原则，即对扩展开放，对修改关闭。当需要添加新的产品类时，只需添加新的具体工厂类或修改现有工厂类，而无需更改现有的客户端代码。

示例：在工厂方法模式中，通过创建新的工厂子类来生成新的产品对象，可以在不修改现有代码的情况下扩展系统。

3、提升代码的可维护性和可读性

将对象的创建逻辑集中在工厂类中，使得代码的维护和修改更加集中，这大大提升了代码的可读性和可维护性。开发人员只需查看和修改工厂类，而不是遍布整个系统的对象创建代码。

示例：对于跨模块的对象创建，更新创建逻辑或优化性能只需修改工厂类而非分散在各处的创建代码。

4、 减少重复代码（Code Reusability and Reduction of Duplication）

工厂模式能够减少代码中的重复部分，尤其是在对象创建较为复杂的情况下。统一的创建逻辑避免了冗余代码，有助于代码重用。

示例：创建多个复杂对象实例时，所有实例化的细节由工厂类处理，简化了客户端代码。

5、 促进对象的管理和控制

通过工厂方法，可以在创建对象时注入依赖、进行配置或实施某些约束。这有助于在对象生命周期中更好地进行管理和控制。

示例：在创建数据库连接对象时，可以在工厂方法中统一配置连接池参数，确保每个连接对象的初始化符合系统要求。

6、 便于替换和测试

工厂模式使得替换和测试变得更加方便。通过工厂方法，较容易实现依赖注入 (Dependency Injection) 和控制反转（Inversion of Control），从而提高测试的可控性和灵活性。

示例：在单元测试中，可以使用模拟（mock）的工厂类来提供伪对象，从而隔离对外部资源的依赖。

二、工厂模式的实现方式

1、简单工厂模式 （Simple Factory Pattern）

简单工厂模式，也称为静态工厂方法模式，是用一个工厂类来创建对象。这种方式非常简单，但是在增加新的产品类时需要修改工厂类，违背了开闭原则（Open-Closed Principle）。
假设我们要创建不同类型的汽车对象：

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

// 具体的汽车实现类
public class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan...");
    }
}

public class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV...");
    }
}

// 简单工厂类
public class CarFactory {
    public static Car createCar(String type) {
        switch (type) {
            case "sedan":
                return new Sedan();
            case "suv":
                return new SUV();
            default:
                throw new IllegalArgumentException("Unknown car type.");
        }
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Car sedan = CarFactory.createCar("sedan");
        sedan.drive();

        Car suv = CarFactory.createCar("suv");
        suv.drive();
    }
}

2、工厂方法模式（Factory Method Pattern）

工厂方法模式通过定义一个创建对象的接口，让子类决定实例化哪个类。这种模式让一个类的实例化延迟到其子类。
以创建不同类型的汽车为例：

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

// 具体的汽车实现类
public class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan...");
    }
}

public class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV...");
    }
}

// 工厂方法接口
public interface CarFactory {
    Car createCar();
}

// 具体的工厂实现类
public class SedanFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Sedan();
    }
}

public class SUVFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SUV();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        CarFactory sedanFactory = new SedanFactory();
        Car sedan = sedanFactory.createCar();
        sedan.drive();

        CarFactory suvFactory = new SUVFactory();
        Car suv = suvFactory.createCar();
        suv.drive();
    }
}

3、抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。这种模式可以更好地支持扩展，且更加复杂和灵活。
我们不再只创建某种汽车，而是创建不同品牌的工厂来生产不同类型的汽车。

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

// 具体的汽车实现类
public class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan...");
    }
}

public class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV...");
    }
}

// 抽象工厂接口
public interface CarFactory {
    Car createSedan();
    Car createSUV();
}

// 具体的工厂实现类
public class FordFactory implements CarFactory {
    @Override
    public Car createSedan() {
        return new Sedan() {
            @Override
            public void drive() {
                System.out.println("Driving a Ford sedan...");
            }
        };
    }

    @Override
    public Car createSUV() {
        return new SUV() {
            @Override
            public void drive() {
                System.out.println("Driving a Ford SUV...");
            }
        };
    }
}

public class ToyotaFactory implements CarFactory {
    @Override
    public Car createSedan() {
        return new Sedan() {
            @Override
            public void drive() {
                System.out.println("Driving a Toyota sedan...");
            }
        };
    }

    @Override
    public Car createSUV() {
        return new SUV() {
            @Override
            public void drive() {
                System.out.println("Driving a Toyota SUV...");
            }
        };
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        CarFactory fordFactory = new FordFactory();
        Car fordSedan = fordFactory.createSedan();
        fordSedan.drive();

        CarFactory toyotaFactory = new ToyotaFactory();
        Car toyotaSUV = toyotaFactory.createSUV();
        toyotaSUV.drive();
    }
}