下面我们就围绕Service对其进行全面讲解：

(请发邮件到 freeget.one@gmail.com  获得最新翻强软件。)

1.Service生命周期

Service生命周期可以从两种启动Service的模式开始讲起，分别是context.startService()和context.bindService()。

(1).startService的启动模式下的生命周期：当我们首次使用startService启动一个服务时，系统会实例化一个Service实例，依次调用其onCreate和onStartCommand方法，然后进入运行状态，此后，如果再使用startService启动服务时，不再创建新的服务对象，系统会自动找到刚才创建的Service实例，调用其onStart方法；如果我们想要停掉一个服务，可使用stopService方法，此时onDestroy方法会被调用，需要注意的是，不管前面使用了多个次startService，只需一次stopService，即可停掉服务。

(2).bindService启动模式下的生命周期：在这种模式下，当调用者首次使用bindService绑定一个服务时，系统会实例化一个Service实例，并一次调用其onCreate方法和onBind方法，然后调用者就可以和服务进行交互了，此后，如果再次使用bindService绑定服务，系统不会创建新的Service实例，也不会再调用onBind方法；如果我们需要解除与这个服务的绑定，可使用unbindService方法，此时onUnbind方法和onDestroy方法会被调用。

两种模式有以下几点不同之处：startService模式下调用者与服务无必然联系，即使调用者结束了自己的生命周期，只要没有使用stopService方法停止这个服务，服务仍会运行；通常情况下，bindService模式下服务是与调用者生死与共的，在绑定结束之后，一旦调用者被销毁，服务也就立即终止，就像江湖上的一句话：不求同生，但愿同死。

值得一提的是，以前我们在使用startService启动服务时都是习惯重写onStart方法，在Android2.0时系统引进了onStartCommand方法取代onStart方法，为了兼容以前的程序，在onStartCommand方法中其实调用了onStart方法，不过我们最好是重写onStartCommand方法。

以上两种模式的流程如下图所示：

下面我们就结合实例来演示一下这两种模式的生命周期过程。我们新建一个名为service的项目，然后创建一个MyService的服务类，代码如下：

[java]  view plain copy
  1. package com.scott.service;
  2. import android.app.Service;
  3. import android.content.Intent;
  4. import android.os.IBinder;
  5. import android.util.Log;
  6. public class MyService extends Service {
  7. private static final String TAG = "MyService";
  8. @Override
  9. public void onCreate() {
  10. super.onCreate();
  11. Log.i(TAG, "onCreate called.");
  12. }
  13. @Override
  14. public int onStartCommand(Intent intent, int flags, int startId) {
  15. Log.i(TAG, "onStartCommand called.");
  16. return super.onStartCommand(intent, flags, startId);
  17. }
  18. @Override
  19. public void onStart(Intent intent, int startId) {
  20. super.onStart(intent, startId);
  21. Log.i(TAG, "onStart called.");
  22. }
  23. @Override
  24. public IBinder onBind(Intent intent) {
  25. Log.i(TAG, "onBind called.");
  26. return null;
  27. }
  28. @Override
  29. public boolean onUnbind(Intent intent) {
  30. Log.i(TAG, "onUnbind called.");
  31. return super.onUnbind(intent);
  32. }
  33. @Override
  34. public void onDestroy() {
  35. super.onDestroy();
  36. Log.i(TAG, "onDestroy called.");
  37. }
  38. }

然后再AndroidManifest.xml中配置服务信息，不然这个服务就不会生效，配置如下：

[html]  view plain copy
  1. <service android:name=".MyService">
  2. <intent-filter>
  3. <action android:name="android.intent.action.MyService" />
  4. <category android:name="android.intent.category.DEFAULT" />
  5. </intent-filter>
  6. </service>

如果服务只是在本应用中使用，大可以去掉<intent-filter>属性。

服务搭建完成之后，我们就来关注一下调用者MainActivity，它很简单，只有两个按钮，一个是启动服务，另一个是停止服务，我们来看一下他们的点击事件：

