Android Service和IntentService知识点详细总结

时间 2019-11-16

标签 android service intentservice 知识详细总结栏目 Android 繁體版

原文原文链接

Service 对于广大的Android开发者来讲算是耳熟能详了，做为Android的四大组件之一，在咱们的开发中也起着重要的做用，在Android面试中，Service相关的问题也是面试官问得比较多的，当别人问你，Service 究竟是什么的时候？你可能随口就能答得上来，Service是一个在后台执行长时间运行操做而不用提供用户界面的应用组件，可由其余组件启动，即便用户切换到其余应用程序，Service 仍然在后台继续运行。没错，这是Service的概念，做为Android开发，或多或少都知道一些，可是不是每一个人把全部知识点都了解得透测。前段时间因为项目中有用到Service，所以，本篇文章对Service的用法作一个总结。html

Service

Service 和Activity 同样同为Android 的四大组件之一，而且他们都有各自的生命周期，要想掌握Service 的用法，那就要了解Service 的生命周期有哪些方法，而且生命周期中各个方法回调的时机和做用。有一点比较重要，Service 有两种启动方式，而且它的两种启动方式的生命周期是不同的。接下来分别看一下两种启动方式各自的生命周期方法。java

startService方式启动Service

当应用组件经过startService方法来启动Service 时，Service 则会处于启动状态，一旦服务启动，它就会在后台无限期的运行，生命周期独立于启动它的组件，即便启动它的组件已经销毁了也不受任何影响，因为启动的服务长期运行在后台，这会大量消耗手机的电量，所以，咱们应该在任务执行完成以后调用stopSelf()来中止服务，或者经过其余应用组件调用stopService 来中止服务。android

startService 启动服务后，会执行以下生命周期：onCreate() －> onStartCommand() －> onStart()(如今已经废弃) －> onDestroy() 。具体看一下它的几个生命周期方法：git

onCreate() :首次启动服务的时候，系统会调用这个方法，在onStartCommand 和 onBind 方法以前，若是服务已经启动起来了，再次启动时，则不会调用此方法，所以能够在onCreate 方法中作一些初始化的操做，好比要执行耗时的操做，能够在这里建立线程，要播放音乐，能够在这里初始化音乐播放器。github
onStartCommand(): 当经过startService 方法来启动服务的时候，在onCreate 方法以后就会回调这个方法，此方法调用后，服务就启动起来了，将会在后台无限期的运行，直到经过stopService 或者 stopSelf 方法来中止服务。面试
onDestroy():当服务再也不使用且将被销毁时，系统将调用此方法。服务应该实现此方法来清理全部资源，如线程、注册的侦听器、接收器等。这是服务接收的最后一个调用。编程

了解了这几个生命周期方法后，咱们就来写一个简单Service 。安全

要使用Service 就要经过继承Service类（或者继承IntentService ,侯文会讲）来实现，代码以下：多线程

public class SimpleService extends Service {
    public static final String TAG = "SimpleService";
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG,"call onBind...");
        return null;
    }

    @Override
    public void onCreate() {
        Log.i(TAG,"call onCreate...");
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Log.i(TAG,"call onStart...");
    }

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

    @Override
    public void onDestroy() {
        Log.i(TAG,"call onDestroy...");
    }



}复制代码

Service类写好了以后，咱们须要在清单文件中注册一下，在application标签下：app

<service android:name=".service.SimpleService"
                 android:exported="false"
            />复制代码

写好了Service而且在清单文件注册以后，咱们就能够启动Service了，启动Service和启动Activity 差很少，经过Intent 来启动，代码以下：

@Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.start_service:
                Intent intent = new Intent(this,SimpleService.class);
                // 启动服务
                startService(intent);
                break;
            case R.id.stop_service:
                Intent service = new Intent(this,SimpleService.class);
                // 中止服务
                stopService(service);
                break;
        }
    }复制代码

如上图界面所示，有2 个button ，分别是启动服务和中止服务，分别点击 startService 和StopService 的button ,看看生命周期回调方法打印的日志：

小结：经过startService 方式启动的服务，服务会无限期的在后台运行，直到经过stopService 或 stopSelf 来终止服务。服务独立于启动它的组件，也就是说，当组件启动服务后，组件和服务就在也没有关系了，就算启动它的组件被销毁了，服务照样在后台运行。经过这种方式启动的服务很差与组件之间通讯。

