Android 四大组件详解（二） Service

一开始学Android的时候就开始听说Service的相关内容，但是真正接触到Service并且使用它是在几个月前的一次IM（即时通讯）的实现上，IM的实现是基于Mqtt协议的，所以有一个Service专门来负责IM相关的操作，有空也会简单介绍一下Mqtt相关的知识。

Service是后台的概念，但它是运行在主线程的，这点很重要，千万别跟Thread搞混，也就是说如果你在Service中执行耗时操作的话是会带来ANR（应用无响应）错误的。Service跟Activity一样也有自己的生命周期，下面就让我们从以下几点来简单介绍一下Service的内容吧。

1. 如何使用Service

2. Service启动方式（bindService跟startService）

3. Service生命周期

4. IntentService简介

5.Service细节知识点

一、如何使用Service

启动一个Service之后Service就独立运行。

首先要自己生成一个Service类（这里用JaymeService为例）继承自Service，然后实现相关的方法（比如onCreate， onDestroy之类执行自己想要的操作）。

如果你想要启动Service时候Service跟启动者（Activity或者Application）之间保持联系。

那你就先要写一个自己的Binder类（这里以JaymeBinder为例），JaymeBinder必须继承自Binder类，然后在JaymeBinder中实现一个getService方法把Service本身返回，然后在JaymeService中生成一个JaymeBinder对象（这里叫为mBinder）。这样我们就有了一个mBinder，然后还要重写JaymeService中的onBind方法，把mBinder返回，Service中所要做的事情就是这些。（具体代码看下面！）

package com.scut.jayme.services;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;

import com.scut.jayme.utils.LogUtils;

/**
* 一个用于掌握 Service生命周期 的Service
*
* Created by jayme on 15/12/5.
*/
public class JaymeService extends Service{
private JaymeBinder mBinder = new JaymeBinder();
@Override
public IBinder onBind(Intent intent) {
showMessage("onBind");
return mBinder;
}

@Override
public void onCreate() {
showMessage("onCreate");
super.onCreate();
}

@Override
public void onDestroy() {
showMessage("onDestroy");
super.onDestroy();
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
showMessage("onStartCommand");
return super.onStartCommand(intent, flags, startId);
}

@Override
public boolean onUnbind(Intent intent) {
showMessage("onUnbind");
return super.onUnbind(intent);
}

@Override
public void onRebind(Intent intent) {
showMessage("onRebind");
super.onRebind(intent);
}

private void showMessage(String message){
LogUtils.i("jaymeService", message);
}

/**
* 用于跟Activity建立关联的Binder
*/
public class JaymeBinder extends Binder {
public JaymeService getService(){
return JaymeService.this;
}
}
}

在实现了Service之后，还要通过正确的方式启动Service才能保持启动者跟Service之间的联系（这里以MainActivity跟JaymeService绑定为例）。

首先在MainActivity中要生成一个ServiceConnection对象（具体代码如下）

private ServiceConnection mServiceConnection = new ServiceConnection() {
/**
* 当Service跟Activity绑定的时候会回调该函数
* @param name       名称
* @param binder     JaymeService中的mBinder对象
*/
@Override
public void onServiceConnected(ComponentName name, IBinder binder) {
LogUtils.i("jaymeActivity", "onServiceConnected");
/** 这里就获取到了Service对象,然后就可以操作Service了 */
mJaymeService = ((JaymeService.JaymeBinder)binder).getService();
}

@Override
public void onServiceDisconnected(ComponentName name) {
LogUtils.i("jaymeActivity", "onServiceDisconnected");
}
};

这样我们在MainActivity中就有了ServiceConnection对象，那就只差最后一步了，通过bindService方法绑定Service。

首先我们跟启动Activity类似，先生成一个Intent对象，然后调用bindService方法就可以实现Service跟MainActivity的绑定，由于此时MainActivity拥有了JaymeService的引用，也就可以操作JaymeService了，具体代码如下。

/**
* 绑定Service操作
*/
private void bindService(){
Intent bindIntent = new Intent(mContext, JaymeService.class);
bindService(bindIntent, mServiceConnection, BIND_AUTO_CREATE);
mIsBind = true;
}

最后再给出完整的MainActivity代码（包含后面要介绍的内容）

package com.scut.jayme.activitys;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.scut.jayme.R;
import com.scut.jayme.services.JaymeIntentService;
import com.scut.jayme.services.JaymeService;
import com.scut.jayme.utils.LogUtils;

public class MainActivity extends Activity implements View.OnClickListener{
private Context mContext;
private boolean mIsBind = false;
private JaymeService mJaymeService;

private Button mStartServiceButton;
private Button mStopServiceButton;
private Button mBindServiceButton;
private Button mUnbindServiceButton;
private Button mStartIntentServiceButton;

private ServiceConnection mServiceConnection = new ServiceConnection() {
/**
* 当Service跟Activity绑定的时候会回调该函数
* @param name       名称
* @param binder     JaymeService中的mBinder对象
*/
@Override
public void onServiceConnected(ComponentName name, IBinder binder) {
LogUtils.i("jaymeActivity", "onServiceConnected");
/** 这里就获取到了Service对象,然后就可以操作Service了 */
mJaymeService = ((JaymeService.JaymeBinder)binder).getService();
}

@Override
public void onServiceDisconnected(ComponentName name) {
LogUtils.i("jaymeActivity", "onServiceDisconnected");
}
};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mContext = MainActivity.this;
findViews();
initListener();
}

