工厂模式是一种创建型设计模式，它的目的是为客户端创建对象提供一个统一的接口，隐藏对象的创建细节并将其委托给一个子类来处理。在工厂模式中，我们不直接调用构造函数来创建对象，而是调用工厂方法来创建对象。

一、原理

工厂模式的主要目的是将对象的创建与使用相分离，并封装对象创建过程中的细节，从而使得代码更具有扩展性和灵活性。

在 Java 中，工厂模式通常由一个工厂类或者一组工厂类来实现。这些工厂类负责创建某个产品或产品族的对象，而客户端只需要调用工厂类的方法即可获取所需的对象。

二、使用场景

通常情况下，工厂模式适用于以下场景：

1、多个子类共同实现一个接口时：当多个子类具有相同的方法，但是这些子类需要根据不同的情况返回不同的实例时，可以采用工厂模式。在这种情况下，工厂类可以根据特定的条件，返回不同的实例。

2、对象的创建过程比较复杂时：当对象的创建过程比较复杂，需要经过多个步骤时，可以采用工厂模式。在这种情况下，工厂类可以将对象的创建过程封装起来，从而提高了代码的可读性和可维护性。

3、需要动态地指定创建哪个实例时：当需要根据运行时的情况来决定创建哪个实例时，可以采用工厂模式。在这种情况下，工厂类可以根据不同的条件，返回不同的实例。

4、降低代码的耦合度时：当需要降低代码的耦合度时，可以采用工厂模式。在这种情况下，工厂类可以负责对象的创建和销毁，从而降低了不同模块之间的耦合度。

三、工厂模式的分类

在 Java 中，工厂模式一般可以分为三种，它们分别是：

1、简单工厂模式（Simple Factory Pattern）：也称为静态工厂模式，将对象的创建过程封装在一个静态方法中，客户端通过传入相应的参数来选择要创建的对象。这种模式比较简单易用，但是也存在一定的局限性，例如不支持拓展和维护。

2、工厂方法模式（Factory Method Pattern）：定义一个抽象的工厂类，具体的对象创建过程由其子类实现。客户端仅需要知道抽象工厂类和相应的产品接口即可，而具体的对象实现细节被封装在不同的子类中。这种模式具有较好的灵活性和可拓展性。

3、抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，其中每个工厂类负责创建一类产品。与工厂方法模式相比，抽象工厂模式可以同时创建多个产品系列，具有更高的抽象层次和更高的复杂度。

除了这三种基本的工厂模式之外，还有一些变种和衍生模式，例如工厂模式和单例模式的结合、工厂模式和策略模式的结合等。根据具体的业务需求和系统设计，我们可以选择不同类型的工厂模式来实现相应的功能。

四、简单工厂模式示例代码

我们将创建一个形状（Shape）抽象类和三个具体形状（Circle、Rectangle、Square）类，以演示简单工厂模式的用法。Shape是一个抽象类，它的子类可以以不同方式实现draw方法来画出不同形状的图形。ShapeFactory是一个工厂类，它根据参数来选择要实例化的对象。

首先，定义Shape抽象类。

public abstract class Shape { public abstract void draw();}

随后，实现具体形状类Circle、Rectangle、Square。

public class Circle implements Shape { @Override public void draw() { System.out.println("Circle.draw"); }}public class Rectangle implements Shape { @Override public void draw() { System.out.println("Rectangle.draw"); }}public class Square implements Shape { @Override public void draw() { System.out.println("Square.draw"); }}

创建工厂类ShapeFactory，使用简单工厂模式，实现 getShape() 的静态方法，通过传入参数，返回不同的 Shape 实现对象实例。

public class ShapeFactory { public static Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase("CIRCLE")){ return new Circle(); } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase("SQUARE")){ return new Square(); } return null; }}

测试简单工厂模式代码。

