You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

148 lines
6.1 KiB

package common.ecommerce.http;
import common.ecommerce.shared.spi.AccessToken;
import common.ecommerce.shared.spi.ChannelSecret;
import common.ecommerce.shared.spi.LockProvider;
import common.ecommerce.shared.spi.TokenStore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.time.Clock;
import java.time.Instant;
import java.util.Optional;
/**
* 令牌管理模板。对应设计文档 9.1 的五条要求。
*
* <ul>
* <li><b>按 AccountKey 隔离缓存</b>:缓存键由适配器按账户维度拼出(如
* {@code lingxing:{appKey}}),同一账户共用一个 token</li>
* <li><b>提前 {@code earlyRefreshSeconds} 续期</b>:见 {@link AccessToken#needsRefresh}</li>
* <li><b>刷新用 {@link LockProvider} 防击穿</b>:拿不到锁说明别的实例正在刷新,
* 等锁释放后重读缓存;仍无有效 token 才抛 {@code AuthException}</li>
* <li><b>刷新失败不返回旧 token</b>:这里不做宽限期兜底,失败直接把异常抛给调用方</li>
* <li><b>日志只打印指纹</b>:token 本体不进日志</li>
* <li><b>支持人工失效/重授权</b>:{@link #forceRefresh} 先删缓存再重取</li>
* </ul>
*
* <p>存储与锁都经 SPI 交给宿主(典型 MySQL / Redis),SDK 自身不落任何状态。
* 令牌的加密由宿主的 {@link TokenStore} 实现负责。</p>
*/
public abstract class TokenManager {
private static final Logger LOG = LoggerFactory.getLogger(TokenManager.class);
/** 刷新锁的 TTL:足够覆盖一次令牌请求,又不至于长时间阻塞其它实例。 */
private static final long REFRESH_LOCK_TTL_SECONDS = 30L;
/** 等锁的轮询间隔。 */
private static final long WAIT_INTERVAL_MILLIS = 50L;
/** 拿不到锁时最多等待多久;超过即认为对方卡死。 */
private static final long WAIT_TIMEOUT_MILLIS = 5_000L;
/** 测试用构造器可缩短等待,生产固定值。 */
private final long waitIntervalMillis;
private final long waitTimeoutMillis;
protected final TokenStore tokenStore;
protected final LockProvider lockProvider;
protected final Clock clock;
private final long earlyRefreshSeconds;
protected TokenManager(TokenStore tokenStore, LockProvider lockProvider, Clock clock, long earlyRefreshSeconds) {
this(tokenStore, lockProvider, clock, earlyRefreshSeconds, WAIT_INTERVAL_MILLIS, WAIT_TIMEOUT_MILLIS);
}
/** 仅供测试缩短等待;生产用上面的构造器。 */
protected TokenManager(TokenStore tokenStore, LockProvider lockProvider, Clock clock, long earlyRefreshSeconds,
long waitIntervalMillis, long waitTimeoutMillis) {
this.tokenStore = tokenStore;
this.lockProvider = lockProvider;
this.clock = clock;
this.earlyRefreshSeconds = earlyRefreshSeconds;
this.waitIntervalMillis = waitIntervalMillis;
this.waitTimeoutMillis = waitTimeoutMillis;
}
/** 拿到可用的 access token;必要时刷新。 */
public AccessToken getOrRefresh(String tokenKey, ChannelSecret secret) {
AccessToken cached = fresh(tokenKey);
if (cached != null) {
return cached;
}
long deadline = System.currentTimeMillis() + waitTimeoutMillis;
while (true) {
Optional<LockProvider.Lock> lock = lockProvider.tryLock("token-refresh:" + tokenKey, REFRESH_LOCK_TTL_SECONDS);
if (lock.isPresent()) {
try {
return refreshUnderLock(tokenKey, secret, cached);
} finally {
lock.get().close();
}
}
// 别的实例正在刷新:等它写完再读缓存
if (!waitQuietly(waitIntervalMillis)) {
throw authError("interrupted while waiting for token refresh: " + tokenKey);
}
AccessToken refreshedByPeer = fresh(tokenKey);
if (refreshedByPeer != null) {
LOG.debug("token for {} refreshed by another instance", tokenKey);
return refreshedByPeer;
}
if (System.currentTimeMillis() >= deadline) {
break;
}
}
throw authError("token refresh in progress for " + tokenKey + ", lock held by another instance");
}
/** 401 后作废并强制重取一次。 */
public AccessToken forceRefresh(String tokenKey, ChannelSecret secret) {
tokenStore.remove(tokenKey);
return getOrRefresh(tokenKey, secret);
}
/** 由平台实现:向平台换取新令牌。 */
protected abstract AccessToken refresh(ChannelSecret secret, AccessToken previous);
// ---------------------------------------------------------------- internals
private AccessToken refreshUnderLock(String tokenKey, ChannelSecret secret, AccessToken previous) {
AccessToken again = fresh(tokenKey);
if (again != null) {
return again;
}
AccessToken refreshed = refresh(secret, previous);
tokenStore.save(tokenKey, refreshed);
LOG.info("token refreshed for {} [{}]", tokenKey, refreshed.fingerprint());
return refreshed;
}
/** 缓存中仍是有效 token 时返回它,否则 null;不做过期兜底。 */
private AccessToken fresh(String tokenKey) {
Optional<AccessToken> cached = tokenStore.get(tokenKey);
if (cached.isPresent() && !cached.get().needsRefresh(Instant.now(clock), earlyRefreshSeconds)) {
return cached.get();
}
return null;
}
private static boolean waitQuietly(long millis) {
try {
Thread.sleep(millis);
return true;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return false;
}
}
private static common.ecommerce.shared.error.AuthException authError(String message) {
return new common.ecommerce.shared.error.AuthException(
common.ecommerce.shared.error.ChannelException.builder()
.message(message)
.operation("token.refresh"));
}
}