设计模式-第二课-三种工厂模式

• 简单工厂模式 (Simple Factory Pattern)

简单工厂模式是一种创建型设计模式，它提供了一个工厂类来创建对象，将对象的创建过程封装起来，客户端只需要通过传递不同的参数来获得不同的对象。

简单工厂模式包含以下角色：

• 工厂类 (Factory)：负责创建对象的类，根据客户端传递的参数创建不同的对象。
• 抽象产品类 (Product)：定义产品的接口，由具体产品类实现。
• 具体产品类 (Concrete Product)：实现抽象产品类的接口，是工厂类创建的对象。

示例代码：

interface Product { 
    void use(); 
} 
class ConcreteProductA implements Product {
     @Override
     public void use() {
         System.out.println("Using ConcreteProductA");
     }
}
 class ConcreteProductB implements Product {
     @Override
     public void use() {
         System.out.println("Using ConcreteProductB");
     }
 }
 class Factory {
 public static Product createProduct(String productType) {
     switch (productType) { 
        case "A": 
            return new ConcreteProductA();
        case "B": 
            return new ConcreteProductB();
        default: 
            throw new IllegalArgumentException("Invalid product type"); 
        }
     }
 } 

// 客户端代码 
Product productA = Factory.createProduct("A"); 
productA.use(); 
Product productB = Factory.createProduct("B"); 
productB.use();

• 工厂模式 (Factory Pattern)

工厂模式是一种创建型设计模式，它定义了一个创建对象的接口，由子类决定实例化哪一个类，将对象的创建和使用分离开来，使得系统更加灵活和可扩展。

工厂模式包含以下角色：

• 工厂接口 (Factory)：定义了创建对象的方法，由具体工厂类实现。
• 抽象产品类 (Product)：定义产品的接口，由具体产品类实现。
• 具体工厂类 (Concrete Factory)：实现工厂接口，负责创建具体产品的对象。
• 具体产品类 (Concrete Product)：实现抽象产品类的接口，是工厂类创建的对象。

示例代码：

interface Product {
    void use();
}

class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

interface Factory {
    Product createProduct();
}

class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
    // 客户端代码 
    Factory factoryA = new ConcreteFactoryA();
    Product productA = factoryA.createProduct(); 
    productA.use();
    Factory factoryB=new ConcreteFactoryB();
    Product productB=factoryB.createProduct();
    productB.use();

• 抽象工厂模式 (Abstract Factory Pattern)

抽象工厂模式是一种创建型设计模式，它提供了一种方式来封装一组具有相同主题的单独工厂。在正常使用中，客户端不需要知道它使用的是哪个具体工厂，因为客户端仅使用它们的通用接口。这使得客户端从具体工厂中解耦，因此不会受到更改的影响。

抽象工厂模式包含以下角色：

• 抽象工厂 (Abstract Factory)：定义了一组工厂方法来创建一系列相关或相互依赖的对象。
• 具体工厂类 (Concrete Factory)：实现抽象工厂接口，负责创建一组具体产品对象。
• 抽象产品类 (Abstract Product)：定义了产品的接口，由具体产品类实现。
• 具体产品类 (Concrete Product)：实现抽象产品类的接口，是具体工厂类创建的对象。

interface Button {
    void click();
}

class WindowsButton implements Button {
    @Override
    public void click() {
        System.out.println("Windows button clicked");
    }
}

class MacButton implements Button {
    @Override
    public void click() {
        System.out.println("Mac button clicked");
    }
}

interface GUIFactory {
    Button createButton();
}

class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
}

class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }
}

class Application {
    private Button button;

    public Application(GUIFactory factory) {
        this.button = factory.createButton();
    }

    public void run() {
        button.click();
    }
}

// 客户端代码
GUIFactory windowsFactory = new WindowsFactory();
Application windowsApp = new Application(windowsFactory);
windowsApp.run();

GUIFactory macFactory = new MacFactory();
Application macApp = new Application(macFactory);
macApp.run();

在以上示例中，抽象工厂是GUIFactory，具体工厂是WindowsFactory和MacFactory，抽象产品是Button，具体产品是WindowsButton和MacButton。客户端代码中创建了两个应用程序，分别使用Windows和Mac工厂创建按钮，这样就可以根据需要动态更改GUI工厂，而不必修改应用程序的代码。

• 三种工厂模式不同场景下有不同的应用

        简单工厂模式适用于创建的对象较少且固定的情况，客户端只需要知道所需产品的名称或类型，而无需知道创建产品的具体过程。例如在图形化用户界面中，根据传入的参数创建不同类型的控件。

        工厂方法模式适用于客户端需要扩展或修改对象创建过程的情况。该模式通过将对象的创建委托给子类来实现客户端与具体类之间的解耦。例如在日志记录器中，客户端可以通过配置文件或其他方式指定所需的日志记录器类型。

        抽象工厂模式适用于创建一组相关对象的情况，这些对象之间存在一定的约束关系，例如在图形用户界面中，窗口、按钮、文本框等控件之间的约束关系。抽象工厂模式通过提供一个工厂接口，客户端代码只需要依赖于这个接口，就可以创建一组相关的对象，而不需要关心对象的具体实现

• Spring中三种工厂的应用

        Spring中最常用的简单工厂模式是BeanFactory和ApplicationContext，它们都负责创建和管理Bean对象。在Spring中，BeanFactory是一个基础接口，它定义了一些基本的方法，如getBean()方法，用于获取Bean对象。Spring提供了多个实现类来实现BeanFactory接口，如XmlBeanFactory、DefaultListableBeanFactory等，这些实现类都是通过反射来实现Bean的创建。

        在Spring中，工厂方法模式常常被用于解决依赖注入的问题。依赖注入（DI）是Spring框架的核心功能之一，它允许开发者通过配置文件或者注解的方式，将对象之间的依赖关系交由Spring容器管理。在实现依赖注入的过程中，工厂方法模式是一个很好的选择。

在Spring中，使用工厂方法模式创建Bean对象时，通常会定义一个工厂接口和多个工厂实现类。工厂接口负责定义工厂方法，用于创建Bean对象，而工厂实现类则实现了工厂接口，并负责创建具体的Bean对象。在使用时，Spring容器会根据配置文件或者注解的信息来选择使用哪个工厂实现类来创建Bean对象。

        抽象工厂模式在Spring中的应用也很广泛，其中最常见的是数据访问层（DAO）的实现。Spring为不同的数据访问场景提供了多个不同的模板类，如JdbcTemplate、NamedParameterJdbcTemplate等。这些模板类都是通过同一个JdbcOperations接口实现的，因此客户端代码只需要依赖于JdbcOperations接口即可，而无需关心具体实现类。在具体的应用场景中，Spring会根据配置文件或者注解的信息，选择合适的模板类来创建DAO对象，从而实现数据的访问。