工厂方法模式：打造灵活对象创建机制

工厂方法模式概述

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，这种模式提供了一个用于创建对象的接口，并让子类决定实例化哪一个类。在工厂方法模式中，我们不直接调用一个类的构造函数来获取对象，而是通过一个工厂类来完成对象的创建工作，这样做的好处是系统更加灵活，添加新产品时也无需修改原有代码。

优点

• 降低耦合度：客户端代码无需知道具体的产品类，只需要关心产品的接口。
• 增加系统的灵活性：新加入一个产品，只需要加入具体的产品类和相对应的工厂类即可。
• 扩展性良好：在现有系统中添加新的产品类型时，无需修改现有的工厂逻辑。

实现方式

在Java中，我们通常是这样来实现工厂方法模式的：

// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 工厂接口
public interface Factory {
    Product createProduct();
}

// 具体工厂A
public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

在Spring Boot中的应用场景

场景一：动态切换数据源

在Spring Boot应用中，你可能需要连接到不同的数据库，这时候就可以使用到工厂方法模式。

public interface DataSourceFactory {
    DataSource createDataSource();
}

@Component
public class MySQLDataSourceFactory implements DataSourceFactory {
    @Override
    public DataSource createDataSource() {
        return new CustomDataSource(/* MySQL的配置参数 */);
    }
}

@Component
public class OracleDataSourceFactory implements DataSourceFactory {
    @Override
    public DataSource createDataSource() {
        return new CustomDataSource(/* Oracle的配置参数 */);
    }
}

然后在需要数据源的地方注入相应的工厂：

@Service
public class DataService {
    private final DataSource dataSource;
    
    @Autowired
    public DataService(DataSourceFactory dataSourceFactory) {
        this.dataSource = dataSourceFactory.createDataSource();
    }
    
    // 使用dataSource的方法
}

场景二：生成不同类型的报告

假设有一个应用需要生成不同类型的报告，如PDF报告、Excel报告等。

public interface Report {
    void generate();
}

public class PDFReport implements Report {
    @Override
    public void generate() {
        // 生成PDF报告的逻辑
    }
}

public class ExcelReport implements Report {
    @Override
    public void generate() {
        // 生成Excel报告的逻辑
    }
}

public interface ReportFactory {
    Report createReport();
}

@Component
public class PDFReportFactory implements ReportFactory {
    @Override
    public Report createReport() {
        return new PDFReport();
    }
}

@Component
public class ExcelReportFactory implements ReportFactory {
    @Override
    public Report createReport() {
        return new ExcelReport();
    }
}

@Service
public class ReportService {
    private final ReportFactory reportFactory;
    
    @Autowired
    public ReportService(ReportFactory reportFactory) {
        this.reportFactory = reportFactory;
    }
    
    public void generateReport() {
        Report report = reportFactory.createReport();
        report.generate();
    }
}

在这个例子中，ReportService 不需要知道具体的报告类型。它只是要求一个实现了 Report 接口的对象，具体是PDF报告还是Excel报告，由注入的 ReportFactory 决定。

总结

工厂方法模式是Java设计模式中的基石之一，它在Spring Boot中广泛应用于生成服务实例、配置类实例等。利用Spring框架的依赖注入和控制反转特性，工厂方法模式的实现变得更加直观且简洁，在增强代码的灵活性和可维护性方面起着至关重要的作用。每个使用Spring Boot的Java工程师都应该掌握这个强大的工具。