Java设计模式-工厂模式

[1. 设计模式有哪些](#1. 设计模式有哪些)

[2. 工厂模式作用是什么](#2. 工厂模式作用是什么)

[3. 工厂模式实践](#3. 工厂模式实践)

[3.1 简单工厂模式](#3.1 简单工厂模式)

[3.2 工厂方法模式](#3.2 工厂方法模式)

[3.3 抽象工厂模式](#3.3 抽象工厂模式)

[4. 框架中的工厂模式源码](#4. 框架中的工厂模式源码)

1. 设计模式有哪些

『创建型』：用于对象的创建，隐藏对象创建逻辑，提升系统灵活性

『结构型』：关注对象或类的组合，解决类或对象之间的组合关系

『行为型』：关注对象之间的通信和职责分配

|-------|--------|----------------------------------------|----|
| 类型 | 设计模式 | 功能 | 备注 |
| 创建型 | 单例模式 | 保证一个类只有一个实例，并提供全局访问点 | ✅ |
| 创建型 | 工厂方法模式 | 定义一个用于创建对象的接口，由子类决定实例化哪一个类 | ✅ |
| 创建型 | 抽象工厂模式 | 提供一个创建一系列相关或相互依赖对象的接口 | |
| 创建型 | 建造者模式 | 将一个复杂对象的构建与其表示分离，使同样的构建过程可以创建不同的表示 | |
| 创建型 | 原型模式 | 通过复制已有的实例来创建新的实例，而不是通过 new 生成 | |
| 结构型模式 | 适配器模式 | 将一个类的接口转换成客户希望的另一个接口 | ✅ |
| 结构型模式 | 装饰器模式 | 动态地给对象添加一些额外的职责 | |
| 结构型模式 | 代理模式 | 为其他对象提供一种代理以控制对这个对象的访问 | ✅ |
| 结构型模式 | 外观模式 | 为子系统中的一组接口提供一个统一的高层接口 | |
| 结构型模式 | 桥接模式 | 将抽象部分与实现部分分离，使它们可以独立变化 | |
| 结构型模式 | 组合模式 | 将对象组合成树形结构以表示"部分-整体"的层次结构 | |
| 结构型模式 | 享元模式 | 运用共享技术有效地支持大量细粒度的对象 | |
| 行为型模式 | 观察者模式 | 对象之间一对多的依赖关系 | |
| 行为型模式 | 策略模式 | 定义一系列算法，把它们一个个封装起来，并且使它们可以互换 | |
| 行为型模式 | 模板方法模式 | 定义一个操作中的算法骨架，将一些步骤延迟到子类中实现 | |
| 行为型模式 | 命令模式 | 将请求封装为对象，从而使你可用不同的请求对客户进行参数化 | |
| 行为型模式 | 责任链模式 | 使多个对象都有机会处理请求，避免请求的发送者和接收者之间的耦合。 | ✅ |
| 行为型模式 | 状态模式 | 允许对象在内部状态改变时改变它的行为 | |
| 行为型模式 | 备忘录模式 | 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 | |
| 行为型模式 | 中介者模式 | 用一个中介对象来封装一系列的对象交互 | |
| 行为型模式 | 迭代器模式 | 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。 | |
| 行为型模式 | 解释器模式 | 给定一个语言，定义它的文法的一种表示，并定义一个解释器。 | |

2. 工厂模式作用是什么

工厂模式（Factory Pattern）是一种创建型设计模式，主要用于将对象的创建过程封装起来，客户端无需关心具体的创建细节，只需要通过工厂类获取所需对象。这样可以降低代码的耦合度，提高可维护性和可扩展性

3. 工厂模式实践

3.1 简单工厂模式

定义：通过一个工厂类，根据参数决定创建哪一种产品对象。
优点：
1. 客户端只需传递参数，不需关心具体产品类，降低了耦合。
2. 实现简单，适合产品种类较少的场景。
缺点：
1. 工厂类职责过重，随着产品扩展，工厂代码变得复杂且难以维护。
2. 不符合开闭原则，每新增产品都需修改工厂类。

java 复制代码

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

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

// 具体产品B
public class ProductB 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 ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("未知产品类型");
        }
    }
}

//使用，调用
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();

        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

3.2 工厂方法模式

定义：定义一个工厂接口，每个具体产品对应一个具体工厂类，由具体工厂类负责创建对应产品对象。
优点：
1. 满足开闭原则，新增产品只需新增具体工厂和产品类，无需修改原有代码。
2. 客户端可灵活选择具体工厂，适合产品种类较多、变化频繁的场景。
缺点：
1. 增加了系统类的数量，结构较为复杂。
2. 客户端需了解每个工厂的作用。

java 复制代码

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

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

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

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

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

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

// 使用与调用
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

3.3 抽象工厂模式

定义：提供一个创建一系列相关或依赖对象的接口，无需指定具体类。
优点：
1. 可创建多系列产品，保证同一系列产品的兼容性。
2. 满足开闭原则，适合产品族复杂、变化频繁的场景。
缺点：
1. 增加系统复杂度，类和接口数量更多。
2. 新增产品族时需修改抽象工厂接口，扩展性有限。

java 复制代码

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

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

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

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

// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product createProductA() {
        return new ProductA1();
    }
    @Override
    public Product createProductB() {
        return new ProductB1();
    }
}

// 使用与调用
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        Product productA = factory.createProductA();
        productA.use();

        Product productB = factory.createProductB();
        productB.use();
    }
}

区别：

模式	适用场景	优点	缺点
简单工厂	产品种类较少	实现简单，易于使用	不符合开闭原则，工厂类复杂
工厂方法	产品种类较多，变化频繁	满足开闭原则，扩展性好	类数量增多，结构复杂
抽象工厂	产品族复杂，系列多	可创建多系列产品，兼容性好	扩展产品族需修改接口，复杂

4. 框架中的工厂模式源码

简单工程模式：Spring 的 BeanFactory，通过名称创建 bean

工厂方法模式：Spring 的 FactoryBean 接口体现了工厂方法模式。用户可以自定义工厂 bean，通过 getObject() 方法返回实际 bean 实例。

自定义工厂方法，该方法可以返回用户自己的bean

抽象工厂模式：

ApplicationContext是一个抽象工程

AnnotationConfigApplicationContext实现了ApplicationContext，并可以创建各种不同的bean，可以一次性创建和管理多个相关 bean，体现了抽象工厂模式的产品族思想。