Service 对于广大的Android开发者来说算是耳熟能详了，作为Android的四大组件之一，在我们的开发中也起着重要的作用，在Android面试中，Service相关的问题也是面试官问得比较多的，当别人问你，Service 到底是什么的时候？你可能随口就能答得上来，Service是一个在后台执行长时间运行操作而不用提供用户界面的应用组件，可由其他组件启动，即使用户切换到其他应用程序，Service 仍然在后台继续运行。没错，这是Service的概念，作为Android开发，或多或少都知道一些，但是不是每个人把所有知识点都了解得透测。前段时间由于项目中有用到Service，因此，本篇文章对Service的用法做一个总结。
Service 目录.png
Service 和Activity 一样同为Android 的四大组件之一，并且他们都有各自的生命周期，要想掌握Service 的用法，那就要了解Service 的生命周期有哪些方法，并且生命周期中各个方法回调的时机和作用。有一点比较重要，Service 有两种启动方式，并且它的两种启动方式的生命周期是不一样的。接下来来分别看一下两种启动方式各自的生命周期方法。
当应用组件通过startService方法来启动Service 时，Service 则会处于启动状态，一旦服务启动，它就会在后台无限期的运行，生命周期独立于启动它的组件，即使启动它的组件已经销毁了也不受任何影响，由于启动的服务长期运行在后台，这会大量消耗手机的电量，因此，我们应该在任务执行完成之后调用stopSelf()来停止服务，或者通过其他应用组件调用stopService 来停止服务。
startService 启动服务后，会执行如下生命周期：onCreate() －>onStartCommand() －> onStart()(现在已经废弃) －> onDestroy() 。具体看一下它的几个生命周期方法：
onCreate() :首次启动服务的时候，系统会调用这个方法，在onStartCommand 和 onBind 方法之前，如果服务已经启动起来了，再次启动时，则不会调用此方法，因此可以在onCreate 方法中做一些初始化的操作，比如要执行耗时的操作，可以在这里创建线程，要播放音乐，可以在这里初始化音乐播放器。
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> 标签下：
<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; } }界面.png
如上图界面所示，有2 个button ，分别是启动服务和停止服务，分别点击 startService 和StopService 的button ,看看生命周期回调方法打印的日志：
生命周期打印日志.png
小结：通过startService 方式启动的服务，服务会无限期的在后台运行，直到通过stopService 或 stopSelf 来终止服务。服务独立于启动它的组件，也就是说，当组件启动服务后，组件和服务就再也没有关系了，就算启动它的组件被销毁了，服务照样在后台运行。通过这种方式启动的服务不好与组件之间通信。
除了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 了从服务中获取的字符串：
绑定服务.png
生命周期方法调用如下：
image.png
可以看到，绑定服务的生命周期内依次调用了onCreate ,onBind,onUnbind 和 onDestroy 方法，只有中间两个生命周期方法与startService 启动服务是不同的。一张图就能看清两种方式的生命周期的异同：
Service生命周期.png
tips: Service 的生命周期方法不同于Activity ，不需要调用超类的生命周期方法，如：不用调用 super.onCreate（）
Service 是支持多个组件绑定在同一个服务上的，第一个组件绑定是会回调 onCreate 生命周期方法，后续的绑定只会调用onBind方法，返回IBinder给客户端。当绑定在服务上的组件都调用unbindService 解除绑定服务或者组件本身就已经被系统回收，那么服务也就会被停止回收了，会回调onUnbind 和 onDestroy 方法。
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); }效果如下：
Service下载图片.gif
如上就完成了使用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 后，就可以调用接口方法了，比如：播放音乐，暂停、停止、获取进度等等。 看一下打印的日志：
模拟播放音乐.png
** 使用AIDL 通信 （跨进城通信IPC）** AIDL（Android 接口定义语言）执行所有将对象分解成原语的工作，操作系统可以识别这些原语并将它们编组到各进程中，以执行 IPC。 如果不是多线程访问服务的话，也可以使用Messenger来跨进城通信，Messenger 方法实际上是以 AIDL 作为其底层结构。Messenger 会在单一线程中创建包含所有客户端请求的队列，以便服务一次接收一个请求。 不过，如果您想让服务同时处理多个请求，则可直接使用 AIDL。 在此情况下，您的服务必须具备多线程处理能力，并采用线程安全式设计。如需直接使用 AIDL，您必须创建一个定义编程接口的 .aidl 文件。Android SDK 工具利用该文件生成一个实现接口并处理 IPC 的抽象类，您随后可在服务内对其进行扩展。
由于篇幅有限，AIDL 实现进程间的通信后面单独出一篇文章讲，这里就不再啰嗦了。
注意：只有允许不同的客户端用IPC 方式访问服务，并且想要在服务中处理多线程时，采用AIDL,如果不想通过IPC实现不同应用的访问，直接用前面所讲的继承Binder ，用接口通信就可以了。
Service 有2种启动方式，startService 启动服务，服务启动起来后，在后台无限期运行，直到通过stopService 或者 stopSelf 停止服务，服务与组件独立，通信比较困难（但还是有办法的，通过BroadcastReceiver ）。另一种方式就是 bindService 即绑定服务，组件和服务绑定在一起，服务的生命后期受组件影响，如果绑定到服务的组件全部被销毁了，那么服务也就会停止了。绑定服务的方式通常用于组件和服务之间 需要相互通信。startService 这种 方式一般用于在后台执行任务，而不需要返回结果给组件。 这两种方式并非完全独立，也就是说，你可以绑定已经通过 startService 启动起来的服务，可以通过在Intent 中添加Action 来标示要执行的动作。比如：通过Intent Action 标记要播放的音乐，调用startService 来启动音乐服务播放音乐，在界面需要显示播放进度的时候，可以通过binderService 来绑定服务，从而获取歌曲信息。这种情况下，Service 需要实现两种方式的生命周期。这种情况下，除非所有客户端都已经取消绑定，否则通过stopService 或者 stopSelf 是不能停止服务的。
Service 是运行在主线程中的，因此不能执行耗时的或者密集型的任务，如果要执行耗时操作或者密集型计算任务，请在服务中开启工作线程，在线程中执行。或者使用下面一节将要讲的IntentService。
IntentService 是Service 的子类，它使用工作线程逐一处理所有启动请求，果您不要求服务同时处理多个请求，这是最好的选择。 您只需实现 onHandIntent方法即可，该方法会接收每个启动请求的 Intent，使您能够执行后台工作。
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(); } } }然后启动服务，看一下打印的日志，如下图：
image.png
判断了是否为主线程，结果为false ,说明是开启了一个工作线程，5s 之后，打印了下载完成，并且自动停止了服务。
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图解.png
代码很简单，IntentService的源码看着是不是很熟悉？当然很熟悉，前面使用Service的时候，在Service 里面开启工作线程其实就和Intent Service的代码差不多。在onCreate中创建线程，启动，初始化Handler和Looper ，然后在onStartCommand中发送消息给Handler 处理任务。
IntentService是Service 的子类，默认给我们开启了一个工作线程执行耗时任务，并且执行完任务后自 动停止服务。扩展IntentService比较简单，提供一个构造方法和实现onHandleIntent 方法就可了，不用重写父类的其他方法。但是如果要绑定服务的话，还是要重写onBind 返回一个IBinder 的。使用Service 可以同时执行多个请求，而使用IntentService 只能同时执行一个请求。
