您的位置: 首页  >  文章  >  安卓服务Service详解

安卓服务Service详解

分类: 文章 • 2024-05-01 21:22:12

service（服务）是安卓中的四大组件之一，它通常用作在后台处理耗时的逻辑，与Activity一样，它存在自己的生命周期，也需要在清单文件中配置相关信息，本博客将对Service的各个知识点进行详细讲解。



一Service的基本用法：

1使用本地服务

1）服务的启动方式

1通过Context的startService()方法启动服务：以该方法启动的服务，开启该服务的应用组件（如Activity）与该Service不存在关联关系，即使开启该服务的Activity被销毁，Service任能够一直在后台运行。通常,开启的服务执行一个单独的操作且不需向调用者返回一个结果。比如，可能从网络进行下载或者上传一个文件。当任务完成，服务就该自我停止。使用服务于使用Activity非常相似，都是先继承其对应的基类，然后重写其中重要的方法，这些方法就是关于其生命周期回调的方法。代码如下所示：

[java] view plain copy
  1. public class MyService extends Service {  
  2.   
  3.     public static final String TAG = "MyService";  
  4.   
  5.     @Override  
  6.     public void onCreate() {  
  7.         super.onCreate();  
  8.         Log.d(TAG, "onCreate() executed");  
  9.     }  
  10.   
  11.     @Override  
  12.     public int onStartCommand(Intent intent, int flags, int startId) {  
  13.         Log.d(TAG, "onStartCommand() executed");  
  14.         return super.onStartCommand(intent, flags, startId);  
  15.     }  
  16.       
  17.     @Override  
  18.     public void onDestroy() {  
  19.         super.onDestroy();  
  20.         Log.d(TAG, "onDestroy() executed");  
  21.     }  
  22.   
  23.     @Override  
  24.     public IBinder onBind(Intent intent) {  
  25.         return null;  
  26.     }  
  27.   
  28. }  
然后再Activity中使用
[java] view plain copy
  1. Intent startIntent = new Intent(this, MyService.class);    
  2. startService(startIntent);   
即可开启该服务，程序运行结果如下：

安卓服务Service详解
从程序的运行结果来看，可以知道当启动一个Service的时候，会调用该Service中的onCreate()和onStartCommand()方法。

当我们在次点击启动服务的按钮，程序运行结果如下：

安卓服务Service详解
可以看到，此时只输出onStartCommand() executed。这说明此时只执行了onStartCommand()方法，而未执行onCreate()，这说明onCreate()方法只会在Service第一次被创建的时候调用，如果当前Service已经被创建过了，则即使多次调用startService()方法，onCreate()方法都不会再执行，这一点非常类似数据库操作中的open一个数据库。

当然上述的例子仅仅只是为了说明上述知识点，因为Service中的代码也仅仅只是打印出log而已，而事实上Service的使用是为了处理一些耗时操作的，如网络请求，文件上传与下载，但都是重写其某个生命周期函数，如onStart(Intent intent, int startId)，onDestroy()在这些函数中完成自己的业务逻辑的处理，下面的代码是使用服务来进行网络通信的一个例子。