[java]  view plain copy
  1. /**
  2. * 启动服务
  3. * @param view
  4. */
  5. public void start(View view) {
  6. Intent intent = new Intent(this, MyService.class);
  7. startService(intent);
  8. }
  9. /**
  10. * 停止服务
  11. * @param view
  12. */
  13. public void stop(View view) {
  14. Intent intent = new Intent(this, MyService.class);
  15. stopService(intent);
  16. }

接下来我们就先点击一次启动按钮，看看都发生了些什么。日志打印结果如下：

当然我们觉得还不过瘾，再点击一次，我们会发现结果略有不同：

我们看到第二次点击时onCreate方法就不再被调用了，而是直接调用了onStartCommand方法（onStartCommand中又调用了onStart方法）。我们选择“Settings->Application s->Running services”就会发现我们刚刚启动的服务：

然后我们点击停止按钮，试图停止服务，我们发现如下现象：

我们会发现onDestroy方法被调用了，此时服务就停止运行了。我们再次查看“Running services”，就会发现MyService这个服务已全无踪迹。

在这个过程中，onBind方法和onUnbind方法始终没被调用，我们下面就让这两位show一下自己。

我们修改一下MainActivity的代码，使其可以可以以bindService的方式启动一个服务，代码如下：

[java]  view plain copy
  1. private ServiceConnection conn = new ServiceConnection() {
  2. @Override
  3. public void onServiceConnected(ComponentName name, IBinder service) {
  4. //connected
  5. Log.i(TAG, "onServiceConnected called.");
  6. }
  7. /**
  8. *  Called when a connection to the Service has been lost.
  9. *  This typically happens when the process hosting the service has crashed or been killed.
  10. *  This does not remove the ServiceConnection itself.
  11. *  this binding to the service will remain active,
  12. *  and you will receive a call to onServiceConnected when the Service is next running.
  13. */
  14. @Override
  15. public void onServiceDisconnected(ComponentName name) {
  16. }
  17. };
  18. /**
  19. * 绑定服务
  20. * @param view
  21. */
  22. public void bind(View view) {
  23. Intent intent = new Intent(this, MyService.class);
  24. bindService(intent, conn, Context.BIND_AUTO_CREATE);
  25. }
  26. /**
  27. * 解除绑定
  28. * @param view
  29. */
  30. public void unbind(View view) {
  31. unbindService(conn);
  32. }

在使用bindService绑定服务时，我们需要一个ServiceConnection代表与服务的连接，它只有两个方法，onServiceConnected和onServiceDisconnected，前者是在操作者在连接一个服务成功时被调用，而后者是在服务崩溃或被杀死导致的连接中断时被调用，而如果我们自己解除绑定时则不会被调用，所以我们这里只研究onServiceConnected这个方法。

看样子是可以去绑定一个服务了，其实还不行，因为我们前面服务中的onBind方法返回值为null，这样是不行的，要想实现绑定操作，必须返回一个实现了IBinder接口类型的实例，该接口描述了与远程对象进行交互的抽象协议，有了它我们才能与服务进行交互。我们于是有了这样的代码：

[java]  view plain copy
  1. @Override
  2. public IBinder onBind(Intent intent) {
  3. Log.i(TAG, "onBind called.");
  4. return new Binder() {};
  5. }

我们返回了一个Binder的实例，而这个Binder恰恰是实现了IBinder接口，所以这样就可以实现绑定服务的操作了，一起来演示一下。

先点击一下绑定按钮，我们会发现在MainActivity中打印日志如下：

似的，onServiceConnected方法被调用了，看来绑定连接已经成功了，看看MyService如何：

onCreate方法和onBind方法被调用了，此时服务已进入运行阶段，如果再次点击绑定按钮，onCreate和onBinder并不会再次被调用，这个过程中它们仅被调用一次。

然后点击解除绑定按钮，我们会发现MyService打印如下：

可以看到onUnbind方法和onDestroy方法被调用了，此时MyService已被销毁，整个生命周期结束。

另一方面，当我们退出MainActivity时，服务也会随之而结束，从这一点上看，MyService可以说是誓死追随着MainActivity。