/**
* 查找相关的控件
*/
private void findViews(){
mStartServiceButton = (Button)findViewById(R.id.main_btn_start_service);
mStopServiceButton = (Button)findViewById(R.id.main_btn_stop_service);
mBindServiceButton = (Button)findViewById(R.id.main_btn_bind_service);
mUnbindServiceButton = (Button)findViewById(R.id.main_btn_unbind_service);
mStartIntentServiceButton = (Button)findViewById(R.id.main_btn_start_intent_service);
}

/**
* 初始化监听器
*/
private void initListener(){
mStartServiceButton.setOnClickListener(this);
mStopServiceButton.setOnClickListener(this);
mBindServiceButton.setOnClickListener(this);
mUnbindServiceButton.setOnClickListener(this);
mStartIntentServiceButton.setOnClickListener(this);
}

/**
* 绑定Service操作
*/
private void bindService(){
Intent bindIntent = new Intent(mContext, JaymeService.class);
bindService(bindIntent, mServiceConnection, BIND_AUTO_CREATE);
mIsBind = true;
}
/**
* 解除绑定Service操作
*/
private void unbindService(){
if(mIsBind) {
unbindService(mServiceConnection);
mIsBind = false;
}else{
Toast.makeText(mContext, "Service 已经解除绑定", Toast.LENGTH_SHORT).show();
}
}

/**
* 启动Service操作
*/
private void startService(){
Intent startIntent = new Intent(mContext, JaymeService.class);
startService(startIntent);
}

/**
* 停止Service操作
*/
private void stopService(){
Intent stopIntent = new Intent(mContext, JaymeService.class);
stopService(stopIntent);
}

/**
* 启动 IntentService
*/
private void startIntentService(){
for(int i  = 0; i < 5; i++) {
Intent intent = new Intent(mContext, JaymeIntentService.class);
intent.putExtra("time", System.currentTimeMillis());
startService(intent);
}
}

@Override
public void onClick(View v) {
String toastMessage = null;
switch (v.getId()){
case R.id.main_btn_start_service:
toastMessage = "start service";
startService();
break;

case R.id.main_btn_stop_service:
toastMessage = "stop service";
stopService();
break;

case R.id.main_btn_bind_service:
toastMessage = "bind service";
bindService();
break;

case R.id.main_btn_unbind_service:
toastMessage = "unbind service";
unbindService();
break;

case R.id.main_btn_start_intent_service:
toastMessage = "start IntentService";
startIntentService();
break;

default:
break;
}

if(null != toastMessage){
Toast.makeText(mContext, toastMessage, Toast.LENGTH_SHORT).show();
}
}
}

对应的layout文件activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout 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:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">

<TextView android:text="通过下面操作跟Log信息检查学习Service的生命周期" android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/textView" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Bind"
android:id="@+id/main_btn_bind_service"
android:layout_below="@+id/textView"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:layout_marginTop="44dp" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Start"
android:id="@+id/main_btn_start_service"
android:layout_alignTop="@+id/main_btn_bind_service"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Stop"
android:id="@+id/main_btn_stop_service"
android:layout_below="@+id/main_btn_start_service"
android:layout_alignRight="@+id/main_btn_start_service"
android:layout_alignEnd="@+id/main_btn_start_service" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="UNBIND"
android:id="@+id/main_btn_unbind_service"
android:layout_alignTop="@+id/main_btn_stop_service"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:layout_alignLeft="@+id/main_btn_bind_service"
android:layout_alignStart="@+id/main_btn_bind_service" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="尝试三次启动IntentService"
android:id="@+id/main_btn_start_intent_service"
android:layout_below="@+id/main_btn_stop_service"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"
android:layout_marginTop="129dp" />
</RelativeLayout>

二、Service的启动方式

上面花了比较大的篇幅去介绍如何使用Service，但是只是会用，具体Service的两种启动方式还是没有进行解释，下面就来简单解释一下启动Service的两种方式（startService跟bindService）。

startService方式启动Service

我们先来介绍简单的启动Service方式－－startService，这种方法只要生成一个Intent对象，然后通过MainActivity的startService方法就可以启动一个Service（具体代码如下）。

/**
* 启动Service操作
*/
private void startService(){
Intent startIntent = new Intent(mContext, JaymeService.class);
startService(startIntent);
}

这种方式启动Service之后Service跟启动者（这里是MainActivity）没有什么关系，启动之后Service就会运行自己的生命周期，Service的销毁什么的都跟启动者没有关系了。

startService方式启动Service的关闭方法（stopService）

如果你想要关闭通过startService方式启动的Activity，你也可以通过生成一个Intent对象，然后调用Activity的stopService方法，具体方法如下。