[java] view plain copy
  1. public class GetMsgService extends Service {  
  2.     private Client client;  
  3.     private boolean isStart;  
  4.     private SharePreferenceUserInfoUtil util;  
  5.     private ClientInputThread cit;  
  6.     @Override  
  7.     public IBinder onBind(Intent intent) {  
  8.         // TODO Auto-generated method stub  
  9.         return null;  
  10.     }  
  11.   
  12.     @Override  
  13.     public void onCreate() {  
  14.         // TODO Auto-generated method stub  
  15.         super.onCreate();  
  16.         client=((MyApplication) getApplication()).getClient();  
  17.     }  
  18.   
  19.     @Override  
  20.     public void onStart(Intent intent, int startId) {  
  21.         // TODO Auto-generated method stub  
  22.         super.onStart(intent, startId);  
  23.         util = new SharePreferenceUserInfoUtil(getApplicationContext(),  
  24.                 Constants.SAVE_USER);  
  25.          
  26.         new Thread(){  
  27.                public void run()  
  28.                {  
  29.                     try {  
  30.                         isStart=client.create();  
  31.                     } catch (UnknownHostException e) {  
  32.                         // TODO Auto-generated catch block  
  33.                         e.printStackTrace();  
  34.                     } catch (IOException e) {  
  35.                         // TODO Auto-generated catch block  
  36.                         e.printStackTrace();  
  37.                     }  
  38.             //在服务中接受来自服务器端的消息，然后通过广播的形式传递给相应的Activity处理。接受服务器端的消息一般在  
  39.             //服务中，因为服务可以在后台一直运行  
  40.                                       
  41.                 if(isStart)  
  42.                 {  
  43.                     cit=client.getClientInputThread();  
  44.                     if(cit!=null)  
  45.                     {  
  46.                         cit.setMessageListener(new MessageListener() {  
  47.                               
  48.                             public void getMessage(TransportObject msg) {  
  49.                                   
  50.                                 if(msg!=null&&msg instanceof TransportObject)  
  51.                                 {  
  52.                                     //通过广播向Activity传递消息  
  53.                                     Intent intent=new Intent();  
  54.                                     intent.setAction(Constants.ACTION_MSG);  
  55.                                     intent.putExtra(Constants.MSG, msg);  
  56.                                     sendBroadcast(intent);  
  57.                                 }  
  58.                             }  
  59.                         });  
  60.                     }  
  61.                     else {  
  62.                         Log.i("GetMsgService","服务器端连接暂时出错");  
  63.                     //  Toast.makeText(getApplicationContext(), "服务器端连接暂时出错，请稍后重试！",0).show();  
  64.                     }  
  65.                 }  
  66.                     
  67.                }  
  68.            }.start();  
  69.     }  
  70.   
  71.     @Override  
  72.     public void onDestroy() {  
  73.         // TODO Auto-generated method stub  
  74.         super.onDestroy();  
  75.         ClientOutputThread out=client.getClientOutputThread();  
  76.         TransportObject<User> msg=new TransportObject<User>(TranObjectType.LOGOUT);  
  77.         User user=new User();  
  78.         user.setId(Integer.parseInt(util.getId()));  
  79.         msg.setObject(user);  
  80.         out.setMsg(msg);  
  81.         //关闭服务时关闭client  
  82.         out.setStart(false);  
  83.         client.getClientInputThread().setStart(false);  
  84.           
  85.           
  86.           
  87.     }  
  88.       
  89.       
  90.   
  91. }  
可以看到，我们在getMsgService的onStart方法中开启了一个线程用来进行客户端从服务器端读取信息的操作，在onDestroy()方法中关闭网络请求的操作。

2通过Context的bindService()方法启动服务：顾名思义，以该方法启动的服务，开启该服务的应用组件（如Activity）与该Service被绑定在一起，通常用这种方式开启的服务是为了与开启该服务的应用组件（如Activity）进行消息通信。

首先我们来看一下bindService的签名：

[java] view plain copy
  1. bindService(Intent service, ServiceConnection conn, int flags)  
其中service参数是通过intent指定要启动的Service。

conn参数是一个ServiceConnection对象，该对象用于监听访问者与service之间的连接情况，当访问者与Service连接成功时会回调该类的onServiceConnected(ComponentName name, IBinder service)方法，然后将服务中创建的Ibinder对象（此时在Service的onBinder方法中需要返回该Ibinder对象）传递给第二个参数service，通过该Ibinder对象就能与Service进行通信。

第三个参数flags指定绑定时是否自动创建Service，一般我们指定为BIND_AUTO_CREATE（自动创建，如果传入0表示不自动创建）示例代码如下：

Service中的代码：

