Service是android四大组件之一，它与Activity非常类似，最大的区别就是Activity在前台运行，主要作用于界面的交互，而Service是在后台运行的一个服务，它没有界面。
Service的创建步骤：
（1）定义一个继承Service的子类；
（2）在AndroidManifest.xml文件中配置该Service。
与activity类似，Service也有自己的生命周期方法，具体如下：
abstract IBinder onBind（Intent intent）：该方法是重写Service必须实现的一个方法，方法中返回一个Binder对象，我们可以通过该Binder对象与Service进行通信。
void onCreate （）：当Service第一次被创建成功后，将会回调该方法，主要做一些初始化操作。
void onDestroy（）：当Service被关闭之前会调用改方法，主要做一些Service的清理与保存工作。
void onStartCommand（）：每次客户端调用startService（Intent）后方法启动Service时，Service都会回调改方法进行相关操作。
boolean onUnbind（）：当绑定改Service上的所有客户端全都断开连接时，将会调用改回回调方法。
下面举例子介绍一下Service组件的简单应用
1、Service的创建、配置、启动与停止
MyService类：这个类只是重写了一些方法，并打印一些log，为了清楚说明Service启动时的方法回调
<span style="font-family:FangSong_GB2312;font-size:18px;">import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service{
private String TAG = "MyService";
//必须实现，返回IBinder对象，用于与Service组件进行通信，此处返回null，具体后面详细介绍
@Override
public IBinder onBind(Intent intent) {
return null;
}
//Service被创建时回调的方法
@Override
public void onCreate(){
Log.i(TAG, "创建Service调用onCreate()");
}
//Service被启动时回调的方法
@Override
public int onStartCommand(Intent intent, int flags, int startId){
Log.i(TAG, "启动Service调用onStartCommand");
/*
* 这里返回状态有三个值，分别是:
* 1、START_STICKY：当服务进程在运行时被杀死，系统将会把它置为started状态，但是不保存其传递的Intent对象，之后，系统会尝试重新创建服务;
* 2、START_NOT_STICKY：当服务进程在运行时被杀死，并且没有新的Intent对象传递过来的话，系统将会把它置为started状态，
* 但是系统不会重新创建服务，直到startService(Intent intent)方法再次被调用;
* 3、START_REDELIVER_INTENT：当服务进程在运行时被杀死，它将会在隔一段时间后自动创建，并且最后一个传递的Intent对象将会再次传递过来。
*/
return START_STICKY;
}
//Service销毁时回调的方法
@Override
public void onDestroy(){
super.onDestroy();
Log.i(TAG, "销毁Service调用onDestroy()");
}
}</span>
定义了Service之后需要在AndroidManifest.xml文件中配置该Service，即在AndroidManifest.xml文件中application标签内增加如下的配置片段来配置service：
<span style="font-family:FangSong_GB2312;font-size:18px;"><!-- 配置一个service组件 -->
<service android:name=".MyService">
<intent-filter>
<!-- 为该组件的intent-filter配置action -->
<action android:name="com.example.MY_SERVER"/>
</intent-filter>
</service></span>
当service开发完成之后，接下来就可以在程序中运行service了，android中运行service有如下两种方法：
1）通过Context的startService（）方法来启动service，用该方法启动的service，访问者与改Service没有关联，当访问者退出了，Service仍然运行。
2）通过Context的bindService（）方法启动service，用该方法启动service，访问者与Service绑定在一起，访问者一旦退出，service也就终止。
下面程序使用activity作为service的访问者，界面中有两个按钮，布局文件很简单，这里就不给出，一个按钮用于启动service，一个按钮用于关闭service
代码如下MainActivity：
<span style="font-family:FangSong_GB2312;font-size:18px;">public class MainActivity extends Activity implements OnClickListener{
private Button start_service;
private Button stop_service;
private TextView text;
private Intent intent;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initView();
}
private void initView() {
text = (TextView) findViewById(R.id.text);
start_service = (Button) findViewById(R.id.start_service);
stop_service = (Button) findViewById(R.id.stop_service);
start_service.setOnClickListener(this);
stop_service.setOnClickListener(this);
//创建启动service的Intent
intent = new Intent(MainActivity.this, MyService.class);
}
@Override
public void onClick(View v) {
switch(v.getId()){
case R.id.start_service:
//启动service
startService(intent);
text.setText("start_service");
break;
case R.id.stop_service:
//停止service
stopService(intent);
text.setText("stop_service");
break;
}
}
}</span>
activity的界面展示如下：
点击“开启SERVER”按钮，控制台输出的log如下：
再次点击“开启SERVER”按钮，控制台会打印启动"Service调用onStartCommand"；
点击“停止SERVICE”按钮，控制台会打印“销毁Service调用onDestroy()”。
这里就不截图了，读者可以自己运行上面代码
2、绑定本地的Service并与之通信
在现实应用中，我们经常需要在Service执行一些操作，并在activity中获取操作的返回值，也就是要求能与Service进行通信。
我们前面写的程序通过startService（）和stopService（）启动、关闭Service时，Service和访问者之间基本不存在太多的关联，因此Service和访问者之间也就无法进行通信和数据交换。
如果我们需要访问者和Service之间能进行通信，则可以使用bindService（）和unbindService（）方法启动和关闭服务。
bindService方法：bindService(Intent service, ServiceConnection conn, int flags)，该方法有三个参数，下面对这三个参数逐一介绍：
1）service：该参数通过Intent指向要启动的Service。
2）conn：该参数是一个ServiceConnection对象，该对象用于监听访问者与Service之间的连接情况。当连接成功是会回调该对象的onServiceConnected（ComponentName name， IBinder service）方法，其中service就是Service类OnBind的返回值；当连接断开时将会回调该对象的onServiceDiscinnected（ComponentName name）方法。
3）flags：指定绑定时是否自创建Service（如果Service还未创建）。0为不创建、BIND_AUTO_CREATE为自创建。
注意上面第二个参数对象的onServiceConnected方法有个IBinder对象，该对象即可实现与绑定的Server进行通讯。
在实际开发中，我们通常会继承Binder（IBinder的实现类）来实现自己的IBinder对象，下面我们来看一个实例：
<span style="font-family:FangSong_GB2312;font-size:18px;">public class BindService extends Service{
private int count;
private boolean quit;
private MyBinder binder = new MyBinder();
public class MyBinder extends Binder{
public int getCount(){
//获取Service中的count
return count;
}
}
//必须实现的方法，返回IBinder对象
@Override
public IBinder onBind(Intent intent) {
return binder;
}
@Override
public void onCreate() {
Log.i("BindService", "onCreate");
super.onCreate();
count = 0;
quit = false;
//启动一个线程，动态更新count的值
new Thread(){
@Override
public void run(){
while(!quit){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
//Log.i("BindService", count+"-------");
}
}
}.start();
}
@Override
public boolean onUnbind(Intent intent) {
return super.onUnbind(intent);
}
@Override
public void onDestroy() {
this.quit = true;
super.onDestroy();
}
}</span>
上面的Service类中我们必须实现onBind方法返回一颗可以访问Service的count值得IBinder对象，该对象会被Service返回给调用者。在oncreate方法中，我们创建另一个线程，用时更新count的值。值得注意的事，由于server也是运行在主线程的，所以不能做耗时的操作，如果需要执行耗时的操作，需要创建子线程开完成。
下面我们来看一下通过Activity绑定Service，具体代码如下：
<span style="font-family:FangSong_GB2312;font-size:18px;">public class SeconActivity extends Activity implements View.OnClickListener{
private TextView text;
private Button bind;
private Button unbind;
private Intent intent;
private boolean quit = false;
private BindService.MyBinder binder;
private Handler hander = new Handler(){
@Override
public void handleMessage(Message msg) {
//收到消息后更新UI（关于Handler，后面的博客会具体讲解）
text.setText(msg.arg1+"");
}
};
private ServiceConnection conn = new ServiceConnection() {
//访问者与Service连接成功时将回调此方法，得到IBinder对象来与Service进行通信
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.i("Activity", "---onServiceConnected----");
quit = true;
binder = (MyBinder) service;
//拿到binder后，启动一个新线程，来每个一秒从Service取出count的值
new Thread(action).start();
}
//访问者与Service断开连接将回调此方法
@Override
public void onServiceDisconnected(ComponentName name) {
quit = false;
Log.i("Activity", "---onServiceDisconnected----");
}
};
private Runnable action = new Runnable() {
@Override
public void run() {
while(quit){
try {
Thread.sleep(1000);
if(binder != null){
//取到count值后，向主线程发送一个消息，让主线程来更新UI
Message message = new Message();
message.arg1 = binder.getCount();
hander.sendMessage(message);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_two);
initView();
}
private void initView() {
intent = new Intent();
intent.setAction("com.example.MY_SERVER");
bind = (Button) findViewById(R.id.bind);
unbind = (Button) findViewById(R.id.unbind);
text = (TextView) findViewById(R.id.text);
bind.setOnClickListener(this);
unbind.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.bind:
//绑定Service
if (!bindService(intent, conn, Service.BIND_AUTO_CREATE)) {
Log.e("bindService", "Could not bind to Bluetooth AVRCP CT Service");
}
else
{
Log.d("bindService","bind successfully"+binder);
}
//bindService(intent, conn, Service.BIND_AUTO_CREATE);
break;
case R.id.unbind:
text.setText("取消绑定");
unbindService(conn);
break;
default:
break;
}
}
}</span>
代码中有详细的解释，大家可以研读一下。代码主要做的事情就是通过Activity绑定一个Service，然后通过得到的Binder来访问Service中的资源。
对于Service的onBind()方法所返回的IBinder对象来讲，他可以被当成该Service组件遂返回的回调对象，Service允许客户端用户通过IBinder对象来访问内部的数据，这样就可以实现客户端与Service之间通信。
3.跨进程调用Service
Android中，各应用程序都运行在自己的进程中，进程之间一般无法直接进行数据交换的，我们上面是现在的代码是指Activity和Service在同一个进程，这样就可以方便的通信，可如果不在一个进程，那么要进行通信就不是那么容易了。
android跨进程通信的方式很多，比如Bundle、文件共享、AIDL、Messenger、ContentProvider、Socket以及Broadcast方式。其中AIDL和Messenger用的是比较多的，他们都是基于binder实现的，具体细节这里就不多讲了，我以后会专门出类似的博客，请关注。
由于AIDL比较复杂，这里我选用Messenger来实现跨进程Server通信，Messenger实际是对AIDL的一次封装。
首先我们看一下服务端，我们创建一个Service来处理客户端请求，并且收到用户请求后向用户返回一条消息，具体代码如下：
<span style="font-family:FangSong_GB2312;font-size:18px;">public class MessengerService extends Service{
private Handler MessengerHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.i("MessengerService", msg.getData().getString("msg"));
//拿到客户端传过来的Messenger对象
Messenger client = msg.replyTo;
//封装要反悔给客户端的消息
Message replyMessage = Message.obtain(null, 2);
Bundle bundle = new Bundle();
bundle.putString("reply", "恩，收到您的消息！");
replyMessage.setData(bundle);
try {
//利用客户端的Messenger为客户端发送消息
client.send(replyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
};
//创建服务端Messenger
private final Messenger mMessenger = new Messenger(MessengerHandler);
@Override
public IBinder onBind(Intent intent) {
Log.i("Service", "onBind");
//向客户端返回Ibinder对象，客户端利用该对象访问服务端
return mMessenger.getBinder();
}
@Override
public void onCreate() {
Log.i("Service", "onCreate");
super.onCreate();
}
}</span>
然后注册Service，让其在单独的进程中运行
<span style="font-family:FangSong_GB2312;font-size:18px;"><span style="white-space:pre"> </span><service android:name=".Messager.MessengerService"
android:process=":remote">
<intent-filter>
<action android:name="com.example.MESSENGER_SERVER"/>
</intent-filter>
</service> </span>
接下来就看客户端了，客户端实现也比较简单，首先绑定远程进程的Service，绑定成功后，根据Service返回的IBinder对象创建Messenger对象，并使用此对象发送消息，为了能收到Service端返回的消息，客户端创建了一个资深的Messenger发送给Service端，Service端就可以通过客户端的Messenger想客户端发送消息了，具体代码如下：
<span style="font-family:FangSong_GB2312;font-size:18px;">public class MessengerActivity extends Activity{
private Messenger mService;
private Button bind;
private TextView text;
private Intent intent;
private ServiceConnection conn = new ServiceConnection(){
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//根据得到的IBinder对象创建Messenger
mService = new Messenger(service);
Message msg = Message.obtain(null, 1);
Bundle bundle = new Bundle();
bundle.putString("msg", "您好，Service");
msg.setData(bundle);
msg.replyTo = mGetMessenger;
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
//为了收到Service的回复，客户端需要创建一个接收消息的Messenger和Handler
private Handler MessengerHander = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 2:
Log.i("MessengerActivity", msg.getData().getString("reply"));
text.setText(msg.getData().getString("reply"));
break;
default:
super.handleMessage(msg);
}
}
};
private Messenger mGetMessenger = new Messenger(MessengerHander);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_messenger);
init();
}
private void init() {
intent = new Intent(MessengerActivity.this, MessengerService.class);
bind = (Button) findViewById(R.id.bind);
text = (TextView) findViewById(R.id.text);
bind.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//bindService(intent, conn, Context.BIND_AUTO_CREATE);
if (!bindService(intent, conn, Context.BIND_AUTO_CREATE)) {
Log.e("bindService", "Could not bind to Bluetooth AVRCP CT Service");
}
else
{
Log.d("bindService","bind successfully");
}
}
});
}
@Override
protected void onDestroy(){
unbindService(conn);
super.onDestroy();
}
}
</span>
代码看起来比较长，可是很简单，相信读者都能读懂。我们运行程序后，看一下log，很闲人客户端向Service发送了一条消息，也收到了Service返回的消息，这说明我们跨进程和Service通信实现成功。
到这里，android的四大组件之一Service就介绍完毕，谢谢大家的阅读！