/**
* 停止Service操作
*/
private void stopService(){
Intent stopIntent = new Intent(mContext, JaymeService.class);
stopService(stopIntent);
}

bindService方式启动Service

刚才我们介绍了比较简单的启动Service的方法，下面就来简单介绍一下绑定Service的方法，也就是用bindService方式启动Service。

这种方式启动Service的话就可以在Service跟启动者之间保持一定的联系，启动者也可以操作Service中的相关行为，这样就可以让一些后台的工作放到Service中，然后通过他们之间的关系来进行通信（比如IM中维持心跳连接的操作）。

上面也说了，要以这种方式启动Service，首先要生成一个ServiceConnection对象实现它的回调方法（也就是在回调方法中可以拿到Service中的相关引用达到操作Service的效果），然后在调用bindService的时候把ServiceConnection对象作为参数传进去就ok了，具体代码参看上面就好。

bindService启动方式启动Service的关闭方法

如果你想要关闭通过bindService方式启动的Service，你可以通过调用MainActivity中的stopService方法来关闭Service。这里要注意的一点就是你在调用unbindService的时候必须保证Service是处于bind的状态下的，不然会抛出异常（这也就是Main Activity 中mIsBind的作用）。下面具体看下代码

/**
* 解除绑定Service操作
*/
private void unbindService(){
if(mIsBind) {
unbindService(mServiceConnection);
mIsBind = false;
}else{
Toast.makeText(mContext, "Service 已经解除绑定", Toast.LENGTH_SHORT).show();
}
}

三、Service的生命周期

在介绍了Service的简单使用方式跟启动方式之后，就可以来探索一下Service的生命周期方法了，Service 的生命周期跟Activity的有一点点类似，话不多说，先上图，一切简单明了。



从图我们可以看出两种不同的启动方式Service的生命周期是不一样的（具体的生命周期演示最后会给出一个demo）。

通过startService方式启动

第一次启动调用onCreate->onStartCommand，再次启动当Service处于启动状态时只调用onStartCommand，然后Service自己关闭或者启动者把它关闭就进入onDestroy了。

通过bindService方式启动

第一次启动bindService(Service没有启动时)会调用onCreate->onBind,当已经bind的时候再启动bindService不触发任何回调，启动unbindService的时候会先调用onUnbind，如果此时Service没有跟别的启动者绑定就会进入onDestroy。

需要注意的地方：

当先启动startService还没有调用stopService的时候，此时第一次调用bindService跟unBindService没有任何异常，但当第二次或者更多次调用bindService、unbindService的时候会不触发onBind跟onUnbind（不知道这算不算一个bug，如果您知道希望指出）

四、IntentService的简介

如果你一开始认真看了这篇文章你就知道Service是运行在主线程的，所以要执行耗时操作的话也会带来ANR错误。而IntentService就是一种可以在里面执行耗时操作而不会带来ANR的Service。

具体方法就是自己写一个IntentService（这里使用JaymeIntentService为例）继承自IntentService，然后重写它的onHandleIntent函数，就可以在里面执行耗时的操作。

package com.scut.jayme.services;

import android.app.IntentService;
import android.content.Intent;

import com.scut.jayme.utils.LogUtils;

/**
* 用于测试 IntentService 的相关属性
* Created by jayme on 15/12/5.
*/
public class JaymeIntentService extends IntentService{
public JaymeIntentService() {
super("JaymeIntentService");
}

@Override
protected void onHandleIntent(Intent intent) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
long time = intent.getLongExtra("time", 0);
LogUtils.i("JaymeIntentService", time + "");
}
}

接着在启动者中调用startService就可以让IntentService执行耗时的操作了

/**
* 启动 IntentService
*/
private void startIntentService(){
for(int i  = 0; i < 5; i++) {
Intent intent = new Intent(mContext, JaymeIntentService.class);
intent.putExtra("time", System.currentTimeMillis());
startService(intent);
}
}

五、Service细节知识点

1. Service是运行在主线程的，所以不要在Service中执行耗时操作，不然会带来ANR错误，要执行耗时操作的话要在Service建立新的线程去执行
2. ServiceConnection中的onServiceConnected会在bindService的时候回调，但是onServiceDisconnected在unbindService的时候不一定会调用，而是在Service
被系统强杀或者Service崩溃了的时候会调用

总结：
我们在了解Service的时候首先要了解怎么使用Service，然后熟悉它的两种启动方式（startService跟bindService），熟悉它的生命周期，这样才能熟练地操作Service的相关行为。

补上LogUtils的源码，主要是为了发布版本控制Log输出的需要。

package com.scut.jayme.utils;

import android.util.Log;

/**
* Created by jay on 15/12/5.
*/
public class LogUtils {
private static final boolean SHOW_LOG = true;
private static final String TAG = "liujie";

public static void i(String message){
if(SHOW_LOG) {
Log.i(TAG, message);
}
}

public static void i(String tag, String message){
if(SHOW_LOG){
Log.i(tag, message);
}
}
}

六、Service演示demo



需要源码的可以去我的资源页查找下载（Android Studio源代码）

＊ 上面的一切观点都是个人的理解，如果有不准确的地方还希望大家指出 ＊