需要注意的是，在连接中断状态再去做解除绑定操作会引起一个异常，在MainActivity销毁之前没有进行解除绑定也会导致后台出现异常信息，此时我们就要想办法确保不会出现此类情况，可以这样做：

[java]  view plain copy
  1. private boolean binded;
  2. @Override
  3. public void onServiceConnected(ComponentName name, IBinder service) {
  4. binded = true;
  5. }
  6. /**
  7. * 解除绑定
  8. * @param view
  9. */
  10. public void unbind(View view) {
  11. unbindService();
  12. }
  13. @Override
  14. protected void onDestroy() {
  15. super.onDestroy();
  16. unbindService();
  17. }
  18. /**
  19. * 解除服务绑定
  20. */
  21. private void unbindService() {
  22. if (binded) {
  23. unbindService(conn);
  24. binded = false;
  25. }
  26. }

以上就是bindService的生命周期，正如我们上面讲的一样，使用bindService启动服务后调用者和服务绑定到了一起，当调用者被销毁，服务也立即结终止。

通常情况下是这样的，不过也有特殊情况。当startService和bindService在同一场合下使用时，就会出现稍微不同的现象。

如果我们先以startService方式启动服务，然后再用bindService绑定到这个服务，之后使用unbindService解除绑定，此时服务并不会因此而终止，而是继续运行，直到我们使用stopService来停止这个服务。下面我们再修改一下代码以验证这个过程。MyService保持不变，我们只需修改一下MainActivity。MainActivity最新代码如下：

[java]  view plain copy
  1. package com.scott.service;
  2. import android.app.Activity;
  3. import android.content.ComponentName;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.content.ServiceConnection;
  7. import android.os.Bundle;
  8. import android.os.IBinder;
  9. import android.util.Log;
  10. import android.view.View;
  11. public class MainActivity extends Activity {
  12. private static final String TAG = "MainActivity";
  13. @Override
  14. public void onCreate(Bundle savedInstanceState) {
  15. super.onCreate(savedInstanceState);
  16. setContentView(R.layout.main);
  17. }
  18. private ServiceConnection conn = new ServiceConnection() {
  19. @Override
  20. public void onServiceConnected(ComponentName name, IBinder service) {
  21. Log.i(TAG, "onServiceConnected called.");
  22. }
  23. @Override
  24. public void onServiceDisconnected(ComponentName name) {
  25. }
  26. };
  27. /**
  28. * 启动服务
  29. * @param view
  30. */
  31. public void start(View view) {
  32. Intent intent = new Intent(this, MyService.class);
  33. startService(intent);
  34. }
  35. /**
  36. * 绑定服务
  37. * @param view
  38. */
  39. public void bind(View view) {
  40. Intent intent = new Intent(this, MyService.class);
  41. bindService(intent, conn, Context.BIND_AUTO_CREATE);
  42. }
  43. /**
  44. * 解除绑定
  45. * @param view
  46. */
  47. public void unbind(View view) {
  48. unbindService(conn);
  49. }
  50. /**
  51. * 停止服务
  52. * @param view
  53. */
  54. public void stop(View view) {
  55. Intent intent = new Intent(this, MyService.class);
  56. stopService(intent);
  57. }
  58. }

在MainActivity中包含了四个按钮事件，分别是startService、bindService、unbindService和stopService，我们逐一地按下，看看都发生了什么。

首先按下启动服务的按钮，MyService打印如下：

恩，意料之中。然后我们再按下绑定服务的按钮，MyService打印如下：

此时，只有onBind被调用，之后两者就绑定成功。我们再按下解除绑定的按钮，MyService打印如下：

此时，onUnbind方法方法被调用，注意，此时MyService并没有因解除绑定而终止，而是继续运行。也许我们心里会问，如果多次按下绑定服务的按钮或重复以上两个步骤，结果如何呢？答案是onBind和onUnbind都不会再被调用了。看不到onBind被调用，是不是没有绑定成功啊，我们来看一下MainActivity打印信息：

