Android四大组件之Service（服务）

最新推荐文章于 2025-02-21 10:39:46 发布

origin_edge

最新推荐文章于 2025-02-21 10:39:46 发布

阅读量333

点赞数

分类专栏：实训理解

本文链接：https://blog.youkuaiyun.com/origin_edge/article/details/80737256

版权

实训理解专栏收录该内容

22 篇文章

订阅专栏

本文详细介绍了Android中的Service，包括Service的概念、应用场景、启动方法（startService和bindService）及其生命周期。还特别提到了IntentService的特点和使用场景，强调了IntentService的异步处理能力和自动关闭特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是Service

Service是Android中实现程序后台运行的解决方案，它适用于去执行一些不需要与用户进行交互但是需要长期执行的任务
Service的运行不依赖于Activity，即使启动Service的这个Activity切换到后台，Service依旧不会停止。那么Service是依赖于什么呢，它依赖于创建Service所在的那个应用程序进程，当这个进程被杀掉后，所有依赖于这个进程的Service都会停止运行。还有要注意的一点是，Service是运行在主线程中的，如果想在Service中进行耗时操作，需要创建子线程

Service有哪些应用场景

上面说到了，Service一般用于执行一些不需要与用户进行交互但是需要长期执行的任务，例如下载资源，还有音乐播放器的后台播放等

Service的启动方法

Service的这两种启动方式有什么区别呢。通过startService方式启动的Service，一旦启动了，那么这个Service就与启动Activity无关了，即使这个Activity切换到后台，Service也不会停止运行。而通过bindService启动的Service则不同，看名字我们就知道，这是绑定服务的意思，也就是说，我通过Activity启动了一个Service，那么这个Service就和我Activity绑定了，当我Activity切换到后台停止运行的时候，这个Service同样会停止运行。这就是这两种方式启动的差别
下面就来通过实例看看具体的操作会产生什么样的效果以及它们的生命周期

startService方式启动Service

创建一个类继承Service并实现onBind方法，这里使用的是app包下的

public class MyStartService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

onBind方法由于我们是使用startService方式启动的，所以不需要管，使用bindService方式启动同样也用不到
然后我们重写onStartCommand方法，在onStartCommand这个方法里写我们需要执行的操作，这里我们写一个从0到9的循环输出操作，创建一个子线程

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count < 10) {
                    Log.e(TAG, "run: -------" + count);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }

好了，Service的代码我们已经写完了，下面我们就在AndroidManifest.xml中注册这个Service，在<application></application>中写入下面代码

<service android:name=".MyStartService"></service>

注册已经搞定了，那我们就来使用一下这个Service吧，创建一个Activity，在布局中添加两个按钮用于启动和停止Service

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

    <Button
        android:id="@+id/btn1"
        android:text="启动"
        android:textSize="30sp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/btn2"
        android:text="停止"
        android:textSize="30sp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
</LinearLayout>

在Activity绑定两个按钮的ID并且添加点击事件

public class ServiceActivity extends AppCompatActivity implements View.OnClickListener{
    private static final String TAG = "ServiceActivity";
    private Button btn1,btn2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_service);

        bindID();

    }

    private void bindID() {
        btn1 = findViewById(R.id.btn1);
        btn2 = findViewById(R.id.btn2);
        btn1.setOnClickListener(this);
        btn2.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.btn1:
                break;
            case R.id.btn2:
                break;
                default:
                    break;
        }
    }
}

然后启动服务，在btn1的点击事件中添加

                Intent intent = new Intent(this,MyStartService.class);
                startService(intent);

这个服务就启动了，那么怎么停止这个服务呢，通过stopService即可

                Intent stopIntent = new Intent(this,MyStartService.class);
                stopService(stopIntent);

然后运行程序，我们就能看到效果了

知道了怎么通过startService方式启动Service，那么我们再来看看它的生命周期是怎么样的

重写onCreate和onDestroy方法，并在这两个方法和onStartCommand方法里加入打印，onCreate是服务被创建的时候调用的，它只会调用一次，onDestroy是服务被销毁的时候调用的

public class MyStartService extends Service {
    private String TAG = "MyStartService";

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

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(TAG, "onCreate: --------------------" );
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG, "onDestroy: --------------------" );
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand: --------------------" );
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count < 10) {
                    Log.e(TAG, "run: -------" + count);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }
}