bindService 方式启动服务

除了startService 来启动服务以外，另一种启动服务的方式就是经过bindService 方法了，也就是绑定服务，其实经过它的名字就容易理解，绑定即将启动组件和服务绑定在一块儿。前面讲的经过startService 方式启动的服务是与组件相独立的，即便启动服务的组件被销毁了，服务仍然在后台运行不受干扰。可是经过bindSerivce 方式绑定的服务就不同了，它与绑定组件的生命周期是有关的。以下：

多个组件能够绑定到同一个服务上，若是只有一个组件绑定服务，当绑定的组件被销毁时，服务也就会中止了。若是是多个组件绑定到一个服务上，当绑定到该服务的全部组件都被销毁时，服务才会中止。

bindService 绑定服务和startService 的生命周期是不同，bindServie 的生命周期以下：onCreate －> onBind －> onUnbind －>onDestroy。其中重要的就是onBind 和onUnbind 方法。

onBind(): 当其余组件想经过bindService 与服务绑定时，系统将会回调这个方法，在实现中，你必须返回一个IBinder接口，供客户端与服务进行通讯，必须实现此方法，这个方法是Service 的一个抽象方法，可是若是你不容许绑定的话，返回null 就能够了。
onUnbind(): 当全部与服务绑定的组件都解除绑定时，就会调用此方法。

了解了这2个方法后，咱们来看一下怎么绑定一个服务。
1，首先，添加一个类继承 Binder ,在Binder 类中添加其余组件要与服务交互的方法，并在onBind() 方法中返回IBinder 实例对象：

public class SimpleService extends Service {
    public static final String TAG = "SimpleService";
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG,"call onBind...");
        //返回IBinder 接口对象
        return new MyBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG,"call onUnbind...");
        return super.onUnbind(intent);
    }

    @Override
    public void onCreate() {
        Log.i(TAG,"call onCreate...");
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Log.i(TAG,"call onStart...");
    }

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

    @Override
    public void onDestroy() {
        Log.i(TAG,"call onDestroy...");
    }

    // 添加一个类继承Binder
    public  class MyBinder extends Binder{
        // 添加要与外界交互的方法
        public String getStringInfo(){
          return "调用了服务中的方法";
        }
    }

}复制代码

2, 绑定服务的时候，须要提供一个ServiceConnection 接口，在接口回调中获取Binder 对象，与服务进行通讯。

private SimpleService.MyBinder mMyBinder;
    // 绑定/解除绑定 Service 回调接口
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 绑定成功后回调
            //1 ,获取Binder接口对象
            mMyBinder = (SimpleService.MyBinder) service;
            //2, 从服务获取数据
            String content = mMyBinder.getStringInfo();
            // 3,界面提示
            Toast.makeText(ServiceSimpleActivity.this,content,Toast.LENGTH_LONG).show();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
           // 解除绑定后回调
            mMyBinder = null;
        }
    };复制代码

3,绑定和解除绑定服务

case R.id.bind_service:
                Intent intent = new Intent(this,SimpleService.class);
                // 绑定服务
                bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
                break;
            case R.id.unbind_service:
                // 解除绑定服务
                unbindService(mConnection);

                break;复制代码

点击绑定按钮，即绑定服务，而且在onServiceConnected 中获得MyBinder 对象，就能够经过这个对象和服务通讯了，例子中咱们Toast 了从服务中获取的字符串：

生命周期方法调用以下：

能够看到，绑定服务的生命周期内依次调用了onCreate ,onBind,onUnbind 和 onDestroy 方法，只有中间两个生命周期方法与startService 启动服务是不一样的。一张图就能看清两种方式的生命周期的异同：

tips: Service 的生命周期方法不一样于Activity ，不须要调用超类的生命周期方法，如：不用调用 super.onCreate（）

多个组件绑定同一服务

Service 是支持多个组件绑定在同一个服务的，第一个组件绑定是会回调 onCreate 生命周期方法，后续的绑定只会调用onBind方法，返回IBinder给客户端。当绑定在服务上的组件都调用unbindService 解除服务或者组件自己就已经被系统回收，那么服务也就会被中止回收了，会回调onUnbind 和 onDestroy 方法。