[java] view plain copy
  1. public class MyService extends Service {  
  2.   
  3.     public static final String TAG = "MyService";  
  4.   
  5.     private MyBinder mBinder = new MyBinder();  
  6.   
  7.     @Override  
  8.     public void onCreate() {  
  9.         super.onCreate();  
  10.         Log.d(TAG, "onCreate() executed");  
  11.     }  
  12.   
  13.     @Override  
  14.     public int onStartCommand(Intent intent, int flags, int startId) {  
  15.         Log.d(TAG, "onStartCommand() executed");  
  16.         return super.onStartCommand(intent, flags, startId);  
  17.     }  
  18.   
  19.     @Override  
  20.     public void onDestroy() {  
  21.         super.onDestroy();  
  22.         Log.d(TAG, "onDestroy() executed");  
  23.     }  
  24.   
  25.     @Override  
  26.     public IBinder onBind(Intent intent) {//在onBind(Intent intent)中返回IBinder对象  
  27.         return mBinder;  
  28.     }  
  29.   
  30.     class MyBinder extends Binder {//定义一个类实现IBinder接口（ Binder实现了IBinder接口）  
  31.   
  32.         public void doSomething() {  
  33.             Log.d("TAG", "doSomething() executed");  
  34.               
  35.         }  
  36.   
  37.     }  
  38.   
  39. }  
Activity中的代码：
[java] view plain copy
  1. public class MainActivity extends Activity  
  2. {  
  3.   ...  
  4. private ServiceConnection connection = new ServiceConnection() {    
  5.     
  6.         @Override    
  7.         public void onServiceDisconnected(ComponentName name) {    
  8.         }    
  9.     
  10.         @Override    
  11.         public void onServiceConnected(ComponentName name, IBinder service) {    
  12.             myBinder = (MyService.MyBinder) service;    
  13.             myBinder.doSomething();    
  14.         }    
  15.     };    
  16.     protected void onCreate(Bundle savedInstanceState) {    
  17.         super.onCreate(savedInstanceState);    
  18.         setContentView(R.layout.activity_main);    
  19.     Intent bindIntent = new Intent(this, MyService.class);    
  20.         bindService(bindIntent, connection, BIND_AUTO_CREATE);//此时使用bindService开启服务  
  21.     }  
  22.   ...  
  23.   
  24. }  
即在服务中定义一个IBinder的实例，然后在Service的public IBinder onBind(Intent intent)方法中将其返回，在Activity中定义一个ServiceConnection类的实例，在其onServiceConnected(ComponentName name, IBinder service)方法中获取Service中 返回IBinder对象，利用该对象即可调用Service中的方法进行相互通信。

注意：一个服务在进程中的主线程运行——一个服务不会创建自己的线程，也不会在另外的进程运行(除非另外指定)。这意味着，如果服务需要做一些频繁占用CPU的工作或者会发生阻塞的操作，你需要在服务中另开线程执行任务。避免程序出现ANR。


2使用AIDL跨进程调用服务：

此种情况与上述介绍的使用bindService方法开启的绑定本地的大的框架基本相同，只不过使用AIDL来实现跨进程调用，关于此种情况的介绍，请参看我的博客：安卓中不同APP之间的消息通信中相关的内容。



二Service与线程的关系及IntentService：

事实上Service与线程之间没多大关系，我们之所以把Service与线程放在一起谈论，是为了更清楚的明白在哪些情况下用服务哪些情况下用线程，哪些情况下在服务中开启一个线程，因为Service默认在主线程中运行，不能进行耗时操作，这也是IntentService存在的原因。因为IntentService会创建单独的worker线程来处理intent请求，不需要自己创建一个子线程。

IntentService处理流程
创建默认的一个 worker 线程处理传递给 onStartCommand() 的所有 intent ，不占据应用的主线程
创建一个工作队列一次传递一个 intent 到你实现的 onHandleIntent() 方法，避免了多线程
在所有启动请求被处理后自动关闭服务，不需要调用 stopSelf()
默认提供 onBind() 的实现，且返回 null
默认提供 onStartCommand() 的实现，实现发送intent到工作队列再到onHandleIntent() 方法实现。

正因为如此，所以使用IntentService无需重写onBind()，onStartCommand()，只需重写onHandleIntent() 即可。示例代码如下：

