如何在Java中实现持续服务器请求？Android令牌验证自动跳转

核心思路 #

要实现持续且高效的令牌验证，不能仅在onCreate执行一次请求，需结合Activity生命周期，在前台时周期性发起验证，同时避免后台不必要的资源消耗，且必须用异步请求避免阻塞主线程。

方案一：Handler + Runnable 轻量周期性验证 #

这是适配前台Activity的轻量方案，能精准控制验证周期，且随Activity生命周期启停：

public class ChatActivity extends AppCompatActivity {
    private Handler tokenCheckHandler;
    private Runnable tokenCheckRunnable;
    private OkHttpClient client;
    // 验证周期，示例为30秒一次（可根据业务需求调整）
    private static final long CHECK_INTERVAL = 30000;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);
        // 初始化OkHttpClient（建议全局单例，避免重复创建连接池）
        client = new OkHttpClient();
        
        // 初始化Handler和验证任务
        tokenCheckHandler = new Handler(Looper.getMainLooper());
        tokenCheckRunnable = new Runnable() {
            @Override
            public void run() {
                // 构建令牌验证请求
                Request request = new Request.Builder()
                        .url("你的令牌验证API地址")
                        .addHeader("Authorization", "Bearer " + 你的令牌)
                        .build();
                
                // 发起异步请求，避免阻塞主线程
                client.newCall(request).enqueue(new Callback() {
                    @Override
                    public void onFailure(@NonNull Call call, @NonNull IOException e) {
                        // 网络异常处理，可根据需求决定是否触发跳转
                        // e.printStackTrace();
                    }

                    @Override
                    public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                        boolean isTokenValid = false;
                        if (response.isSuccessful()) {
                            // 解析响应体，判断令牌有效性
                            String responseBody = response.body().string();
                            isTokenValid = 解析响应得到验证结果;
                        }
                        
                        // 回到主线程处理跳转逻辑
                        runOnUiThread(() -> {
                            if (!isTokenValid) {
                                // 取消后续验证任务，避免内存泄漏
                                tokenCheckHandler.removeCallbacks(tokenCheckRunnable);
                                // 跳转回MainActivity并关闭当前页面
                                startActivity(new Intent(ChatActivity.this, MainActivity.class));
                                finish();
                            } else {
                                // 令牌有效，继续下一次周期性验证
                                tokenCheckHandler.postDelayed(tokenCheckRunnable, CHECK_INTERVAL);
                            }
                        });
                    }
                });
            }
        };
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 进入前台时启动验证循环（立即执行第一次，之后按周期重复）
        tokenCheckHandler.postDelayed(tokenCheckRunnable, 0);
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 离开前台时停止验证，避免后台消耗资源
        tokenCheckHandler.removeCallbacks(tokenCheckRunnable);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 销毁时彻底清理资源
        tokenCheckHandler.removeCallbacks(tokenCheckRunnable);
        tokenCheckHandler = null;
    }
}

方案二：WorkManager 后台稳定验证（适合需后台持续验证场景） #

如果需要Activity退到后台后仍保持验证，可使用WorkManager实现周期性任务，但需注意系统电池优化限制：

// 1. 创建令牌验证Worker
public class TokenCheckWorker extends Worker {
    private OkHttpClient client;

    public TokenCheckWorker(@NonNull Context context, @NonNull WorkerParameters params) {
        super(context, params);
        client = new OkHttpClient();
    }

    @NonNull
    @Override
    public Result doWork() {
        Request request = new Request.Builder()
                .url("你的令牌验证API地址")
                .addHeader("Authorization", "Bearer " + 你的令牌)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            boolean isTokenValid = response.isSuccessful() && 解析响应得到验证结果;
            if (!isTokenValid) {
                // 发送广播通知ChatActivity执行跳转
                Intent intent = new Intent("com.your.package.TOKEN_INVALID");
                LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);
                return Result.success();
            }
        } catch (IOException e) {
            e.printStackTrace();
            return Result.retry(); // 请求失败后自动重试
        }
        return Result.success();
    }
}

// 2. 在ChatActivity中调度Worker并监听广播
public class ChatActivity extends AppCompatActivity {
    private BroadcastReceiver tokenInvalidReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);
        
        // 注册广播接收器，接收令牌无效通知
        tokenInvalidReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                startActivity(new Intent(ChatActivity.this, MainActivity.class));
                finish();
            }
        };
        LocalBroadcastManager.getInstance(this)
                .registerReceiver(tokenInvalidReceiver, new IntentFilter("com.your.package.TOKEN_INVALID"));
        
        // 调度周期性验证任务（示例为15分钟一次，可调整）
        PeriodicWorkRequest workRequest = new PeriodicWorkRequest.Builder(TokenCheckWorker.class, 15, TimeUnit.MINUTES)
                .build();
        WorkManager.getInstance(this).enqueue(workRequest);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 注销广播接收器，避免内存泄漏
        LocalBroadcastManager.getInstance(this).unregisterReceiver(tokenInvalidReceiver);
    }
}

关键优化建议 #

1. 禁用同步请求：必须使用enqueue()异步请求，禁止用execute()，否则会阻塞主线程导致ANR。
2. 绑定生命周期：方案一通过onResume/onPause控制验证启停，确保只有Activity在前台时才发起请求，节省设备资源。
3. 本地预判过期：如果令牌包含过期时间（如JWT的exp字段），可先本地判断是否即将过期，再发起API请求，减少不必要的网络调用。
4. 全局单例客户端：将OkHttpClient设为全局单例，避免重复创建连接池，提升请求性能。
5. 资源及时清理：在Activity销毁时取消Handler回调、注销广播接收器，彻底避免内存泄漏。

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