从service 到 JobIntentService 和 WorkManager

最新推荐文章于 2025-07-26 17:30:15 发布

原创最新推荐文章于 2025-07-26 17:30:15 发布 · 1.2k 阅读

30 ·

CC 4.0 BY-SA版权

文章标签：

#android #android studio #java #okhttp

Android开发专栏收录该内容

18 篇文章

订阅专栏

Android 系统对后台服务的限制越来越严格，特别是从 Android 8（API 级别 26）开始，后台服务的使用受到限制。如果需要在后台持续运行，可以考虑使用 JobIntentService 或 WorkManager。

service

1. Service 的概念

Service 是 Android 四大组件之一，它是一个用于在后台执行长时间运行操作的组件，没有用户界面。Service 的主要用途包括：

执行后台任务，如下载文件、播放音乐、同步数据等。
提供后台服务，如通知推送、定时任务等。
与其他组件（如 Activity 或 BroadcastReceiver）进行交互。

2. Service 的生命周期

Service 的生命周期主要由以下几个方法控制：

onCreate()：当 Service 被创建时调用。如果 Service 已经运行，则不会再次调用。
onStartCommand()：当通过 startService() 启动 Service 时调用。每次调用 startService() 都会触发此方法。
onBind()：当通过 bindService() 绑定 Service 时调用。如果 Service 已经绑定，则不会再次调用。
onUnbind()：当所有绑定的客户端都解绑时调用。
onDestroy()：当 Service 被销毁时调用。

3. Service 的启动方式

Service 可以通过两种方式启动：

显式启动：通过 startService() 方法启动。这种方式启动的 Service 会一直运行，直到调用 stopService() 或 stopSelf()。
绑定启动：通过 bindService() 方法启动。这种方式启动的 Service 会与绑定的组件（如 Activity）的生命周期相关联。当所有绑定的组件都解绑时，Service 会被销毁。

如果需要 Service 在后台持续运行，建议使用 startForeground() 方法将其置于前台。

4. Service 的使用场景

后台任务：如下载文件、同步数据等。
播放音乐：在后台播放音乐，即使用户离开了应用。
定时任务：如定时推送通知。
与后台服务交互：如与服务器进行通信。

5. 实现一个简单的 Service

接下来，通过一个简单的示例来展示如何实现一个 Service。这个 Service 将在后台执行一个简单的计时任务，并在日志中打印计时信息。

步骤 1：定义 Service

public class MyService extends Service {
    private static final String TAG = "MyService";
    private boolean isRunning = false;
    private int count = 0;

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "Service created");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "Service started");
        isRunning = true;
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (isRunning) {
                    try {
                        Thread.sleep(1000);
                        count++;
                        Log.d(TAG, "Count: " + count);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        return START_STICKY; // 如果系统杀死 Service，系统会重新启动它
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "Service destroyed");
        isRunning = false;
    }

    @Override
    public IBinder onBind(Intent intent) {
        // 返回一个 IBinder 对象，用于绑定服务
        return null;
    }
}

代码说明

onCreate()：当 Service 被创建时调用。
onStartCommand()：当通过 startService() 启动 Service 时调用。这里启动了一个后台线程，每秒打印一次计时信息。
onDestroy()：当 Service 被销毁时调用。这里将 isRunning 设置为 false，停止后台线程。
onBind()：当通过 bindService() 绑定 Service 时调用。这里返回 null，因为我们不支持绑定。

步骤 2：在 AndroidManifest.xml 中注册 Service

<application
    ...>
    <service
        android:name=".MyService"
        android:enabled="true"
        android:exported="false" />
</application>

步骤 3：从 Activity 启动和停止 Service

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 启动 Service
        Button startButton = findViewById(R.id.startButton);
        startButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent startIntent = new Intent(MainActivity.this, MyService.class);
                startService(startIntent);
            }
        });

        // 停止 Service
        Button stopButton = findViewById(R.id.stopButton);
        stopButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent stopIntent = new Intent(MainActivity.this, MyService.class);
                stopService(stopIntent);
            }
        });
    }
}

步骤 4：布局文件（activity_main.xml）

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center">

    <Button
        android:id="@+id/startButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Service" />

    <Button
        android:id="@+id/stopButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Stop Service" />
</LinearLayout>

通过上述代码，实现了一个简单的 Service，它在后台运行并每秒打印一次计时信息。Service 的生命周期方法（如 onCreate()、onStartCommand() 和 onDestroy()）用于控制服务的启动和停止。还通过 startService() 和 stopService() 方法从 Activity 中启动和停止服务。