public class FactoryPatternDemo { public static void main(String[] args) { // 获取 Circle 的对象，并调用它的 draw 方法 Shape shape1 = ShapeFactory.getShape("CIRCLE"); shape1.draw(); // 获取 Rectangle 的对象，并调用它的 draw 方法 Shape shape2 = ShapeFactory.getShape("RECTANGLE"); shape2.draw(); // 获取 Square 的对象，并调用它的 draw 方法 Shape shape3 = ShapeFactory.getShape("SQUARE"); shape3.draw(); }}

五、工厂方法模式示例代码

还是上面的示例中的 Shape抽象类 和 实现具体形状类Circle、Rectangle、Square。不同的是这次我们使用工厂方法模式，创建抽象工厂类ShapeFactory。

public abstract class ShapeFactory { public abstract Shape getShape();}

创建具体工厂类CircleFactory、RectangleFactory、SquareFactory。

public class CircleFactory extends ShapeFactory { @Override public Shape getShape() { return new Circle(); }}public class RectangleFactory extends ShapeFactory { @Override public Shape getShape() { return new Rectangle(); }}public class SquareFactory extends ShapeFactory { @Override public Shape getShape() { return new Square(); }}

ShapeFactory是一个抽象工厂类，它负责定义创建Shape对象的接口。CircleFactory、RectangleFactory、SquareFactory是具体工厂类，它们分别返回Circle、Rectangle、Square对象。

六、抽象工厂模式示例代码

在本示例代码中，我们将创建两个产品族：电脑和手机，每个产品族都有两个产品：台式电脑和笔记本电脑，手机和平板电脑。首先定义抽象产品类 Computer 和 Phone：

public interface Computer { // 打印电脑信息 void printComputerInfo();}public interface Phone { // 打印手机信息 void printPhoneInfo();}

接下来定义具体产品类 DesktopComputer、LaptopComputer、SmartPhone 和 Tablet：

public class DesktopComputer implements Computer { @Override public void printComputerInfo() { System.out.println("Desktop Computer"); }}public class LaptopComputer implements Computer { @Override public void printComputerInfo() { System.out.println("Laptop Computer"); }}public class SmartPhone implements Phone { @Override public void printPhoneInfo() { System.out.println("Smart Phone"); }}public class Tablet implements Phone { @Override public void printPhoneInfo() { System.out.println("Tablet"); }}

然后定义抽象工厂类 AbstractFactory：

public abstract class AbstractFactory { // 创建电脑 public abstract Computer createComputer(); // 创建手机 public abstract Phone createPhone();}

接下来定义具体工厂类 ComputerFactory 和 PhoneFactory：

public class ComputerFactory extends AbstractFactory { @Override public Computer createComputer() { return new DesktopComputer(); } @Override public Phone createPhone() { return new SmartPhone(); }}public class PhoneFactory extends AbstractFactory { @Override public Computer createComputer() { return new LaptopComputer(); } @Override public Phone createPhone() { return new Tablet(); }}

最后，我们可以通过创建一个具体工厂类的实例来访问工厂方法，并创建一系列相关的产品：

public class AbstractFactoryPatternDemo { public static void main(String[] args) { AbstractFactory computerFactory = new ComputerFactory(); Computer desktopComputer = computerFactory.createComputer(); Phone smartPhone = computerFactory.createPhone(); desktopComputer.printComputerInfo(); smartPhone.printPhoneInfo(); AbstractFactory phoneFactory = new PhoneFactory(); Computer laptopComputer = phoneFactory.createComputer(); Phone tablet = phoneFactory.createPhone(); laptopComputer.printComputerInfo(); tablet.printPhoneInfo(); }}

输出结果为：

Desktop ComputerSmart PhoneLaptop ComputerTablet

使用抽象工厂模式可以轻松创建一系列相关或相互依赖的对象，而无需指定其具体类。

七、SpringBoot中的工厂模式

SpringBoot 源代码中有很多使用工厂模式的例子，其中最经典的就是 BeanFactory 和ApplicationContext。这两个类都是Spring框架创建和管理bean实例的核心，它们使用了工厂模式来实现。

BeanFactory是Spring框架中最基本的bean工厂接口，它定义了Spring容器如何创建、配置和管理bean实例。在BeanFactory中，我们可以使用getBean方法根据Bean名称或类型来获取一个bean实例，如下所示：

public interface BeanFactory { ...... Object getBean(String name) throws BeansException;<T> T getBean(String name, Class<T> requiredType) throws BeansException;Object getBean(String name, Object... args) throws BeansException;<T> T getBean(Class<T> requiredType) throws BeansException;<T> T getBean(Class<T> requiredType, Object... args) throws BeansException; ......}

在 BeanFactory 的实现中，通常会使用工厂模式来创建和管理bean实例。例如，Spring 提供了一个名为 DefaultListableBeanFactory 的默认实现，它在初始化时会读取配置文件中的 bean 定义信息，并将这些信息保存到内部的 BeanDefinitionMap 中。之后，当用户调用 getBean() 方法时，它会根据Bean名称或类型从 BeanDefinitionMap 中获取bean定义信息，并使用工厂模式创建相应的 bean 实例。

八、总结

工厂模式是一种常用的设计模式，它可以将对象的创建与使用分离，提高代码的重用性和可维护性。在 Java 编程中，工厂模式被广泛应用于各种场景，如数据库连接池、日志记录器等。通过合理应用工厂模式，我们可以使代码更加灵活和易于扩展。

对于本文中的内容，不知道你有没有什么看法，欢迎在评论区里留言。如果你对我的文章内容感兴趣，欢迎点击关注，谢谢支持！[谢谢][谢谢][谢谢]

文章链接：【Java程序员必须掌握的15个设计模式，特点和使用场景汇总整理！】