Service 与应用组件通讯的几种方式

1,BroadcastReceiver
经过前文咱们知道，startService方式启动的服务在后台，无限期地运行，而且与启动它的组件是独立的，启动Service 以后也就与启动它的组件没有任何关系了。所以它是不能与启动它的组件之间相互通讯的。虽然Service 没有提供这种启动方式的通讯方法，咱们仍是能够经过其余方式来解决的，这就用到了BroadcastReceiver。

场景描述：经过startService 启动一个长期在后台运行的下载图片服务，而后在界面上点击下载按钮，经过intent 传递一个下载连接给Service，在下载完成后，经过BroadcastReceiver 通知Activity 界面显示图片。看一下代码实现：

Service代码以下：

public class DownloadService extends Service {
    public static final String IMAGE = "iamge_url";
    public static final String RECEIVER_ACTION = "com.zhouwei.simpleservice";
    private static final String TAG = "DownloadService";
    public static final String ACTION_START_SERVICER = "com.zhouwei.startservice";
    public static final String ACTION_DOWNLOAD = "com.zhouwei.startdownload";
    private Looper mServiceLooper;
    private ServiceHandler mServiceHandler;
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper){
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            // 工做线程作耗时下载
            String url = (String) msg.obj;
            Bitmap bitmap = null;
            try {
                bitmap = Picasso.with(getApplicationContext()).load(url).get();
                Intent intent = new Intent();
                intent.putExtra("bitmap",bitmap);
                intent.setAction(RECEIVER_ACTION);
                // 通知显示
                LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);
            } catch (IOException e) {
                e.printStackTrace();
            }


            //工做完成以后，中止服务
            stopSelf();
        }
    }
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    public void onCreate() {
        // 开启一个工做线程作耗时工做
        HandlerThread thread = new HandlerThread("ServiceHandlerThread", Process.THREAD_PRIORITY_BACKGROUND);
        thread.start();
        // 获取工做线程的Looper
        mServiceLooper = thread.getLooper();
        // 建立工做线程的Handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG,"call onStartCommand...");
        if(intent.getAction().equals(ACTION_DOWNLOAD)){
            handleCommand(intent);
        }else if(intent.getAction().equals(ACTION_START_SERVICER)){
            //do nothing
        }

        return START_STICKY;
    }

    private void handleCommand(Intent intent){
        String url = intent.getStringExtra(IMAGE);
        // 发送消息下载
        Message message = mServiceHandler.obtainMessage();
        message.obj = url;
        mServiceHandler.sendMessage(message);
    }
}复制代码

新建了一个DownloadService ，在里面启动了一个工做线程，在线程里下载图片，而后经过BroadcastReceiver 通知Activity显示。

Activity的代码很简单，注册BroadcastReceiver，在onReceiver中显示图片就行了，代码以下：

private ImageView mImageView;
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 显示图片
            Bitmap bitmap = intent.getParcelableExtra("bitmap");
            mImageView.setImageBitmap(bitmap);
        }
    };复制代码

/** * 启动下载 */
    private void startDownload(){
        Intent intent = new Intent(this,DownloadService.class);
        // 启动服务
        intent.putExtra(DownloadService.IMAGE,"http://www.8kmm.com/UploadFiles/2012/8/201208140920132659.jpg");
        intent.setAction(DownloadService.ACTION_DOWNLOAD);
        startService(intent);
    }复制代码

效果以下：

如上就完成了使用BroadcastReceiver 完成和组件和Service的通讯。

2, LocaService 使用Binder 和服务通讯
既然经过startService 启动的服务与启动它的组件是独立的。相互通讯比较麻烦，那么Google也提供了二者之间的通讯方法，那就是组件绑定服务，也就是上文讲的经过bindService 将组件和服务绑定到一块儿。组件能够获取Service 经过onBind返回的一个IBinder接口，这样二者就能够通讯了，这也是Service 应用类通讯比较经常使用的方式。

下面就模拟一个用服务播放音乐的例子来说一下组件经过Binder 接口和服务之间通讯。
首先定义一个通讯的接口 IPlayer：

/** * Created by zhouwei on 17/5/11. */

