java开发中的设计模式之工厂模式

工厂模式在Java开发中的详细讲解

工厂模式（Factory Pattern）是Java中最常用的设计模式之一，它提供了一种创建对象的最佳方式。在工厂模式中，对象的创建逻辑对客户端是隐藏的，客户端通过一个共同的接口来使用新创建的对象，从而实现解耦和灵活性。本文将详细讲解工厂模式的类型、使用场景，并结合代码示例进行说明。

工厂模式主要分为三种类型：

1. 简单工厂模式（Simple Factory Pattern）
2. 工厂方法模式（Factory Method Pattern）
3. 抽象工厂模式（Abstract Factory Pattern）

下面将逐一介绍每种类型，包括定义、使用场景、代码示例及其优缺点。

---

1. 简单工厂模式

定义

简单工厂模式（也称为静态工厂方法模式）通过定义一个工厂类，根据客户端传入的参数来创建不同的对象实例。工厂类封装了对象的创建逻辑，客户端只需提供参数即可获得对象。

使用场景

简单工厂模式适用于以下场景：

• 需要根据不同参数创建不同对象，且产品种类较少且不易变化。
• 例如，根据配置文件选择创建不同的数据库连接（如MySQL、PostgreSQL）。

代码示例

以下是一个简单工厂模式的实现，模拟创建不同类型的"产品"：

// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();  // 输出: 使用产品A

        Product productB = SimpleFactory.createProduct("B");
        productB.use();  // 输出: 使用产品B
    }
}

优点

• 简单易用：客户端无需知道具体产品类的实现，只需传递参数即可。
• 集中管理：对象的创建逻辑集中在工厂类中，便于维护。

缺点

• 扩展性差：每增加一个新产品，都需要修改工厂类的代码，违反了"开闭原则"（对扩展开放，对修改关闭）。

---

2. 工厂方法模式

定义

工厂方法模式定义了一个创建对象的接口（工厂接口），但将具体的对象实例化推迟到子类中实现。每个具体产品由对应的具体工厂类负责创建。

使用场景

工厂方法模式适用于以下场景：

• 一个类无法提前知道需要创建的具体对象类型。
• 需要通过子类来指定创建的对象。
• 例如，不同类型的日志记录器（如文件日志、网络日志）的创建。

代码示例

以下是一个工厂方法模式的实现，创建不同类型的产品：

// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂接口
public interface Factory {
    Product createProduct();
}

// 具体工厂A
public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();  // 输出: 使用产品A

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();  // 输出: 使用产品B
    }
}

优点

• 符合开闭原则：增加新产品时，只需新增具体工厂和产品类，无需修改现有代码。
• 解耦：客户端与具体产品类解耦，只依赖工厂接口。

缺点

• 类数量增加：每增加一个新产品，都需要新增一个具体工厂类，导致类数量变多。

---

3. 抽象工厂模式

定义

抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。它通常用于创建一组产品族。

使用场景

抽象工厂模式适用于以下场景：

• 需要创建一组相关或相互依赖的对象，且这些对象之间有一定的约束关系。
• 例如，创建不同风格的UI组件（如Windows风格、Mac风格的按钮和文本框）。

代码示例

以下是一个抽象工厂模式的实现，创建两组相关的产品：

// 抽象产品A
public interface AbstractProductA {
    void use();
}

// 具体产品A1
public class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("使用产品A1");
    }
}

// 具体产品A2
public class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("使用产品A2");
    }
}

// 抽象产品B
public interface AbstractProductB {
    void use();
}

// 具体产品B1
public class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void use() {
        System.out.println("使用产品B1");
    }
}

// 具体产品B2
public class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void use() {
        System.out.println("使用产品B2");
    }
}

// 抽象工厂接口
public interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.use();  // 输出: 使用产品A1
        productB1.use();  // 输出: 使用产品B1

        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.use();  // 输出: 使用产品A2
        productB2.use();  // 输出: 使用产品B2
    }
}

优点

• 产品族一致性：确保由同一工厂创建的产品是兼容的。
• 解耦：客户端与具体产品类解耦，只依赖抽象工厂接口。

缺点

• 扩展性有限：如果需要增加新的产品类型（如新增AbstractProductC），需要修改抽象工厂接口和所有具体工厂类，违反开闭原则。

---

总结与选择指南

三种工厂模式的对比

模式	适用场景	优点	缺点
简单工厂模式	产品种类少且固定	简单易用，逻辑集中	扩展性差，违反开闭原则
工厂方法模式	产品种类多，需灵活扩展	符合开闭原则，解耦	类数量增加
抽象工厂模式	创建一组相关或依赖的对象	保证产品族一致性，解耦	扩展新产品类型困难

如何选择

• 简单工厂模式：适合小型项目或产品种类较少、不常变化的场景。
• 工厂方法模式：适合需要动态扩展产品类型的场景，如框架开发。
• 抽象工厂模式：适合需要创建一组相关对象的复杂系统，如跨平台的UI组件库。

通过合理选择工厂模式，可以提高Java代码的可维护性、扩展性和解耦性。在实际开发中，建议根据具体需求权衡每种模式的优缺点，以设计出优雅的系统架构。