如何在Guice中重新配置（重置）单例服务AccessVerifier？

问题背景 #

我打算用Google Guice重构一段遗留代码，项目里有个AccessVerifier单例服务，代码如下：

@Singleton
public class AccessVerifier {
    
    private JWTVerifier verifier;

    public AccessVerifier(String secret) {
        this.verifier = JWT.require(Algorithm.HMAC256(secret)).build();
    }

    public void setSecret(String secret){
        this.verifier = JWT.require(Algorithm.HMAC256(secret)).build();
    }

    public DecodedJWT decodeToken(String token)
    {
        DecodedJWT jwt = this.verifier.verify(token);

        // 验证token中的部分声明

        return jwt;
    }
}

我们需要定期轮换secret参数，希望能重新配置或重置该服务来初始化verifier成员。

在未使用Guice时，用传统单例实现（通过getInstance()），可以直接调用AccessVerifier.getInstance().setSecret(...)。但迁移到Guice后，希望由Guice管理实例，不想用App.getInjector().get(AccessVerifier.class).setSecret(...)这种不够优雅的方式。

我曾考虑传入Provider<String>给AccessVerifier，但不想每次调用都创建JWTVerifier，需要存储旧secret并每次调用verifier时做比较。请问还有其他实现方式吗？

可行解决方案 #

1. 引入Secret管理类封装状态 #

创建专门的SecretManager单例类，负责存储当前secret，提供更新和获取方法，再将其注入AccessVerifier，通过双重检查锁定实现仅在secret变化时更新verifier：

@Singleton
public class SecretManager {
    private volatile String currentSecret;

    @Inject
    public SecretManager(@Named("initialSecret") String initialSecret) {
        this.currentSecret = initialSecret;
    }

    public void updateSecret(String newSecret) {
        this.currentSecret = newSecret;
    }

    public String getCurrentSecret() {
        return currentSecret;
    }
}

修改AccessVerifier：

@Singleton
public class AccessVerifier {
    private final SecretManager secretManager;
    private volatile JWTVerifier verifier;
    private volatile String lastUsedSecret;

    @Inject
    public AccessVerifier(SecretManager secretManager) {
        this.secretManager = secretManager;
        this.lastUsedSecret = secretManager.getCurrentSecret();
        this.verifier = JWT.require(Algorithm.HMAC256(lastUsedSecret)).build();
    }

    public DecodedJWT decodeToken(String token) {
        String currentSecret = secretManager.getCurrentSecret();
        if (!currentSecret.equals(lastUsedSecret)) {
            synchronized (this) {
                if (!currentSecret.equals(lastUsedSecret)) {
                    this.verifier = JWT.require(Algorithm.HMAC256(currentSecret)).build();
                    this.lastUsedSecret = currentSecret;
                }
            }
        }
        DecodedJWT jwt = this.verifier.verify(token);
        // 验证token中的部分声明
        return jwt;
    }
}

后续更新secret时，只需注入SecretManager调用updateSecret即可：

// 在需要更新的业务逻辑中
@Inject
private SecretManager secretManager;

// 执行更新
secretManager.updateSecret(newSecret);

2. 封装带缓存的JWTVerifier Provider #

用Guice的Provider接口封装JWTVerifier的创建逻辑，仅在secret变化时生成新实例，避免重复创建：

@Singleton
public class JWTVerifierProvider implements Provider<JWTVerifier> {
    private final SecretManager secretManager;
    private volatile JWTVerifier cachedVerifier;
    private volatile String cachedSecret;

    @Inject
    public JWTVerifierProvider(SecretManager secretManager) {
        this.secretManager = secretManager;
        this.cachedSecret = secretManager.getCurrentSecret();
        this.cachedVerifier = JWT.require(Algorithm.HMAC256(cachedSecret)).build();
    }

    @Override
    public JWTVerifier get() {
        String currentSecret = secretManager.getCurrentSecret();
        if (!currentSecret.equals(cachedSecret)) {
            synchronized (this) {
                if (!currentSecret.equals(cachedSecret)) {
                    this.cachedVerifier = JWT.require(Algorithm.HMAC256(currentSecret)).build();
                    this.cachedSecret = currentSecret;
                }
            }
        }
        return cachedVerifier;
    }
}

修改AccessVerifier注入该Provider：

@Singleton
public class AccessVerifier {
    private final Provider<JWTVerifier> verifierProvider;

    @Inject
    public AccessVerifier(Provider<JWTVerifier> verifierProvider) {
        this.verifierProvider = verifierProvider;
    }

    public DecodedJWT decodeToken(String token) {
        DecodedJWT jwt = verifierProvider.get().verify(token);
        // 验证token中的部分声明
        return jwt;
    }
}

在Guice模块中完成绑定：

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(String.class).annotatedWith(Names.named("initialSecret")).toInstance("your-initial-secret");
        bind(SecretManager.class).asEagerSingleton();
        bind(JWTVerifier.class).toProvider(JWTVerifierProvider.class);
        bind(AccessVerifier.class).asEagerSingleton();
    }
}

3. 兼容多Secret的平滑轮换（可选） #

如果需要支持旧token的验证，可以让SecretManager维护一个活跃secret列表，AccessVerifier依次尝试用每个secret验证：

@Singleton
public class SecretManager {
    private volatile List<String> activeSecrets;

    @Inject
    public SecretManager(@Named("initialSecret") String initialSecret) {
        this.activeSecrets = Collections.singletonList(initialSecret);
    }

    public void rotateSecret(String newSecret) {
        // 保留旧secret一段时间，兼容未过期的旧token
        List<String> newSecrets = new ArrayList<>();
        newSecrets.add(newSecret);
        newSecrets.addAll(activeSecrets);
        // 可限制列表长度避免内存溢出
        this.activeSecrets = Collections.unmodifiableList(newSecrets);
    }

    public List<String> getActiveSecrets() {
        return activeSecrets;
    }
}

修改AccessVerifier的验证逻辑：

public DecodedJWT decodeToken(String token) {
    List<String> secrets = secretManager.getActiveSecrets();
    for (String secret : secrets) {
        try {
            JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret)).build();
            DecodedJWT jwt = verifier.verify(token);
            // 验证token中的部分声明
            return jwt;
        } catch (JWTVerificationException e) {
            // 当前secret验证失败，尝试下一个
            continue;
        }
    }
    throw new JWTVerificationException("所有secret均无法验证token");
}

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