运行时通过Guice获取的单例如何作为静态常量优雅实现？

首先需要明确：你担心方案1构造注入的性能损耗完全是不必要的。Guice对@Singleton作用域的依赖注入开销极低，每次创建SenderWrapper时注入两个已初始化好的单例，仅相当于两次对象引用赋值，完全不会成为性能瓶颈，哪怕是每秒数万请求的高并发场景也感知不到这部分开销。

首选方案：构造函数注入（符合DI规范，可测试性最强） #

这是最符合依赖注入设计原则的实现，没有隐式依赖，单元测试时可以直接mock两个Sender实例传入，不需要处理静态资源，代码可读性和可维护性最高。
实现代码如下：

public class SenderWrapper implements ISenderWrapper {
    // 用final修饰，保证初始化后不可修改
    private final Sender senderA;
    private final Sender senderB;

    @Inject
    public SenderWrapper(@Named("senderA") Sender senderA, @Named("senderB") Sender senderB) {
        this.senderA = senderA;
        this.senderB = senderB;
    }

    public void dummyMethod() {
        senderA.send();
        senderB.send();
    }
}

// Guice 模块绑定
public class SenderModule extends AbstractModule {
    @Override
    protected void configure() {
        // 两个Sender绑定为单例
        bind(Sender.class).annotatedWith(Names.named("senderA")).to(SenderA.class).in(Singleton.class);
        bind(Sender.class).annotatedWith(Names.named("senderB")).to(SenderB.class).in(Singleton.class);
        // SenderWrapper默认每次注入生成新实例，符合你每请求一个的要求
        bind(ISenderWrapper.class).to(SenderWrapper.class);
    }
}

备选方案：静态持有容器（适合多场景复用Sender，减少重复注入） #

如果项目中大量地方都要用到这两个Sender，到处注入太繁琐，可以选择这个方案，既解决了原方案2静态变量可修改的问题，也不需要滥用枚举：
实现代码如下：

// 单独的Sender持有类，不对外暴露修改权限
public final class SenderHolder {
    private static Sender senderA;
    private static Sender senderB;

    // 私有构造，禁止实例化该工具类
    private SenderHolder() {}

    // 仅允许在Guice初始化阶段调用一次，防止重复赋值
    public static void init(Sender a, Sender b) {
        if (senderA != null || senderB != null) {
            throw new IllegalStateException("SenderHolder不可重复初始化");
        }
        senderA = a;
        senderB = b;
    }

    // 对外仅暴露get方法，无set方法，杜绝运行时修改
    public static Sender getSenderA() {
        return senderA;
    }

    public static Sender getSenderB() {
        return senderB;
    }
}

// Guice模块中初始化
@Provides
@Singleton
@Named("senderA")
public Sender provideSenderA() {
    return new SenderA();
}

@Provides
@Singleton
@Named("senderB")
public Sender provideSenderB(@Named("senderA") Sender senderA) {
    Sender senderB = new SenderB();
    // 两个Sender都实例化完成后统一初始化Holder
    SenderHolder.init(senderA, senderB);
    return senderB;
}

// SenderWrapper中直接调用，无需注入
public class SenderWrapper implements ISenderWrapper {
    public void dummyMethod() {
        SenderHolder.getSenderA().send();
        SenderHolder.getSenderB().send();
    }
}

原有方案的问题说明 #

• 原方案2的核心问题是对外暴露可修改的公共静态变量，存在被业务代码误改的风险，不符合开闭原则。
• 原枚举方案属于语义滥用，枚举的设计初衷是表示固定的枚举值，用来持有业务服务实例会降低代码可读性，且单元测试时替换mock实例非常麻烦。

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