设计模式-工厂模式实战

一、引言

    工厂模式是一种创建型设计模式，它提供了一种创建对象的接口，但将对象的实际创建委托给具体的子类或实现类。这允许客户端代码在不关心对象的具体类型的情况下创建对象，从而提高了代码的灵活性和可维护性。
工厂模式是一种对象创建模式，它将对象的创建过程抽象化，并将实际的创建过程推迟到子类或实现类。工厂模式包括以下关键元素：

• 工厂接口（Factory Interface）：定义创建对象的接口，通常包括一个或多个工厂方法。
• 具体工厂（Concrete Factory）：实现工厂接口的具体类，负责创建具体的产品对象。
• 产品接口（Product Interface）：定义产品对象的接口，通常包括产品的各种属性和行为。
• 具体产品（Concrete Product）：实现产品接口的具体类，由具体工厂创建。

二、适用场景

    工厂模式适用于以下情况：

1. 对象创建复杂：当对象的创建涉及复杂的初始化过程、依赖关系或决策逻辑时，工厂模式可以将创建过程封装起来。
2. 对象类型不确定：当客户端不知道所需对象的具体类型，但需要根据一些条件来创建对象时，工厂模式非常有用。
3. 遵循开闭原则：工厂模式有助于遵循开闭原则，因为您可以添加新的具体工厂或具体产品，而无需修改现有代码。

三、代码实战

简单工厂模式

简单工厂模式（Simple Factory Pattern）是工厂模式的最简单形式，它由一个工厂类负责创建对象。以下是一个简单工厂模式的示例，用于创建不同类型的几何形状：

// 产品接口
interface Shape {
   void draw();
}

// 具体产品
class Circle implements Shape {
   public void draw() {
       System.out.println("绘制圆形");
   }
}

class Rectangle implements Shape {
   public void draw() {
       System.out.println("绘制矩形");
   }
}

class Square implements Shape {
   public void draw() {
       System.out.println("绘制正方形");
   }
}

