深入理解与实践Spring Boot中的工厂模式

引言

工厂模式核心思想是隐藏对象的具体创建过程，提供统一的接口进行对象的创建，从而达到解耦的目的。在springboot项目中，工 厂模式的应用有助于提高系统的灵活性和可扩展性。

工厂模式产生的背景

工厂模式诞生于解决对象创建的复杂性问题。在传统的编程实践中，如果每当需要创建不同类型的对象时，代码中充斥着大量new操作符直接实例化对象的语句，这样会导致耦合度高，不易于维护和扩展。例如，假设我们在一个系统中要根据不同条件创建不同的数据库连接，如果不采用工厂模式，每次创建连接都需要硬编码数据库驱动和连接字符串，当需要切换数据库类型或者更改连接配置时，就需要修改多处代码。

为什么使用工厂模式？

1. 解耦：工厂模式将对象的创建逻辑从使用它的客户代码中分离出来，使得代码更关注于业务逻辑本身，而不是对象如何创建。
2. 弹性与扩展性：若需新增或替换产品类（即创建的对象），只需改动工厂内部逻辑，而无需修改调用者代码，增强了系统的可维护性和可扩展性。
3. 一致性与封装：通过工厂提供的统一接口创建对象，保证了创建过程的一致性，并且隐藏了对象创建的复杂性，如初始化过程、依赖注入等。

Spring Boot中工厂模式的示例

下面展示一个在Spring Boot中应用工厂模式的例子，这里我们将创建一个简单的LanguageProcessor接口以及几个具体的语言服务实现，并通过一个工厂类来根据外部输入动态创建相应的选择语言。

定义处理器接口定义处理器接口

package com.example.demo.processor;

/**
 * @author YangDi
 * @since 2024/3/20
 */
public interface LanguageProcessor {
    void process(String languageType);
}

实现处理器接口的类

package com.example.demo.processor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @author YangDi
 * @since 2024/3/20
 */
@Component
public class EnglishProcessor implements LanguageProcessor{
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public void process(String languageType) {
        logger.info("The current selection is English!");
    }
}

package com.example.demo.processor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @author YangDi
 * @since 2024/3/20
 */
@Component
public class ChineseProcessor implements LanguageProcessor{
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public void process(String languageType) {
        logger.info("当前选择的是中文！");
    }
}

创建工厂类

package com.example.demo.factory;

import com.example.demo.processor.LanguageProcessor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author YangDi
 * @since 2024/3/20
 */
@Component
public class LanguageProcessorFactory {

    private final Map<String, LanguageProcessor> processorMap = new ConcurrentHashMap<>();

    @Autowired
    public LanguageProcessorFactory(Map<String, LanguageProcessor> beansOfType) {
        // 将所有实现了Processor接口的Bean注入到map中
        this.processorMap.putAll(beansOfType);
    }

    public LanguageProcessor getLanguageProcessor(String type) {
        return processorMap.get(type);
    }
}

控制层

package com.example.demo;

import com.example.demo.factory.LanguageProcessorFactory;
import com.example.demo.utils.result.ResultEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author YangDi
 * @since 2024/3/20
 */
@RestController
@RequestMapping("/language")
public class LanguageController {

    @Autowired
    private LanguageProcessorFactory languageProcessorFactory;

    @RequestMapping("/selectLanguage")
    public ResultEntity<String> selectLanguage(@RequestParam String languageType) {
        languageProcessorFactory.getLanguageProcessor(languageType).process(languageType);
        return ResultEntity.success("success");
    }
}

通过这种方式，我们可以轻松地添加新的Processor实现类而不必修改客户端代码，只需要确保新类也被Spring管理并实现了Processor接口即可。