CDI传递服务的最佳实践：如何将Singleton服务传入自定义复杂对象？

嘿，我来帮你搞定这个问题！针对你需要在@ViewScoped的Managed Bean里创建带Singleton服务的复杂对象场景，这里有几个实用的方案：

1. 构造函数注入（推荐） #

这是最符合依赖注入原则的方式——让复杂对象在创建时就拿到所需的服务，确保对象从一开始就是完整可用的，还能避免后续的空指针问题。

首先给你的复杂对象添加一个带SimpleService和业务数据的构造函数：

public class ComplexBusinessObject {
    private final SimpleService simpleService;
    private final SomeBusinessData businessData;

    // 构造函数一次性注入依赖和数据
    public ComplexBusinessObject(SimpleService simpleService, SomeBusinessData businessData) {
        this.simpleService = simpleService;
        this.businessData = businessData;
        // 这里可以做初始化逻辑
    }

    // 你的复杂业务逻辑方法
    public void executeComplexLogic() {
        // 直接使用注入的服务处理业务
        simpleService.processData(businessData);
        // 其他复杂逻辑...
    }
}

然后在ExampleBean里直接通过构造函数创建对象：

@ManagedBean
@ViewScoped
public class ExampleBean {
    @Inject
    private SimpleService simpleService;

    public void customLogic() {
        // 先准备好业务数据
        SomeBusinessData data = new SomeBusinessData("用户输入的关键数据");
        // 传入服务和数据，创建完整的复杂对象
        ComplexBusinessObject complexObj = new ComplexBusinessObject(simpleService, data);
        // 执行业务逻辑
        complexObj.executeComplexLogic();
    }
}

2. Setter方法注入 #

如果你的复杂对象需要支持无参构造（比如序列化场景），可以用Setter方法来注入服务：

复杂对象的代码：

public class ComplexBusinessObject {
    private SimpleService simpleService;
    private SomeBusinessData businessData;

    // 无参构造
    public ComplexBusinessObject() {}

    // Setter注入服务
    public void setSimpleService(SimpleService simpleService) {
        this.simpleService = simpleService;
    }

    public void setBusinessData(SomeBusinessData businessData) {
        this.businessData = businessData;
    }

    public void executeComplexLogic() {
        // 记得做非空校验，避免NPE
        if (simpleService == null) {
            throw new IllegalStateException("SimpleService未注入，请先调用setSimpleService方法");
        }
        simpleService.processData(businessData);
    }
}

Bean里的调用逻辑：

public void customLogic() {
    SomeBusinessData data = new SomeBusinessData("用户输入的关键数据");
    ComplexBusinessObject complexObj = new ComplexBusinessObject();
    complexObj.setSimpleService(simpleService);
    complexObj.setBusinessData(data);
    complexObj.executeComplexLogic();
}

3. 工厂类封装创建逻辑 #

如果创建复杂对象的逻辑很繁琐（比如需要多个服务、多步初始化），可以抽一个工厂类来封装，让Bean的代码更简洁：

先写工厂类：

@Singleton
public class ComplexObjectFactory {
    @Inject
    private SimpleService simpleService;

    // 工厂方法负责创建并初始化复杂对象
    public ComplexBusinessObject create(SomeBusinessData businessData) {
        ComplexBusinessObject complexObj = new ComplexBusinessObject();
        complexObj.setSimpleService(simpleService);
        complexObj.setBusinessData(businessData);
        // 这里可以添加更多初始化步骤，比如注入其他服务
        return complexObj;
    }
}

然后在Bean里注入工厂，调用创建方法：

@ManagedBean
@ViewScoped
public class ExampleBean {
    @Inject
    private ComplexObjectFactory objectFactory;

    public void customLogic() {
        SomeBusinessData data = new SomeBusinessData("用户输入的关键数据");
        ComplexBusinessObject complexObj = objectFactory.create(data);
        complexObj.executeComplexLogic();
    }
}

小提醒 #

• 优先选构造函数注入，它能让对象的依赖关系更清晰，还能保证对象创建后直接可用。
• 如果你的复杂对象不需要动态传入业务数据，也可以把它做成@ViewScoped的托管Bean，但这种方式灵活性会差很多，不如手动创建+传参实用。

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