2. 使用 startForeground() 创建前台服务

前台服务会显示一个通知，用户可以清楚地看到服务正在运行。前台服务不会被系统轻易杀死。

示例代码：

public class ForegroundService extends Service {
    private static final int NOTIFICATION_ID = 1;
    private static final String CHANNEL_ID = "ForegroundServiceChannel";

    @Override
    public void onCreate() {
        super.onCreate();
        // 创建通知渠道（Android 8 及以上版本需要）
        createNotificationChannel();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 创建通知
        Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
                .setContentTitle("Foreground Service")
                .setContentText("Service is running")
                .setSmallIcon(R.drawable.ic_notification)
                .build();

        // 将服务置于前台
        startForeground(NOTIFICATION_ID, notification);

        // 模拟后台任务
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(1000);
                        Log.d("ForegroundService", "Running: " + i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 任务完成后停止服务
                stopSelf();
            }
        }).start();

        return START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // 停止前台服务
        stopForeground(true);
    }

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

    // 创建通知渠道
    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel serviceChannel = new NotificationChannel(
                    CHANNEL_ID,
                    "Foreground Service Channel",
                    NotificationManager.IMPORTANCE_DEFAULT
            );
            NotificationManager manager = getSystemService(NotificationManager.class);
            manager.createNotificationChannel(serviceChannel);
        }
    }
}

代码说明：

createNotificationChannel()：创建通知渠道（Android 8 及以上版本需要）。
startForeground()：将服务置于前台，并显示通知。
NotificationCompat.Builder：构建通知内容。
new Thread()：在后台线程中执行任务。
stopSelf()：任务完成后停止服务。
stopForeground()：在服务销毁时停止前台服务。

JobIntentService

3. 使用 JobIntentService

JobIntentService 是一个兼容类，用于在后台执行任务。它在 Android 8 及以上版本中会使用 JobScheduler，在旧版本中则会回退到 IntentService。

特点

兼容性：兼容从 Android 4.0 到最新版本。
后台任务处理：适用于简单的后台任务，如数据同步、文件下载等。
自动管理 Wake Locks：在 Android Oreo 及以上版本中，JobIntentService 会自动管理 Wake Locks。
任务调度：在 Android Oreo 及以上版本中，任务通过 JobScheduler 调度；在旧版本中，任务通过 startService() 执行。

使用场景

执行耗时操作，如下载文件、上传数据等。
需要兼容旧版本系统的后台任务。

示例代码：

public class MyJobIntentService extends JobIntentService {
    // 定义一个服务ID
    static final int JOB_ID = 1000;

    // 启动服务的静态方法
    public static void enqueueWork(Context context, Intent work) {
        enqueueWork(context, MyJobIntentService.class, JOB_ID, work);
    }

    @Override
    protected void onHandleWork(@NonNull Intent intent) {
        // 模拟后台任务
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
                Log.d("MyJobIntentService", "Running: " + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

代码说明：

enqueueWork()：静态方法用于启动服务。
onHandleWork()：在后台线程中执行任务。
enqueueWork()：将任务加入队列，JobIntentService 会根据系统版本选择合适的后台执行方式。

WorkManager

4. 使用 WorkManager

WorkManager 是 Android 官方推荐的后台任务调度框架，适用于需要灵活调度的任务，例如周期性任务或延迟任务。它支持一次性任务、周期性任务，并且可以根据设备的条件（如网络状态、电池电量等）执行任务。

特点

灵活的任务调度：支持一次性任务、周期性任务。
条件约束：可以根据网络状态、电池电量等条件执行任务。
兼容性：兼容从 Android 4.0 到最新版本。
可靠性：即使应用退出或设备重启，任务也能继续执行。

使用场景

定期同步数据。
在后台处理耗时任务。
需要根据设备条件执行的任务。

示例代码：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 创建一个一次性工作请求
        OneTimeWorkRequest workRequest = new OneTimeWorkRequest.Builder(MyWorker.class)
                .setConstraints(new Constraints.Builder()
                        .setRequiredNetworkType(NetworkType.CONNECTED)
                        .build())
                .build();

        // 将工作请求加入队列
        WorkManager.getInstance(this).enqueue(workRequest);
    }
}

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

    @NonNull
    @Override
    public Result doWork() {
        // 模拟后台任务
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
                Log.d("MyWorker", "Running: " + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 返回任务执行结果
        return Result.success();
    }
}