实际开发中常用的设计模式--------工厂模式（知识跟业务场景结合）-----小白也能看懂（通俗易懂版本）

本文链接：https://blog.csdn.net/qq_51711443/article/details/131572315

1.工厂模式的定义
工厂模式是一种创建型设计模式，它提供了一种将对象的创建过程封装起来的方式。在工厂模式中，我们定义一个抽象工厂类或接口，并且在该类或接口中定义一个用于创建对象的方法。然后我们可以通过实现该工厂类或接口来创建不同类型的对象。

使用工厂模式可以有效地避免代码重复
2.工厂模式场景
以制作披萨为例来说明工厂模式。

假设我们有一个披萨店，它可以制作不同种类的披萨，例如芝士披萨、意大利辣香肠披萨等。每种披萨都有自己独特的配料和制作方法。

如果我们想要添加一种新的披萨类型，或者修改某种披萨的配料和制作方法，那么直接在代码中进行修改将会非常麻烦。此时，工厂模式就可以派上用场了。

我们可以定义一个名为 Pizza 的抽象类，并且定义多个方法用于制作披萨。然后分别创建不同类型的具体子类，并且分别实现相应的制作方法。

接着我们定义一个名为 SimplePizzaFactory 的简单工厂类，并且在其中定义一个名为 createPizza() 的方法用于根据不同类型的参数来创建不同类型的披萨对象。

最后，在客户端中通过调用 SimplePizzaFactory.createPizza() 方法来创建不同类型的披萨对象即可完成相应操作。

// 定义披萨类
public abstract class Pizza {
    public void prepare() {
        System.out.println("Preparing " + this.getClass().getSimpleName());
    }

    public void bake() {
        System.out.println("Baking " + this.getClass().getSimpleName());
    }

    public void cut() {
        System.out.println("Cutting " + this.getClass().getSimpleName());
    }

    public void box() {
        System.out.println("Boxing " + this.getClass().getSimpleName());
    }
}

// 定义芝士披萨类
public class CheesePizza extends Pizza {}

// 定义意大利辣香肠披萨类
public class PepperoniPizza extends Pizza {}

// 简单工厂类，用于创建不同类型的披萨对象
public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        if (type.equals("cheese")) { // 如果参数为"cheese"，则创建芝士披萨对象并返回
            return new CheesePizza();
        } else if (type.equals("pepperoni")) { // 如果参数为"pepperoni"，则创建意大利辣香肠披萨对象并返回
            return new PepperoniPizza();
        } else { // 如果参数无效，则抛出异常
            throw new IllegalArgumentException("Invalid pizza type: " + type);
        }
    }
}

// 披萨店类，用于接收客户订单并制作相应的披萨
public class PizzaStore {
    private final SimplePizzaFactory factory; // 使用简单工厂类来创建不同类型的披萨

    public PizzaStore(SimplePizzaFactory factory) { // 构造函数接收一个简单工厂对象作为参数
        this.factory = factory;
    }

    public Pizza orderPizza(String type) { // 接收客户订单，并根据订单类型来制作相应的披萨
        Pizza pizza = factory.createPizza(type); // 使用简单工厂对象来创建相应类型的披萨

        pizza.prepare(); // 制作过程中调用相应方法进行准备、烘焙、切割和装盒等操作
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza; // 返回制作好的披萨对象给客户端使用
    }
}

在上述代码中，我们首先定义了一个名为 Pizza 的抽象类，并且定义了多个方法用于制作披萨。然后分别创建了两个具体子类 CheesePizza 和 PepperoniPizza，并且分别实现了相应的制作方法。

接着我们定义了一个名为 SimplePizzaFactory 的简单工厂类，并且在其中定义了一个名为 createPizza() 的方法用于根据不同类型的参数来创建不同类型的披萨对象。

最后，在客户端中通过调用 SimplePizzaFactory.createPizza() 方法来创建不同类型的披萨对象即可完成相应操作。同时，在 PizzaStore 类中也使用了该工厂模式来组织复杂业务流程。
3.应用：数据库连接

public interface Connection {
    void connect();
}

public class MySqlConnection implements Connection {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL database");
    }
}

public class OracleConnection implements Connection {
    @Override
    public void connect() {
        System.out.println("Connecting to Oracle database");
    }
}

public enum DatabaseType {
    MYSQL,
    ORACLE
}

public class ConnectionFactory {
    public static Connection createConnection(DatabaseType type) {
        switch (type) {
            case MYSQL:
                return new MySqlConnection();
            case ORACLE:
                return new OracleConnection();
            default:
                throw new IllegalArgumentException("Invalid database type: " + type);
        }
    }
}

在上述代码中，我们首先定义了一个名为 Connection 的接口，并且定义了一个名为 connect() 的方法用于连接数据库。然后分别创建了两个实现类 MySqlConnection 和 OracleConnection，并且分别实现了相应的连接方法。

接着我们定义了一个名为 DatabaseType 的枚举类型，用于表示不同类型的数据库。

最后，在客户端中通过调用 ConnectionFactory.createConnection() 方法来创建不同类型的数据库连接对象即可完成相应操作。例如：

// 客户端代码
Connection mysql = ConnectionFactory.createConnection(DatabaseType.MYSQL);
mysql.connect();

Connection oracle = ConnectionFactory.createConnection(DatabaseType.ORACLE);
oracle.connect();

在上述代码中，我们通过调用 ConnectionFactory.createConnection() 方法来创建不同类型的数据库连接对象，并且调用其 connect() 方法即可完成相应操作

4.Spring工厂模式的应用

Spring 通过使用工厂模式来创建和管理 Bean 对象实例
下面是一个使用 Spring 创建对象实例的示例代码：

1.首先，在配置文件中定义一个工厂类。例如：

<bean id="myFactory" class="com.example.MyFactory">
</bean>

2.然后，在工厂类中定义一个用于创建对象实例的方法。例如：

public class MyFactory {
    public MyObject createMyObject() {
        return new MyObject();
    }
}

3.最后，在客户端中通过调用工厂对象的创建方法来创建不同类型的对象实例。例如：

<bean id="myObject" factory-bean="myFactory" factory-method="createMyObject">
</bean>

在上述代码中，我们首先定义了一个名为 myFactory 的 Bean 实例，并且指定其类型为 MyFactory。然后在 MyFactory 类中定义了一个名为 createMyObject() 的方法，用于创建 MyObject 对象实例。

最后，在客户端中我们使用标签并且指定其属性值 factory-bean 为 “myFactory”，表示该 Bean 实例由名为 myFactory 的工厂类所创建；同时还指定其属性值 factory-method 为 “createMyObject”，表示调用该工厂类的方法来创建对应类型的对象实例。

通过使用工厂模式和依赖注入技术，Spring 可以方便地组织复杂业务流程，并且使得程序更加灵活和易于维护。同时也可以提高程序可读性和可扩展性。