Android：ServiceIntent类onHandleIntent仅执行一次，需每秒调用API

看起来你应该是用了IntentService吧？它的onHandleIntent方法设计初衷就是处理单个传入的Intent，处理完成后Service会自动停止，所以自然没法循环执行你的API调用逻辑。下面给你几个可行的解决方案，按需选择：

方案一：改用普通Service + 后台循环线程（推荐用于精确每秒执行的场景） #

普通Service不会自动停止，我们可以在它的onStartCommand方法里启动一个后台线程，用循环来实现每秒一次的API调用，同时要注意在Service销毁时清理线程，避免内存泄漏。

public class FancyBookMakingService extends Service {
    // 控制循环的标志位，用volatile保证多线程可见性
    private volatile boolean isTaskRunning = false;
    private Thread apiWorkerThread;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 避免重复启动线程
        if (!isTaskRunning) {
            isTaskRunning = true;
            apiWorkerThread = new Thread(() -> {
                while (isTaskRunning) {
                    try {
                        // 执行API调用
                        String result = getApi(URL);
                        // 发送广播传递结果
                        Intent broadcastIntent = new Intent(DataHolder.ACTION_SEND_DATA);
                        broadcastIntent.putExtra("key", result);
                        sendBroadcast(broadcastIntent);

                        // 暂停1秒，实现每秒一次的频率
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // 线程被中断时退出循环
                        Thread.currentThread().interrupt();
                        break;
                    } catch (Exception e) {
                        // 处理API调用时的异常，比如网络错误
                        e.printStackTrace();
                    }
                }
            });
            apiWorkerThread.start();
        }
        // 返回START_STICKY，让系统在内存不足杀死Service后尝试重启（可根据需求调整）
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // 停止循环并中断线程
        isTaskRunning = false;
        if (apiWorkerThread != null) {
            apiWorkerThread.interrupt();
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        // 不需要绑定的话返回null
        return null;
    }

    // 你的API调用方法
    private String getApi(String url) {
        // 这里写你的API请求逻辑，比如用OkHttp或者HttpURLConnection
        return "";
    }
}

方案二：使用Handler + Runnable实现定时循环 #

这个方案适合如果你的API调用是异步操作，或者更习惯用Handler来调度任务的场景。同样要记得在Service销毁时移除回调，防止内存泄漏。

public class FancyBookMakingService extends Service {
    private Handler taskHandler;
    private Runnable apiCallRunnable;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 用后台Looper创建Handler，避免阻塞主线程
        taskHandler = new Handler(Looper.getMainLooper()); // 如果API是耗时操作，建议用新的Looper：Handler(Looper.myLooper())
        apiCallRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    String result = getApi(URL);
                    Intent broadcastIntent = new Intent(DataHolder.ACTION_SEND_DATA);
                    broadcastIntent.putExtra("key", result);
                    sendBroadcast(broadcastIntent);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // 1秒后再次执行当前Runnable，形成循环
                taskHandler.postDelayed(this, 1000);
            }
        };
        // 立即执行第一次任务
        taskHandler.post(apiCallRunnable);
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // 移除所有未执行的回调，停止循环
        if (taskHandler != null && apiCallRunnable != null) {
            taskHandler.removeCallbacks(apiCallRunnable);
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private String getApi(String url) {
        // API调用逻辑
        return "";
    }
}

方案三：WorkManager（适合非精确、需要持久化的定时任务） #

如果你的任务不需要严格的每秒执行，或者希望App退出后甚至系统重启后仍能继续执行，WorkManager是更合适的选择。不过要注意：WorkManager的周期性任务最小间隔是15分钟（受系统电池优化限制），所以不适合精确每秒执行的场景，这里只做补充说明：

1. 定义Worker类：

public class ApiCallWorker extends Worker {
    public ApiCallWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    @NonNull
    @Override
    public Result doWork() {
        try {
            String result = getApi(URL);
            Intent broadcastIntent = new Intent(DataHolder.ACTION_SEND_DATA);
            broadcastIntent.putExtra("key", result);
            getApplicationContext().sendBroadcast(broadcastIntent);
            // 任务执行成功，返回SUCCESS
            return Result.success();
        } catch (Exception e) {
            e.printStackTrace();
            // 任务失败，可选择重试或返回FAILURE
            return Result.retry();
        }
    }

    private String getApi(String url) {
        // API调用逻辑
        return "";
    }
}

2. 调度周期性任务（比如每15分钟一次）：

// 在Activity或Service中调用
PeriodicWorkRequest workRequest = new PeriodicWorkRequest.Builder(
        ApiCallWorker.class,
        15, TimeUnit.MINUTES // 最小间隔15分钟
).build();

WorkManager.getInstance(context).enqueue(workRequest);

注意事项 #

• 不要继续使用IntentService：它的核心逻辑就是处理单个Intent后自动终止，完全不适合循环执行的任务。
• 处理异常：API调用可能会抛出网络异常、超时等问题，一定要在代码中捕获并处理，避免线程崩溃导致循环终止。
• 电池优化：频繁的每秒API调用会消耗较多电量，如果不是必须的场景，建议适当调整调用频率，或者使用WorkManager的优化策略。

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