Spring Boot 3与工厂模式实践

前言

在本篇博客中，我们将讨论如何在Spring Boot 3中使用工厂模式进行开发。实际上，Spring框架本身就是一个巨大的工厂模式的实现。但在开发过程中，我们仍可能需要自定义一些工厂来满足特定的业务需求。

工厂模式是一种创建型设计模式，该模式提供了一种封装对象创建复杂性的方式。在Spring Boot中使用工厂模式可以帮助我们更好地进行解耦，提高代码重用性，提高系统的灵活性和可维护性。

实现

下面是一个简单的示例，演示如何使用工厂模式在Spring Boot中创建对象：
定义一个抽象的接口或类：

1
2
3
public interface Product {
    void produce();
}

定义不同的具体产品类：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ConcreteProduct1 implements Product {
    @Override
    public void produce() {
        System.out.println("Producing product 1");
    }
}

public class ConcreteProduct2 implements Product {
    @Override
    public void produce() {
        System.out.println("Producing product 2");
    }
}

定义一个工厂类，根据不同的条件创建对应的产品对象：

1
2
3
4
5
6
7
8
9
10
11
public class ProductFactory {
    public Product createProduct(String type) {
        if ("1".equals(type)) {
            return new ConcreteProduct1();
        } else if ("2".equals(type)) {
            return new ConcreteProduct2();
        }
        throw new IllegalArgumentException("Invalid product type: " + type);
    }
}

在Spring Boot应用程序中使用工厂类创建对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        
        ProductFactory factory = new ProductFactory();
        
        Product product1 = factory.createProduct("1");
        product1.produce(); // Output: Producing product 1
        
        Product product2 = factory.createProduct("2");
        product2.produce(); // Output: Producing product 2
    }
}

开发例子

支付方式选择工厂

假设我们需要开发一个电商系统，该系统支持多种支付方式，如信用卡支付、支付宝支付、微信支付等。每种支付方式的处理逻辑可能都不同，此时我们可以使用工厂模式来管理这些支付方式。

首先，定义一个支付接口 Payment：

1
2
3
4
public interface Payment {
    void pay();
}

然后，实现具体的支付方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class CreditCardPayment implements Payment {
    @Override
    public void pay() {
        System.out.println("Processing credit card payment...");
    }
}

public class AlipayPayment implements Payment {
    @Override
    public void pay() {
        System.out.println("Processing Alipay payment...");
    }
}

public class WechatPayment implements Payment {
    @Override
    public void pay() {
        System.out.println("Processing WeChat payment...");
    }
}

接下来，创建支付方式工厂 PaymentFactory：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class PaymentFactory {
    private Map<String, Payment> paymentMap;

    @Autowired
    public PaymentFactory(List<Payment> payments) {
        paymentMap = payments.stream()
                .collect(Collectors.toMap(payment -> payment.getClass().getSimpleName(), payment -> payment));
    }

    public Payment getPayment(String type) {
        return paymentMap.get(type);
    }
}

在这里，Spring会自动将所有实现了Payment接口的bean注入到PaymentFactory中，然后我们将这些bean存储到一个Map中，键是bean的类名，值是bean本身。

最后，我们可以在需要的地方使用PaymentFactory来获取并使用具体的支付方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class PaymentService {
    @Autowired
    private PaymentFactory paymentFactory;

    public void processPayment(String type) {
        Payment payment = paymentFactory.getPayment(type);
        if (payment != null) {
            payment.pay();
        } else {
            System.out.println("Invalid payment type: " + type);
        }
    }
}

报表生成器工厂

假设我们需要生成多种类型的报表，如PDF报表、Excel报表、CSV报表等。每种报表的生成逻辑可能都不同，此时我们可以使用工厂模式来管理这些报表生成器。

首先，定义一个报表生成器接口 ReportGenerator：

1
2
3
4
public interface ReportGenerator {
    void generate();
}

然后，实现具体的报表生成器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class PdfReportGenerator implements ReportGenerator {
    @Override
    public void generate() {
        System.out.println("Generating PDF report...");
    }
}

public class ExcelReportGenerator implements ReportGenerator {
    @Override
    public void generate() {
        System.out.println("Generating Excel report...");
    }
}

public class CsvReportGenerator implements ReportGenerator {
    @Override
    public void generate() {
        System.out.println("Generating CSV report...");
    }
}

接下来，创建报表生成器工厂 ReportGeneratorFactory：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class ReportGeneratorFactory {
    private Map<String, ReportGenerator> generatorMap;

    @Autowired
    public ReportGeneratorFactory(List<ReportGenerator> generators) {
        generatorMap = generators.stream()
                .collect(Collectors.toMap(generator -> generator.getClass().getSimpleName(), generator -> generator));
    }

    public ReportGenerator getGenerator(String type) {
        return generatorMap.get(type);
    }
}

最后，我们可以在需要的地方使用ReportGeneratorFactory来获取并使用具体的报表生成器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class ReportService {
    @Autowired
    private ReportGeneratorFactory generatorFactory;

    public void generateReport(String type) {
        ReportGenerator generator = generatorFactory.getGenerator(type);
        if (generator != null) {
            generator.generate();
        } else {
            System.out.println("Invalid report type: " + type);
        }
    }
}

这样，无论我们需要添加多少种支付方式或报表类型，都只需要添加相应的实现类，并在工厂中注册即可，无需修改业务逻辑代码，这就是工厂模式的魅力。

总结

希望以上的例子能够帮助你理解如何在Spring Boot中使用工厂模式。在实际的项目开发中，工厂模式是非常常用的一种设计模式，掌握好它能够帮助我们设计出更加灵活、可维护的系统。

本篇文章由AI生成