Java独立应用中Google OAuth临时持久化凭证实现方案咨询

你的需求非常贴合实际场景——默认的Google OAuth凭证存储机制不会自动让持久化的凭证过期，而你需要避免用户拷贝应用文件夹后冒用他人身份，同时又不想每次启动都强制重新认证。下面是两个可行的方案，基于你现有的代码就能快速改造：

方案一：检查凭证文件修改时间，到期自动删除 #

这个方案最简单，不需要修改Google API的核心存储逻辑，只需要在认证前检查凭证文件的最后修改时间，如果超过你设定的期限（比如30天），就删除旧凭证，触发重新认证流程。

修改你的authorize()方法： #

private Credential authorize() throws IOException {
    // 先检查凭证是否过期（自定义30天有效期）
    File storedCredentialFile = new File(DATA_STORE_DIR, "StoredCredential");
    long thirtyDaysInMillis = 30L * 24 * 60 * 60 * 1000;
    if (storedCredentialFile.exists()) {
        long lastModified = storedCredentialFile.lastModified();
        if (System.currentTimeMillis() - lastModified > thirtyDaysInMillis) {
            // 删除过期凭证
            storedCredentialFile.delete();
            MyLogger.getLogger().info("旧凭证已过期，将重新引导用户完成认证");
        }
    }

    // 原有的认证逻辑保持不变
    InputStream in = new FileInputStream(ResourceWorking.googleClientSecretPath());
    GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));
    MyLogger.getLogger().info(clientSecrets.getDetails().toPrettyString());

    GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY, clientSecrets, SCOPES)
            .setDataStoreFactory(DATA_STORE_FACTORY)
            .setAccessType("offline")
            .build();
    Credential credential = new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
    MyLogger.getLogger().info(credential.getAccessToken()+" "+credential.getRefreshToken()+" "+credential.getExpirationTimeMilliseconds()+" "+credential.getExpiresInSeconds());
    return credential;
}

原理：默认的FileDataStoreFactory会把凭证存在StoredCredential文件里，我们通过检查这个文件的最后修改时间来判断是否过期。删除文件后，下次调用authorize()会自动触发浏览器认证流程，生成新的凭证并覆盖存储。

方案二：自定义DataStore存储，添加自定义过期元数据 #

如果你需要更灵活的控制（比如记录用户的认证时间、自定义不同的过期规则），可以扩展Google的DataStore接口，在存储凭证的同时保存自定义的过期时间，读取时自动校验。

步骤1：创建带过期时间的凭证包装类 #

public class ExpiringCredential implements Serializable {
    private Credential credential;
    private long customExpirationTimestamp; // 自定义过期时间戳（毫秒）

    public ExpiringCredential(Credential credential, long customExpirationTimestamp) {
        this.credential = credential;
        this.customExpirationTimestamp = customExpirationTimestamp;
    }

    // Getters and Setters
    public Credential getCredential() { return credential; }
    public long getCustomExpirationTimestamp() { return customExpirationTimestamp; }
}

步骤2：自定义DataStore实现 #

基于FileDataStore改造，读取时自动检查过期时间：

public class ExpiringFileDataStore<T extends Serializable> extends FileDataStore<T> {
    public ExpiringFileDataStore(File dataDirectory, String id, Serializer<T> serializer) throws IOException {
        super(dataDirectory, id, serializer);
    }

    @Override
    public T get(String key) throws IOException {
        ExpiringCredential expiringCred = (ExpiringCredential) super.get(key);
        if (expiringCred != null && System.currentTimeMillis() > expiringCred.getCustomExpirationTimestamp()) {
            // 过期则删除凭证并返回null，触发重新认证
            delete(key);
            return null;
        }
        return (T) expiringCred;
    }
}

步骤3：替换默认的DataStoreFactory #

static {
    try {
        HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
        // 使用自定义的DataStoreFactory
        DATA_STORE_FACTORY = new DataStoreFactory() {
            @Override
            public <V extends Serializable> DataStore<V> getDataStore(String id) throws IOException {
                return new ExpiringFileDataStore<>(DATA_STORE_DIR, id, new JacksonSerializer<>(ExpiringCredential.class));
            }
        };
    } catch (Throwable t) {
        MyLogger.getLogger().severe(t);
    }
}

步骤4：存储带自定义过期时间的凭证 #

在authorize()方法中，获取新凭证后包装成ExpiringCredential存储：

// 获取到credential后，添加自定义过期逻辑
long thirtyDaysLater = System.currentTimeMillis() + 30L * 24 * 60 * 60 * 1000;
ExpiringCredential expiringCred = new ExpiringCredential(credential, thirtyDaysLater);
DATA_STORE_FACTORY.getDataStore("StoredCredential").set("user", expiringCred);

注意：这个方案需要你对Google API的DataStore机制有一定了解，适合需要复杂过期规则的场景。

额外优化建议：多用户场景隔离 #

如果你的应用是供多用户使用，建议给每个用户分配独立的凭证存储标识（比如用当前用户名代替固定的"user"作为authorize()方法的参数），这样不同用户的凭证会分开存储，进一步降低冒用风险：

// 假设你能获取当前使用应用的用户名
String currentUser = getCurrentAppUserName();
credential = new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize(currentUser);

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