重复按下绑定按钮，几次都绑定成功了。最后我们按下停止服务的按钮，MyService打印如下：

此时，onDestroy被调用了，此时MyService停止了运行，整个生命周期结束。

以上就是关于MyService生命周期的讲解，下面我们来介绍一下如何与服务进行通信。与服务之间的通信可以分为两种，进程内的通信和进程间的通信，前者调用者和服务在同一应用进程内，而后者是分布在不同应用进程中的。

2.进程内与服务通信

进程内与服务通信实际上就是通过bindService的方式与服务绑定，获取到通信中介Binder实例，然后通过调用这个实例的方法，完成对服务的各种操作。我们上面也介绍了不少关于bindService的内容，下面我们就针对实际需求对代码做改动。首先是MyService，代码如下：

[java]  view plain copy
  1. package com.scott.service;
  2. import android.app.Service;
  3. import android.content.Intent;
  4. import android.os.Binder;
  5. import android.os.IBinder;
  6. import android.util.Log;
  7. public class MyService extends Service {
  8. private static final String TAG = "MyService";
  9. @Override
  10. public IBinder onBind(Intent intent) {
  11. Log.i(TAG, "onBind called.");
  12. return new MyBinder();
  13. }
  14. /**
  15. * 绑定对象
  16. * @author user
  17. *
  18. */
  19. public class MyBinder extends Binder {
  20. /**
  21. * 问候
  22. * @param name
  23. */
  24. public void greet(String name) {
  25. Log.i(TAG, "hello, " + name);
  26. }
  27. }
  28. }

我们创建了一个MyBinder的内部类，定义了一个greet方法，在onBind方法中就将这个MyBinder的实例返回，只要调用者获取到这个实例，就可以像拿着游戏手柄一样对服务进行操作。我们来看一下调用者的代码吧，MainActivity代码如下：

[java]  view plain copy
  1. package com.scott.service;
  2. import android.app.Activity;
  3. import android.content.ComponentName;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.content.ServiceConnection;
  7. import android.os.Bundle;
  8. import android.os.IBinder;
  9. import android.view.View;
  10. public class MainActivity extends Activity {
  11. /**
  12. * 绑定对象实例
  13. */
  14. private MyService.MyBinder binder;
  15. @Override
  16. public void onCreate(Bundle savedInstanceState) {
  17. super.onCreate(savedInstanceState);
  18. setContentView(R.layout.main);
  19. }
  20. private ServiceConnection conn = new ServiceConnection() {
  21. @Override
  22. public void onServiceConnected(ComponentName name, IBinder service) {
  23. binder = (MyService.MyBinder) service;  //获取其实例
  24. binder.greet("scott");                  //调用其方法
  25. }
  26. @Override
  27. public void onServiceDisconnected(ComponentName name) {
  28. }
  29. };
  30. /**
  31. * 绑定服务
  32. * @param view
  33. */
  34. public void bind(View view) {
  35. Intent intent = new Intent(this, MyService.class);
  36. bindService(intent, conn, Context.BIND_AUTO_CREATE);
  37. }
  38. /**
  39. * 解除绑定
  40. * @param view
  41. */
  42. public void unbind(View view) {
  43. unbindService(conn);
  44. }
  45. }

在上面的代码中，我们是在绑定服务成功时将IBinder类型的service参数强转为MyService.MyBinder类型，获取绑定中介实例，然后调用其greet方法。

操作一下，看看效果如何。先点击绑定服务的按钮，MyService打印如下：

需要注意的是，与服务绑定是一个异步的过程，也就是说，在这一刻我们绑定服务，下一刻我们去操作binder对象，也许它还为null，这就容易引起空指针异常，正确的做法是把这些操作放到绑定成功之后，确保万无一失。

以上就是进程内通信的内容。

关于进程间通信的内容，限于篇幅原因，这里就不再陈述了，大家可以看我之前的两篇文章，做一下了解：

使用AIDL实现进程间的通信

使用AIDL实现进程间的通信之复杂类型传递