[java] view plain copy
  1. public class HelloIntentService extends IntentService {  
  2.   /** 
  3.    * A constructor is required, and must call the super IntentService(String) 
  4.    * constructor with a name for the worker thread. 
  5.    */  
  6.   public HelloIntentService() {  
  7.     super("HelloIntentService");  
  8.   }  
  9.   /** 
  10.    * The IntentService calls this method from the default worker thread with 
  11.    * the intent that started the service. When this method returns, IntentService 
  12.    * stops the service, as appropriate. 
  13.    */  
  14.   @Override  
  15.   protected void onHandleIntent(Intent intent) {  
  16.     // Normally we would do some work here, like download a file.  
  17.     // For our sample, we just sleep for 5 seconds.  
  18.     long endTime = System.currentTimeMillis() + 5*1000;  
  19.     while (System.currentTimeMillis() < endTime) {  
  20.       synchronized (this) {  
  21.         try {  
  22.           wait(endTime - System.currentTimeMillis());  
  23.         } catch (Exception e) {  
  24.         }  
  25.       }  
  26.     }  
  27.   }  
  28. }  


三Service的生命周期

我们先来看一下谷歌官方图片：

安卓服务Service详解

从上述图片可以看到两种不同的启动方式其生命周期也不同：

启动的服务： 
startService()->onCreate()->onStartCommand()->running->stopService()/stopSelf()->onDestroy()->stopped 
其中，服务未运行时会调用一次onCreate()，运行时不调用。
绑定的服务： 
bindService()->onCreate()->onBind()->running->onUnbind()->onDestroy()->stopped
服务起始于 onCreate() ，终止于 onDestory()

服务的开关过程，只有 onStartCommand() 可多次调用，其他在一个生命周期只调用一次。

这两个过程不是完全独立，也可以绑定一个由 startService() 启动过的服务



四如何创建不被系统杀死的服务

服务不被杀死包括三种情况

1.系统根据资源分配情况杀死服务

2.用户通过 settings -> Apps -> Running -> Stop 方式杀死服务
3.用户通过 settings -> Apps -> Downloaded -> Force Stop 方式杀死服务
第一种情况：

用户不干预，完全靠系统来控制，办法有很多。比如 onStartCommand() 方法的返回值设为 START_STICKY ，服务就会在资源紧张的时候被杀掉，然后在资源足够的时候再恢复。当然也可设置为前台服务，使其有高的优先级，在资源紧张的时候也不会被杀掉。

关于 onStartCommand() 方法的返回值做一下简单的介绍：

START_STICKY：如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null。
START_NOT_STICKY：“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务。
START_REDELIVER_INTENT：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
START_STICKY_COMPATIBILITY：START_STICKY的兼容版本，但不保证服务被kill后一定能重启。
第二种情况：
用户干预，主动杀掉运行中的服务。这个过程杀死服务会通过服务的生命周期，也就是会调用 onDestory() 方法，这时候一个方案就是在 onDestory() 中发送广播开启自己。这样杀死服务后会立即启动。如下：

在onCreate中注册广播，用来开启服务，在服务的onDestroy()中发送广播通知服务开启自己，代码如下：

[java] view plain copy
  1. public void onCreate() {  
  2.   // TODO Auto-generated method stub  
  3.   super.onCreate();  
  4.   mBroadcast = new BroadcastReceiver() {  
  5.     @Override  
  6.     public void onReceive(Context context, Intent intent) {  
  7.       // TODO Auto-generated method stub  
  8.       Intent a = new Intent(ServiceA.this, ServiceA.class);  
  9.       startService(a);  
  10.     }  
  11.   };  
  12.   mIF = new IntentFilter();  
  13.   mIF.addAction("listener");  
  14.   registerReceiver(mBroadcast, mIF);  
  15. }  
  16. @Override  
  17. public void onDestroy() {  
  18.   // TODO Auto-generated method stub  
  19.   super.onDestroy();  
  20.   Intent intent = new Intent();  
  21.   intent.setAction("listener");  
  22.   sendBroadcast(intent);  
  23.   unregisterReceiver(mBroadcast);  
  24. }  

第三种情况：
强制关闭就不好解决。这个好像是从包的level去关的，不是走的Service的完整的生命周期。所以在服务里加代码是无法被调用的。处理这个情况的唯一方法是屏蔽掉 force stop 和 uninstall 按钮，让其不可用。

好了，以上就是本人理解的关于Service的相关知识，看官如果觉得不错请不要吝啬点击一下下方的“顶”按钮给我一点鼓励哦！安卓服务Service详解

相关推荐