public interface IPlayer {
    // 播放
    public void play();
    // 暂停
    public void pause();
    // 中止
    public void stop();
    // 获取播放进度
    public int getProgress();
    // 获取时长
    public int getDuration();
}复制代码

而后添加一个MusicService 类，继承Service 实现 Iplayer 接口：

public class MusicService extends Service implements IPlayer{
    public static final String TAG = "MusicService";
    private LocalService mBinder = new LocalService();
    public class LocalService extends Binder{
        public MusicService getService(){
            return MusicService.this;
        }
    }

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

    @Override
    public void play() {
        Log.i(TAG,"music play...");
    }

    @Override
    public void pause() {
        Log.i(TAG,"music pause...");
    }

    @Override
    public void stop() {
        Log.i(TAG,"music stop...");
    }

    @Override
    public int getProgress() {
        return 100;
    }

    @Override
    public int getDuration() {
        return 10240;
    }
}复制代码

其中比较重要的就是内部类LocalService ，继承Binder ,里面提供一个getService 方法，返回MusicService 实例，组件经过IBinder 获取到Music 实例后，就能够和Service之间相互通讯啦！

Activity中代码以下：

private MusicService.LocalService mLocalService;
    private MusicService mMusicService;
    // 绑定/解除绑定 Service 回调接口
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //1 ,获取Binder接口对象
            mLocalService = (MusicService.LocalService) service;
            //2, 获取MusicService 实例
            mMusicService = mLocalService.getService();

            // 只要拿到Music Service 实例以后，就能够调用接口方法了
            // 能够经过它来播放／暂停音乐，还能够经过它来获取当前播放音乐的进度，时长等等

            mMusicService.play();

            mMusicService.pause();

            mMusicService.stop();

            int progress = mMusicService.getProgress();
            Log.i(MusicService.TAG,"progress:"+progress);

            int duration = mMusicService.getDuration();
            Log.i(MusicService.TAG,"duration:"+duration);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
           // 解除绑定后回调
            mMusicService = null;
            mLocalService = null;
        }
    };复制代码

获取到MusicService 后，就能够调用接口方法了，好比：播放音乐，暂停、中止、获取进度等等。
看一下打印的日志：

使用AIDL 通讯（跨进城通讯IPC）
AIDL（Android 接口定义语言）执行全部将对象分解成原语的工做，操做系统能够识别这些原语并将它们编组到各进程中，以执行 IPC。若是不是多线程访问服务的话，也可使用Messenger来跨进城通讯，Messenger
方法其实是以 AIDL 做为其底层结构。Messenger
会在单一线程中建立包含全部客户端请求的队列，以便服务一次接收一个请求。不过，若是您想让服务同时处理多个请求，则可直接使用 AIDL。在此状况下，您的服务必须具有多线程处理能力，并采用线程安全式设计。如需直接使用 AIDL，您必须建立一个定义编程接口的 .aidl
文件。Android SDK 工具利用该文件生成一个实现接口并处理 IPC 的抽象类，您随后可在服务内对其进行扩展。

因为篇幅有限，AIDL 实现进程间的通讯后面单独出一篇文章讲，这里就再也不啰嗦了。

注意：只有容许不一样的客户端用IPC 方式访问服务，而且想要在服务中处理多线程时，采用AIDL,若是不想经过IPC实现不一样应用的访问，直接用前面所讲的继承Binder ，用接口通讯就能够了。

Service 总结

Service 有2种启动方式，startService 启动服务，服务启动起来后，在后台无限期运行，直到经过stopService 或者 stopSelf 中止服务，服务与组件独立，通讯比较困难（但仍是有办法的，经过BroadcastReceiver ）。另外一种方式就是 bindService 即绑定服务，组件和服务绑定在一块儿，服务的生命后期受组件影响，若是绑定到服务的组件所有被销毁了，那么服务也就会中止了。绑定服务的方式一般用于组件和服务之间须要相互通讯。startService 这种方式通常用于在后台执行任务，而不须要返回结果给组件。 这两种方式并不是彻底独立，也就是说，你能够绑定已经经过 startService 启动起来的服务，能够经过在Intent 中添加Action 来标示要执行的动做。好比：经过Intent Action 标记要播放的音乐，调用startService 来启动音乐服务播放音乐，在界面须要显示播放进度的时候，能够经过binderService 来绑定服务，从而获取歌曲信息。这种状况下，Service 须要实现两种方式的生命周期。这种状况下，除非全部客户端都已经取消绑定，不然经过stopService 或者 stopSelf 是不能中止服务的。