我们来运行这个程序看看打印的什么
可以看到，当点击了启动后，首先执行了onCreate方法，然后执行了onStartCommand方法，然后我们再停止这个Service看看
可以看到，onDestroy方法被执行了，它的生命周期如下

bindService方式启动Service

上面讲了startService方式启动Service，那么使用bindService方式启动Service有什么不同呢，下面我们就来一起看看
首先创建一个类继承Service

public class MyBindService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

然后创建一个内部类MyBinder继承Binder，创建一个方法返回服务的对象

    public class MyBinder extends Binder{
        public MyBindService getService(){
            return MyBindService.this;
        }
    }

实例化这个内部类

private MyBinder myBinder = new MyBinder();

返回myBinder

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

重写onCreate方法

    @Override
    public void onCreate() {
        super.onCreate();

    }

创建一个方法

    public void run(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count < 10) {
                    Log.e(TAG, "run: -------" + count);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        }).start();
    }

好了，这个服务的内容已经写完了，可能你看到这里会奇怪，前一个启动方法使用的onStartCommand方法呢，为什么这里没有使用？这个等会了解了它的生命周期，你就会知道了
接下来我们将Activity中的代码完善，首先我们要实例化一个ServiceConnection用于绑定服务

    private ServiceConnection connection = new ServiceConnection() {
        /**
         * Service连接成功时调用
         * @param name
         * @param service
         */
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.e(TAG, "onServiceConnected: -------------------");
            //获取Service返回的MyBindService对象
            MyBindService myBindService  = ((MyBindService.MyBinder)service).getService();
            //调用MyBindService的run方法
            myBindService.run();
        }

        /**
         * Service因为一些原因被破坏或销毁的时候调用
         * @param name
         */
        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e(TAG, "onServiceDisconnected: ---------------------------" );
        }
    };

然后在点击事件中创建服务，这里使用bindService，一个参数是Intent，第二个参数就是刚刚实例化的ServiceConnection，第三个是创建方法，这里我们使用BIND_AUTO_CREATE

Intent intent = new Intent(this,MyBindService.class);
bindService(intent,connection,BIND_AUTO_CREATE);

解绑使用unbindService

unbindService(connection);

之后运行程序，我们可以看到onServiceConnected被打印出来了

下面我们就来看看通过bindService方式启动的Service的生命周期有什么不同
重写下面几个方法并添加打印

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "onBind: ------------------------------");
        return myBinder;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(TAG, "onCreate: ---------------------------");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand: --------------------");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.e(TAG, "onUnbind: -------------------------------");
        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG, "onDestroy: -----------------------------------");
    }

然后运行程序并点击启动服务
可以看到，这里打印了onCreate和onBind，并没有打印onStartCommand，这是因为通过bindService方式启动的Service并不会执行onStartCommand方法
我们再点击下停止，解绑服务试试
执行了onUnbind和onDestroy方法，通过这个例子，我们可以知道，通过bindService方法启动的Service生命周期如下

IntentService有什么不同以及IntentService的用法和注意事项

IntentService是一个基于Service的一个类，用来处理异步的请求，我们可以通过startService(Intent)来提交请求，该Service会在需要的时候创建，当完成所有的任务以后自己关闭，下面我们来看看IntentService的用法
创建一个MyIntentService继承IntentService，同时创建一个构造方法，这里需要注意，默认的重构方法是有参的，而在AndroidManifest.xml中注册时，需要你有一个无参的构造方法，所以这里我们可以将参数删掉，将名字指定为服务类名，同时它需要你重写onHandleIntent方法，这里我们依旧写一个0-9循环

public class MyIntentService extends IntentService {
    private String TAG = "MyIntentService";

    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public MyIntentService() {
        super("MyIntentService");
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        int count = 0;
        while (count<10){
            Log.e(TAG, "onHandleIntent: ------------"+count );
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
        }
    }
}

然后在Activity中通过startService启动这个服务

Intent intent = new Intent(this,MyIntentService.class);
startService(intent);

可以看到，我们执行了一个while循环耗时操作，但是并没有写在子线程中，这是因为它会自己创建子线程进行处理，并且它是串行的，也就是当前这个线程执行完毕才会执行下一个线程