// 简单工厂
class ShapeFactory {
   public Shape createShape(String shapeType) {
       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 Client {
   public static void main(String[] args) {
       ShapeFactory factory = new ShapeFactory();

       Shape circle = factory.createShape("CIRCLE");
       circle.draw();

       Shape rectangle = factory.createShape("RECTANGLE");
       rectangle.draw();

       Shape square = factory.createShape("SQUARE");
       square.draw();
   }
}

原理：在简单工厂模式中，ShapeFactory 负责根据客户端传入的参数创建不同类型的几何形状对象。客户端代码只需通过工厂来创建对象，而无需了解对象的具体构建过程。

工厂方法模式

工厂方法模式（Factory Method Pattern）引入了工厂接口和多个具体工厂，每个具体工厂负责创建一种具体产品。以下是一个工厂方法模式的示例，用于创建不同类型的日志记录器：

// 产品接口
interface Logger {
   void log(String message);
}

// 具体产品
class ConsoleLogger implements Logger {
   public void log(String message) {
       System.out.println("Console: " + message);
   }
}

class FileLogger implements Logger {
   public void log(String message) {
       System.out.println("File: " + message);
   }
}

// 工厂接口
interface LoggerFactory {
   Logger createLogger();
}

// 具体工厂
class ConsoleLoggerFactory implements LoggerFactory {
   public Logger createLogger() {
       return new ConsoleLogger();
   }
}

class FileLoggerFactory implements LoggerFactory {
   public Logger createLogger() {
       return new FileLogger();
   }
}

// 客户端代码
public class Client {
   public static void main(String[] args) {
       LoggerFactory factory = new ConsoleLoggerFactory(); // 或 FileLoggerFactory

       Logger logger = factory.createLogger();
       logger.log("Hello, Factory Method Pattern!");
   }
}

原理：工厂方法模式引入了工厂接口 LoggerFactory 和多个具体工厂（ConsoleLoggerFactory 和 FileLoggerFactory）。每个具体工厂负责创建一种具体产品（ConsoleLogger 和 FileLogger）。客户端代码通过工厂接口来创建产品，选择具体工厂以获取所需类型的产品。

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）进一步抽象了工厂模式，它包括多个工厂接口和多个具体工厂，每个具体工厂负责创建一组相关的产品。以下是一个抽象工厂模式的示例，用于创建不同类型的按钮和窗口组合：

// 抽象产品A - 按钮
interface Button {
   void display();
}

// 具体产品A - Mac按钮
class MacButton implements Button {
   public void display() {
       System.out.println("Mac按钮");
   }
}

// 具体产品A - Windows按钮
class WindowsButton implements Button {
    public void display() {
        System.out.println("Windows按钮");
    } 
}

// 抽象产品B - 窗口
interface Window {
   void render();
}

// 具体产品B - Mac窗口
class MacWindow implements Window {
   public void render() {
       System.out.println("Mac窗口");
   }
}

// 具体产品B - Windows窗口
class WindowsWindow implements Window {
   public void render() {
       System.out.println("Windows窗口");
   }
}

// 抽象工厂接口
interface GUIFactory {
   Button createButton();
   Window createWindow();
}

// 具体工厂A - 创建Mac风格组件
class MacFactory implements GUIFactory {
   public Button createButton() {
       return new MacButton();
   }

  public Window createWindow() {
       return new MacWindow();
   }
}

// 具体工厂B - 创建Windows风格组件
class WindowsFactory implements GUIFactory {
   public Button createButton() {
       return new WindowsButton();
   }

   public Window createWindow() {
       return new WindowsWindow();
   }
}

// 客户端代码
public class Client {
   public static void main(String[] args) {
       GUIFactory factory = new MacFactory(); // 或 WindowsFactory

       Button button = factory.createButton();
       Window window = factory.createWindow();

       button.display();
       window.render();
   }
}

原理：抽象工厂模式引入了抽象工厂接口 GUIFactory 和多个具体工厂（MacFactory 和 WindowsFactory）。每个具体工厂负责创建一组相关的产品（按钮和窗口）。客户端代码通过抽象工厂接口来创建产品，选择具体工厂以获取所需类型的产品。

抽象工厂模式允许您创建一组相关的产品，例如在不同操作系统下的用户界面组件。它提供了更高级别的抽象，使得客户端代码可以独立于具体产品的创建过程。根据需要选择不同的具体工厂，以获取适用于特定环境的产品组合。

四、实际应用举例

    工厂模式在实际应用中有许多常见的场景，以下是一些典型的应用场景：

1. 数据库连接池：数据库连接池是一个常见的应用工厂模式的例子。连接池管理了数据库连接对象的创建和回收，以便在应用程序中重复使用连接，从而提高性能和减少资源消耗。
2. 日志记录器：应用程序通常需要根据配置选择使用不同的日志记录器（如控制台日志或文件日志），工厂模式可以根据配置来创建正确类型的日志记录器。
3. UI库：用户界面库可以使用工厂模式来创建不同操作系统或主题的界面组件，例如按钮、文本框和窗口。
4. 插件系统：应用程序可以使用工厂模式来动态加载和管理插件。工厂模式允许应用程序创建和初始化插件，而不需要提前知道插件的具体实现。
5. 文件格式转换器：在文件转换应用中，根据用户需求选择不同的文件格式转换器（如PDF到Word或Word到PDF），工厂模式可以根据用户选择来创建正确类型的转换器。
6. 依赖注入容器：许多依赖注入容器（如Spring和Guice）使用工厂模式来管理对象的创建和生命周期，以及依赖注入。
7. 游戏开发：游戏开发中经常需要创建不同类型的角色、武器和道具。工厂模式可以用于根据游戏场景创建相应的游戏对象。
8. 缓存管理：工厂模式可以用于管理缓存对象的创建和回收，以提高数据访问性能。

Spring中工厂模式解析

Spring的BeanFactory和ApplicationContext是工厂模式的实际应用示例，它们用于创建和管理Spring中的Bean对象。BeanFactory和ApplicationContext是Spring容器，它们负责对象的创建、配置、初始化和管理。以下是Spring中使用工厂模式的示例代码：

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class MainApp {
   public static void main(String[] args) {
       // 创建一个Resource对象，它指定了Spring配置文件的位置
       Resource resource = new ClassPathResource("beans.xml");

       // 创建一个BeanFactory，它将从配置文件中加载Bean定义
       BeanFactory factory = new XmlBeanFactory(resource);

       // 从BeanFactory中获取一个名为"myBean"的Bean对象
       MyBean myBean = (MyBean) factory.getBean("myBean");

       // 使用Bean对象
       myBean.doSomething();
   }
}

在这个示例中，BeanFactory 充当工厂，负责创建和管理Bean对象。它通过读取配置文件（beans.xml）中的Bean定义来实例化Bean。客户端代码（MainApp）只需从容器中获取所需的Bean对象，而无需关心对象的创建和初始化细节。

解释：

• BeanFactory 充当工厂接口，它定义了创建和管理Bean对象的方法。
• XmlBeanFactory 是具体工厂，它根据配置文件中的Bean定义创建实际的Bean对象。
• Resource 对象用于指定Spring配置文件的位置，通常使用ClassPathResource加载类路径下的配置文件。
  *配置文件 beans.xml 包含了Bean的定义，包括Bean的类型、属性、初始化方法等信息。
  *客户端代码 MainApp 通过容器获取所需的Bean对象，而不需要直接实例化或初始化Bean。>

这种使用工厂模式的方式使Spring框架非常灵活和可扩展。通过配置文件，您可以轻松更改应用程序中使用的Bean类型，而不必修改客户端代码。这有助于实现依赖注入、松散耦合和易于测试的应用程序架构。

五、结论

以下是工厂模式的总结和结论：
优点：

1. 解耦：工厂模式将对象的创建过程与客户端代码分离，降低了对象之间的耦合度。客户端只需关心接口或抽象类，无需了解具体实现。
2. 可维护性：如果需要更改对象的创建方式，只需修改工厂类而无需修改客户端代码，从而提高了代码的可维护性。
3. 扩展性：可以轻松添加新的具体工厂或具体产品，以满足新的需求，而无需修改现有代码。
4. 复用性：工厂模式提供了一种标准的方式来创建对象，可以在多个地方重复使用。
5. 隐藏细节：客户端代码无需了解对象的创建和初始化细节，从而降低了复杂性。

缺点和注意事项：

1. 复杂性：对于简单的对象创建，引入工厂模式可能会显得繁琐。因此，工厂模式最适用于对象创建较为复杂或需要管理的情况。
2. 过度使用：过度使用工厂模式可能导致类爆炸，因此应根据实际需求谨慎选择何时使用工厂模式。
3. 不适用于所有情况：并非所有对象的创建都需要通过工厂模式，有些对象可以直接通过构造函数或其他方式创建。

总的来说，工厂模式是一种非常有用的设计模式，用于对象的创建和管理。它提供了一种通用的方式来降低耦合度、提高可维护性和扩展性，以及隐藏对象创建的细节。在实际应用中，工厂模式常常用于创建复杂对象、依赖注入、插件系统、框架和库等场景，有助于编写可维护且具有良好设计的代码

点赞收藏，富婆包养✋✋