Service 是运行在主线程中的，所以不能执行耗时的或者密集型的任务，若是要执行耗时操做或者密集型计算任务，请在服务中开启工做线程，在线程中执行。或者使用下面一节将要讲的IntentService。

IntentService

IntentService 是Service 的子类，它使用工做线程逐一处理全部启动请求，果您不要求服务同时处理多个请求，这是最好的选择。您只需实现 onHandIntent方法便可，该方法会接收每一个启动请求的 Intent，使您可以执行后台工做。

IntentService 示例

IntentService 默认为咱们开启了一个工做线程，在任务执行完毕后，自动中止服务，所以在咱们大多数的工做中，使用IntentService 就够了，而且IntentService 比较简单，只要实现一个方法OnHandleIntent，接下来看一下示例：

IntentService 扩展类：

public class MyIntentService extends IntentService {
    public static final 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) {
      // 这里已是工做线程，在这里执行操做就行

       boolean isMainThread =  Thread.currentThread() == Looper.getMainLooper().getThread();
        Log.i(TAG,"is main thread:"+isMainThread);

        // 执行耗时下载操做
        mockDownload();
    }

    /** * 模拟执行下载 */
    private void mockDownload(){
       try {
           Thread.sleep(5000);
           Log.i(TAG,"下载完成...");
       }catch (Exception e){
           e.printStackTrace();
       }
    }
}复制代码

而后启动服务，看一下打印的日志，以下图：

判断了是否为主线程，结果为false ,说明是开启了一个工做线程，5s 以后，打印了下载完成，而且自动中止了服务。

IntentService 源码浅析

IntentService 自动为咱们开启了一个线程来执行耗时操做，而且在任务完成后自动中止服务，那么它是怎么作的呢？咱们看一下源码一探究竟。其实IntentService 的源码很是简单，就一百多行。一块儿看一下：

// 1,有一个Looper 变量和一个ServiceHandler 变量，ServiceHander 继承Handler 处理消息
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
           // 在工做线程中调用onHandleIntent，子类根据Intent传递的数据执行具体的操做
            onHandleIntent((Intent)msg.obj);
          // 任务执行完毕后，自动中止Service
            stopSelf(msg.arg1);
        }
    }
//2, 在OnCreate 方法中，建立了一个线程HandlerThread ，并启动线程
// 而后获取工做线程的Looper ，并用Looper 初始化Handler(咱们都知道Handler 的建立须要一依赖Looper)
 public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
//3, 在onStart()方法中发送消息给Handler,而且把Intent 传给了Handler 处理
 @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }
// 4，onStartCommand 直接调用的是onStart方法
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }
// 5 最后就是一个子类须要实现的抽象方法，这个方法在handleMessage中调用，也就是在工做线程中执行。
 protected abstract void onHandleIntent(@Nullable Intent intent);复制代码

上面代码中注释得很清楚，下面用一张图来看一下整个过程.

代码很简单，IntentService的源码看着是否是很熟悉？固然很熟悉，前面使用Service的时候，在Service 里面开启工做线程其实就和Intent Service的代码差很少。在onCreate中建立线程，启动，初始化Handler和Looper ，而后在onStartCommand中发送消息给Handler 处理任务。

IntentService 总结

IntentService是Service 的子类，默认给咱们开启了一个工做线程执行耗时任务，而且执行完任务后自动中止服务。扩展IntentService比较简单，提供一个构造方法和实现onHandleIntent 方法就可了，不用重写父类的其余方法。可是若是要绑定服务的话，仍是要重写onBind 返回一个IBinder 的。使用Service 能够同时执行多个请求，而使用IntentService 只能同时执行一个请求。

以上就是对Service 和IntentService的详细总结，若是问题，欢迎讨论。全部Demo代码已上传Github:github.com/pinguo-zhou…（包含我全部博客的所讲的知识点的Demo代码）

参考：
API Guides 服务
 Android 接口定义语言 (AIDL)