使用工厂模式时Spring Boot组件无法自动注入的解决方案咨询

方案1：让工厂成为Spring Bean，构造注入传递依赖 #

核心思路是让工厂由Spring管理，注入所需依赖后，仅在创建需要依赖的Notification实例时通过构造函数传递依赖，无需修改接口和不需要依赖的实现类。

代码调整： #

1. 修改需要依赖的实现类（如EmailNotification），添加构造函数接收Environment：

public class EmailNotification implements Notification {
    private final Environment env;

    public EmailNotification(Environment env) {
        this.env = env;
    }

    @Override
    public void notifyUser() {
        String emailHost = env.getProperty("email.host");
        System.out.println("Sending an e-mail notification via " + emailHost);
    }
}

2. 将NotificationFactory标记为Spring Bean，构造注入Environment：

@Component
public class NotificationFactory {
    private final Environment env;

    public NotificationFactory(Environment env) {
        this.env = env;
    }

    public Notification createNotification(String channel) {
        if (channel == null || channel.isEmpty())
            return null;
        switch (channel) {
            case "SMS":
                return new SMSNotification();
            case "EMAIL":
                return new EmailNotification(env); // 仅给需要的实例传依赖
            case "PUSH":
                return new PushNotification();
            default:
                throw new IllegalArgumentException("Unknown channel " + channel);
        }
    }
}

3. 修改NotificationService，注入工厂而非手动实例化：

@Service
public class NotificationService {
    private final NotificationFactory notificationFactory;

    public NotificationService(NotificationFactory notificationFactory) {
        this.notificationFactory = notificationFactory;
    }

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        NotificationService service = context.getBean(NotificationService.class);
        Notification notification = service.notificationFactory.createNotification("EMAIL");
        notification.notifyUser();
    }
}

优点：仅修改需要依赖的类，接口无需变更，新增依赖时仅需调整对应实现类和工厂的对应分支，不影响其他实现。

方案2：将所有Notification实现类注册为Spring Bean #

让Spring管理所有Notification实例，工厂通过Spring容器获取实例，依赖注入由Spring自动处理，无需手动传递参数。

代码调整： #

1. 给每个Notification实现类添加@Component注解，指定Bean名称匹配渠道：

@Component("SMS")
public class SMSNotification implements Notification {
    @Override
    public void notifyUser() {
        System.out.println("Sending an SMS notification");
    }
}

@Component("EMAIL")
public class EmailNotification implements Notification {
    @Autowired
    private Environment env; // Spring管理实例，注入有效

    @Override
    public void notifyUser() {
        String emailHost = env.getProperty("email.host");
        System.out.println("Sending an e-mail notification via " + emailHost);
    }
}

@Component("PUSH")
public class PushNotification implements Notification {
    @Override
    public void notifyUser() {
        System.out.println("Sending a push notification");
    }
}

2. 改造工厂，通过Spring自动注入的Map获取所有Notification实例：

@Component
public class NotificationFactory {
    private final Map<String, Notification> notificationMap;

    // Spring自动将所有Notification类型的Bean注入Map，key为Bean名称
    public NotificationFactory(Map<String, Notification> notificationMap) {
        this.notificationMap = notificationMap;
    }

    public Notification createNotification(String channel) {
        if (channel == null || channel.isEmpty())
            return null;
        Notification notification = notificationMap.get(channel);
        if (notification == null) {
            throw new IllegalArgumentException("Unknown channel " + channel);
        }
        return notification;
    }
}

3. NotificationService同样注入工厂使用：

@Service
public class NotificationService {
    private final NotificationFactory notificationFactory;

    public NotificationService(NotificationFactory notificationFactory) {
        this.notificationFactory = notificationFactory;
    }

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        NotificationService service = context.getBean(NotificationService.class);
        Notification notification = service.notificationFactory.createNotification("EMAIL");
        notification.notifyUser();
    }
}

优点：依赖注入完全交由Spring处理，工厂无需维护依赖传递逻辑，新增Notification实现类仅需添加@Component，扩展性极强。
注意：默认Spring Bean为单例，若需要每次创建新实例，可给实现类添加@Scope("prototype")。

方案3：封装依赖上下文（复杂依赖场景） #

若未来需要新增多个不同依赖，可将依赖封装为一个上下文类，避免工厂方法参数膨胀。

代码示例： #

1. 创建依赖上下文类：

public class NotificationContext {
    private final Environment env;
    // 未来新增的依赖可在此扩展，如MailSender、SmsSender等
    private final MailSender mailSender;

    public NotificationContext(Environment env, MailSender mailSender) {
        this.env = env;
        this.mailSender = mailSender;
    }

    // Getter方法
    public Environment getEnv() { return env; }
    public MailSender getMailSender() { return mailSender; }
}

2. 让需要依赖的实现类接收上下文：

public class EmailNotification implements Notification {
    private final NotificationContext context;

    public EmailNotification(NotificationContext context) {
        this.context = context;
    }

    @Override
    public void notifyUser() {
        Environment env = context.getEnv();
        MailSender sender = context.getMailSender();
        // 使用依赖完成业务逻辑
    }
}

3. 工厂注入上下文并传递：

@Component
public class NotificationFactory {
    private final NotificationContext context;

    public NotificationFactory(NotificationContext context) {
        this.context = context;
    }

    public Notification createNotification(String channel) {
        switch (channel) {
            case "EMAIL":
                return new EmailNotification(context);
            // 其他分支...
            default:
                throw new IllegalArgumentException("Unknown channel " + channel);
        }
    }
}

优点：统一管理所有可能的依赖，避免多次修改方法签名；
注意：需保持上下文职责单一，避免过度封装成“上帝类”。

内容的提问来源于stack exchange，提问作者Soph_dev