Service完全解析相关推荐

  1. Android Service完全解析，关于服务你所需知道的一切(下)

    转载请注册出处:http://blog.csdn.net/guolin_blog/article/details/9797169 在上一篇文章中,我们学习了Android Service相关的许多重要 ...

  2. Android Service完全解析，关于服务你所需知道的一切(上)

    转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/11952435 相信大多数朋友对Service这个名词都不会陌生,没错,一个老练的A ...

  3. Web Service详细解析及使用方法

    Web Service详细解析及使用方法 XFire篇.... 2 XFire简介... 2 XFire特性... 2 XFire使用... 3 提供服务实现类... 3 服务类的接口类... 3 配 ...

  4. EMC 存储使用Unisphere Service Manager解析存储原厂日志

    一.什么是Unisphere Service Manager(USM) Unisphere Service Manager(USM)是一个基于Java的桌面应用程序,是EMC VNX中端产品系列维护的 ...

  5. Android Service 全解析

    Service的种类    按运行地点分类: 类别 区别 优点 缺点 应用 本地服务(Local) 该服务依附在主进程上, 服务依附在主进程上而不是独立的进程,这样在一定程度上节约了资源,另外Loca ...

  6. Service 深度解析

    通过android:process指定的远程服务是运行在一个独立的进程里,比如说接入消息推送之类的,需要建立长连接. 以下默认是local Service 服务适用于不需要和用户交互,又需要长期运行的 ...

  7. tomcat源码阅读之Server和Service接口解析

    tomcat中的服务器组件接口是Server接口,服务接口是Service,Server接口表示Catalina的整个servlet引擎,囊括了所有的组件,提供了一种优雅的方式来启动/关闭Catali ...

  8. Android Service完全解析

    Service的基本用法 1.新建一个Android项目,新建一个MyService继承自Service,并重写父类的onCreate(),onStartCommand()方法和onDestory() ...

  9. kubernetes service 原理解析

    原文链接:原文网址 service工作原理: 后续内容详见原文- https://www.jianshu.com/p/879b91d73ea4

  10. linux service命令解析（重要）

    我们平时都会用service xxx start来启动某个进程,那么它背后究竟执行了什么? 其实service的绝对路径为/sbin/service ,打开这个文件cat /sbin/service, ...

最新文章

  1. 019_Jedis的List数据类型
  2. ue4 classuobject没有成员beginplay_关于UE4使用的一些想法（一）
  3. c# 标准正太分布函数_机器学习中常见的几种概率分布
  4. 玩转算法面试-第三章
  5. maven构建Hibernate项目
  6. 椭圆极点极线性质_圆锥曲线的统一性质
  7. 一个死去的网站shige.laiyo.com
  8. 二级Access数据库大纲知识要点
  9. CCF NOI1048 检测矩阵
  10. python入门--常见的异常类型，常见错误
  11. Git学习笔记一《版本控制之道-使用Git》
  12. 【操作系统】实验四 主存空间的分配和回收
  13. BadBoy安装与使用
  14. 基于Python+Opencv的银行卡号识别系统（附完整代码）
  15. CSS display属性 – 不显示、显示表格、内联块等
  16. 计算机硬盘用u盘维修,电脑维修：U盘和移动硬盘及固态硬盘的区别
  17. s3cmd安装配置及基础命令
  18. 你知道java中重载和重写的区别吗?(详细解说)
  19. LocalDate获取当天,本月第一天,本月最后一天,今年第一天,今年最后一天
  20. 【关于为什么要刷力扣的思考】记第二次周赛AK

热门文章

  1. ios微信客户端中声音无法播放
  2. 什么样的人学习效果最差？
  3. 微信小程序 TOP100 榜单
  4. ajax同步请求和异步请求
  5. 17225 狼人游戏
  6. 使用Python进行面部合成
  7. 一篇文章搞懂Java设计模式之责任链模式
  8. java怎么判断对象不为空_java判断对象是否为空的方法
  9. 当我说我爱你时，你已经不在
  10. 教育管理硕士选题大全||120个论文题目哪里找