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

一、原理

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

在 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 Computer
Smart Phone
Laptop Computer
Tablet

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

七、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个设计模式，特点和使用场景汇总整理！】