博客分类：
最近学习了一下Android里面的Service的应用，在BindService部分小卡了一下，主要是开始没有彻底理解为什么要这么实现。
BindService和Started Service都是Service，有什么地方不一样呢：
1. Started Service中使用StartService（）方法来进行方法的调用，调用者和服务之间没有联系，即使调用者退出了，服务依然在进行【onCreate()-
&onStartCommand()-&startService()-&onDestroy()】，注意其中没有onStart()，主要是被onStartCommand()方法给取代了，onStart方法不推荐使用了。
2. BindService中使用bindService()方法来绑定服务，调用者和绑定者绑在一起，调用者一旦退出服务也就终止了【onCreate()-&onBind()-&onUnbind()-&onDestroy()】。
调用者Activity：
MainAcitvity
package com.zys.
import com.zys.service.BindService.MyB
import android.R.
import android.app.A
import ponentN
import android.content.C
import android.content.I
import android.content.ServiceC
import android.os.B
import android.os.IB
import android.view.V
import android.view.View.OnClickL
import android.widget.B
public class MainActivity extends Activity {
private Button startB
private Button stopB
private boolean
/** Called when the activity is first created. */
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
flag = false;
startBtn = (Button)this.findViewById(R.id.startBtn);
stopBtn = (Button)this.findViewById(R.id.stopBtn);
startBtn.setOnClickListener(listener);
stopBtn.setOnClickListener(listener);
private OnClickListener listener = new OnClickListener() {
public void onClick(View v) {
// TODO Auto-generated method stub
switch (v.getId()) {
case R.id.startBtn:
bindService();
case R.id.stopBtn:
private void bindService(){
Intent intent = new Intent(MainActivity.this,BindService.class);
bindService(intent, conn, Context.BIND_AUTO_CREATE);
private void unBind(){
if(flag == true){
unbindService(conn);
flag = false;
private ServiceConnection conn = new ServiceConnection() {
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
MyBinder binder = (MyBinder)
BindService bindService = binder.getService();
bindService.MyMethod();
flag = true;
服务BindService
BindService
package com.zys.
import java.io.FileD
import android.app.S
import android.content.I
import android.os.B
import android.os.IB
import android.os.II
import android.os.P
import android.os.RemoteE
import android.util.L
public class BindService extends Service {
private static final String TAG = "BindService";
public void MyMethod(){
Log.i(TAG, "BindService--&MyMethod()");
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return myB
public class MyBinder extends Binder{
public BindService getService(){
return BindService.this;
private MyBinder myBinder = new MyBinder();
由于Android 中的Service使用了onBind 的方法去绑定服务，返回一个Ibinder对象进行操作，而我们要获取具体的Service方法的内容的时候，我们需要Ibinder对象返回具体的Service对象才能操作，所以说具体的Service对象必须首先实现Binder对象，这个样子的话我们才能利用bindService的方法对Service进行绑定，获取Binder对象之后获取具体的Service对象，然后才获取Service中的方法等等。所以我们需要注意的是bindService的方式去绑定服务获取的必定是实现了Binder的对象，所以这是我们必须使用Binder的方式去获取Service的方式而不是直接使用Service的类，这个是Android内部实现所约束的。
方法过程如下：
Intent intent = new Intent(MainActivity.this,BindService.class)-&新建了BindService对象-&新建了MyBinder对象
-&bindService(intent, conn, Context.BIND_AUTO_CREATE);-&onBind()函数
-----传递MyBinder对象-------&onServiceConnected（）
--& 通过传递的Binder对象获取刚刚和Binder对象对应的BindService 对象　　--&调用Service中定义的方法。
这个其中必须通过Binder对象，因为是通过Binder对象来传递的，通过Binder对象获取Service对象，然后获取所需的服务，所以Service必须实现Binder，以便传递和使用。
------------------------------------------
奇怪的事情真多，我的service怎么就有onStart方法，难得是版本的原因了？
package com.endual.
import android.app.S
import android.content.I
import android.os.IB
public class Myservice extends Service{
public IBinder onBind(Intent intent) {
System.out.println("----------&&onBind");
public void onCreate() {
System.out.println("----------&&onCreate");
super.onCreate();
public void onDestroy() {
System.out.println("----------&&onDestroy");
super.onDestroy();
public void onRebind(Intent intent) {
System.out.println("----------&&onRebind");
super.onRebind(intent);
public void onStart(Intent intent, int startId) {
System.out.println("----------&&onStart");
super.onStart(intent, startId);
public int onStartCommand(Intent intent, int flags, int startId) {
System.out.println("----------&&onStartCommand");
return super.onStartCommand(intent, flags, startId);
public boolean onUnbind(Intent intent) {
System.out.println("----------&&onUnbind");
return super.onUnbind(intent);
浏览 41069
浏览: 1775897 次
来自: 杭州
你好，ES跑起来了吗？我的在tomcat启动时卡在这里Hibe ...
java实现操作word中的表格内容，用插件实现的话，可以试试 ...
Maven多模块spring + springMVC + JP ...
博主还有wlsvm.zip这个压缩包吗？链接打不开了
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'中国领先的IT技术网站
51CTO旗下网站
安卓开发组件Android Service教程
在这篇文章中，我们想要讨论一下Android应用开发中的一个重要组件――Android Service。与Activity不同，Service在Android中运行在后台，Service没有界面并且生命周期也与Activity不同。 使用Service可以实现一些后台操作，例如从远程服务器上加载一个网页。我们可以使用Service在Android中实现多任务。
作者：佚名来源：importnew| 13:08
在这篇文章中，我们想要讨论一下Android应用开发中的一个重要组件&&Android
Service。与Activity不同，Service在Android中运行在后台，Service没有界面并且生命周期也与Activity不同。 使用Service可以实现一些后台操作，例如从远程服务器上加载一个网页。我们可以使用Service在Android中实现多任务。
Android Service概述
我们知道，如果系统资源变得紧张，Android
Activity可以被启动、停止、销毁甚至可能被重新创建。而Service被设计成拥有更长的生命周期。Service在Android中可以从 Activity、广播接收器（Broadcast receiver）或者由其他Service中启动。
必须注意到的是，使用Service不会自动创建新的线程。所以，如果我们要在Service中实现一个简单的逻辑并且那不需要长时间处理，我们不 必在一个单独的线程中运行它。但是，如果需要去实现一个复杂的逻辑并且会耗费长时间的处理，我们在创建新线程时必须小心，要不然由于Service运行在 主线程可能引起ANR问题（应用程序无响应）。
在Android中Service主要使用的场景如下：
实现多任务（multi-task）
进程间通信（IPC）
第一种情况的典型例子是，应用需要从远程服务端下载数据。在这种情况下，可以使用与用户交互的Activity，并在用户使用应用时启动Service，在后台运行完成工作。还有一种场景，当Service完成了任务发送信息给用户。
在第二种情况下，我们想要&分享&一些通常的功能，这样不同的应用可以重用他们。例如，可以假设我们有一个可以发送邮件的Service，我们想要 在几个应用分享这个服务，这样就不必重写新相同的代码。在这种情况下，我们可以使用IPC这样Service，暴露一个可以被其他应用调用的
&远程&接口。
Service基础
现在我们对Service有了更多的了解，我们来创建它。在Android中创建一个Service我们需要继承Service类。
public&class&TestService&extends&Service&{&&&&&&&@Override&&&&&public&IBinder&onBind(Intent&arg0)&{&&&&&&&&&&&&&&&&return&null;&&&&&}&&&}&
可以看到，我们只实现了一个叫做onBinde的方法。在上面的示例中，我们使用了本地服务，所以方法返回null。正如前面提到的，Service有它自己的生命周期，因此我们可以重写一些回调方法，这样就能处理其不同的状态了：
public&class&TestService&extends&Service&{&&&&&&&@Override&&&&&public&void&onCreate()&{&&&&&&&&&&&&&&&&super.onCreate();&&&&&}&&&&&&&@Override&&&&&public&void&onDestroy()&{&&&&&&&&&&&&&&&&super.onDestroy();&&&&&}&&&&&&&@Override&&&&&public&int&onStartCommand(Intent&intent,&int&flags,&int&startId)&{&&&&&&&&&&&&&&&&return&super.onStartCommand(intent,&flags,&startId);&&&&&}&&&&&&&@Override&&&&&public&IBinder&onBind(Intent&arg0)&{&&&&&&&&&&&&&&&&return&null;&&&&&}&&&}&
第一个方法onCreate只有在Service被创建的时刻被调用。如果Service已经在运行中，这个方法将不会被调用。我们不能直接调用它，它是由系统负责调用的。
OnStartCommand方法是最重要的方法，因为它在我们需要启动Service的时候被调用。在这个方法中，我们拥有在运行Service 时传递进来的Intent，这样就可以与Service交换一些信息。在这个方法中，我们实现自己的逻辑：如果不是耗时的操作可以直接在这个方法中执行， 否则可以创建一个线程。正如你看到的那样，这个方法需要返回一个整型值。这个整型代表系统应该怎么样处理这个Service：
START_STICKY：使用这个返回值，如果系统杀死我们的Service将会重新创建。但是，发送给Service的Intent不会再投递。这样Service是一直运行的。
START_NOT_STICKY：如果系统杀死了Service，不会重新创建，除非客户端显式地调用了onStart命令。
START_REDELIVER_INTENT：功能与START_STICKY类似。另外，在这种情况下Intent会重新传递给Service。
OnDestory是在Service将被销毁时系统调用的方法。
一旦有了自定义的Service类，就要在Manifest.xml中声明，这样我们就可以使用了。
&service&android:name=&.TestService&&&&&&&&&&&android:enabled=&true&/&&
启动和停止Service
正如我们知道的，一个Service会被启动、最后会被停止，这样就可以完成它的任务了。假设我们从一个Activity中启动它，可以使用Intent传递给Service一些信息。假设我们的Activity有两个按钮，一个来启动，一个来停止Service：
btnStart.setOnClickListener(new&View.OnClickListener()&{&&&&&&&@Override&&&&&public&void&onClick(View&v)&{&&&&&&&&&Intent&i&=&new&Intent(MainActivity.this,&TestService.class);&&&&&&&&&i.putExtra(&name&,&&SurvivingwithAndroid&);&&&&&&&&&&&&&&&&MainActivity.this.startService(i);&&&&&&&&&&&&}&});&&&btnStop.setOnClickListener(new&View.OnClickListener()&{&&&&&&&@Override&&&&&public&void&onClick(View&v)&{&&&&&&&&&Intent&i&=&new&Intent(MainActivity.this,&TestService.class);&&&&&&&&&MainActivity.this.stopService(i);&&&&&}&});&
在上面示例代码的第5行，我们创建一个传递类名的Intent来处理我们的服务，而且我们设置一些像名字这样的参数。然后在第7行的地方，我们启动这个Service。同样的方式，在17行我们停止了这个Service。
在开始按钮上点击，得到下面的Log：
可以注意到onCreate方法被调用了。因为这是我们第一次启动这个Service，如果我们在开始按钮上再次点击，系统不会调用onCreate方法。当我们在停止按钮上点击时，系统销毁这个Service。
IntentService
正如我们以前提到的，Service运行在主线程中。所以，我们在Service中实现逻辑时要非常小心。要考虑如果这个逻辑是一个阻塞操作，或者 需要很长时间才能结束，可能会引发ANR问题。在这种情况下，我们要将逻辑移到独立的线程中。这就意味着，要在onStartCommand方法中创建一 个线程，然后运行它。
从Service派生的另一个IntentService类可以简化我们的开发。当不需要在同一时间去处理多个请求时，这个类比较好用。这个类创建了一个工作线程来处理不同的请求。执行的操作如下：
创建一个单独的线程来处理请求。
创建一个请求队列并偶尔传递一个Intent。
创建一个默认的onStartCommand实现。
在所有的请求执行完毕后结束Service。
如果我们想要创建一个IntentService，需要继承IntentService类而不是Service类：
public&class&TestIntentService&extends&IntentService&{&&&&&&&public&TestIntentService()&{&&&&&&&&&super(&TestIntentService&);&&&&&&&&&&&&}&&&&&&&@Override&&&&&protected&void&onHandleIntent(Intent&intent)&{&&&&&&&}&&&}&
在这个实例中，我们只需要实现onHandleIntent方法。这里实现的外部逻辑不用关心操作是否耗时，因为这个方法在单独的线程中调用。
自动启动Service
很多时候我们想要自动启动我们的服务，例如在开机时自动启动。我们知道需要一个组件来启动Service。那么，怎么样做到自动启动呢？我们可以使 用一个广播接收器来启动服务。例如，如果我们想要在智能手机开机时候启动它，可以先创建一个广播接收器监听这个事件（开机），然后启动Service。
public&class&BootBroadcast&extends&BroadcastReceiver&{&&&&&&&@Override&&&&&public&void&onReceive(Context&ctx,&Intent&intent)&{&&&&&&&&&&&&&&&&ctx.startService(new&Intent(ctx,&TestService.class));&&&&&&&}&&&}&
在Manifest.xml中声明：
&receiver&android:name=&.BootBroadcast&&&&&&&&&&&intent-filter&&&&&&&&&&&&action&android:name=&android.intent.action.BOOT_COMPLETED&/&&&&&&&&&&&&&&&&&&&&&&/intent-filter&&&/receiver&&
【编辑推荐】
【责任编辑： TEL：（010）】
大家都在看猜你喜欢
头条头条关注热点头条
24H热文一周话题本月最赞
讲师：125345人学习过
讲师：91256人学习过
讲师：83013人学习过
精选博文论坛热帖下载排行
本书对前沿而又成熟的系统分析技术和方法进行了讨论，包括CMM与过程改进、J2EE与NET平台、中间件及相关技术、应用服务器、Web 服务、数据...
订阅51CTO邮刊92873人阅读
Android疑难解析（42）
转载请注册出处：在上一篇文章中，我们学习了Android Service相关的许多重要内容，包括Service的基本用法、Service和Activity进行通信、Service的销毁方式、Service与Thread的关系、以及如何创建前台Service。以上所提到的这些知识点，基本上涵盖了大部分日常开发工作当中可能使用到的Service技术。不过关于Service其实还有一个更加高端的使用技巧没有介绍，即远程Service的用法。使用远程Service甚至可以实现Android跨进程通信的功能，下面就让我们具体地学习一下。如果你还没有看过前面一篇文章，建议先去阅读一下 &，因为本篇文章中涉及到的代码是在上篇文章的基础上进行修改的。在上篇文章中我们知道了，Service其实是运行在主线程里的，如果直接在Service中处理一些耗时的逻辑，就会导致程序ANR。让我们来做个实验验证一下吧，修改上一篇文章中创建的ServiceTest项目，在MyService的onCreate()方法中让线程睡眠60秒，如下所示：public class MyService extends Service {
public void onCreate() {
super.onCreate();
Log.d(TAG, &onCreate() executed&);
Thread.sleep(60000);
} catch (InterruptedException e) {
e.printStackTrace();
}重新运行后，点击一下Start Service按钮或Bind Service按钮，程序就会阻塞住并无法进行任何其它操作，过一段时间后就会弹出ANR的提示框，如下图所示。之前我们提到过，应该在Service中开启线程去执行耗时任务，这样就可以有效地避免ANR的出现。那么本篇文章的主题是介绍远程Service的用法，如果将MyService转换成一个远程Service，还会不会有ANR的情况呢？让我们来动手尝试一下吧。将一个普通的Service转换成远程Service其实非常简单，只需要在注册Service的时候将它的android:process属性指定成:remote就可以了，代码如下所示：&?xml version=&1.0& encoding=&utf-8&?&
&manifest xmlns:android=&/apk/res/android&
package=&com.example.servicetest&
android:versionCode=&1&
android:versionName=&1.0& &
android:name=&com.example.servicetest.MyService&
android:process=&:remote& &
&/service&
&/manifest&现在重新运行程序，并点击一下Start Service按钮，你会看到控制台立刻打印了onCreate() executed的信息，而且主界面并没有阻塞住，也不会出现ANR。大概过了一分钟后，又会看到onStartCommand() executed打印了出来。为什么将MyService转换成远程Service后就不会导致程序ANR了呢？这是由于，使用了远程Service后，MyService已经在另外一个进程当中运行了，所以只会阻塞该进程中的主线程，并不会影响到当前的应用程序。为了证实一下MyService现在确实已经运行在另外一个进程当中了，我们分别在MainActivity的onCreate()方法和MyService的onCreate()方法里加入一行日志，打印出各自所在的进程id，如下所示：Log.d(&TAG&, &process id is & + Process.myPid());再次重新运行程序，然后点击一下Start Service按钮，打印结果如下图所示：可以看到，不仅仅是进程id不同了，就连应用程序包名也不一样了，MyService中打印的那条日志，包名后面还跟上了:remote标识。那既然远程Service这么好用，干脆以后我们把所有的Service都转换成远程Service吧，还省得再开启线程了。其实不然，远程Service非但不好用，甚至可以称得上是较为难用。一般情况下如果可以不使用远程Service，就尽量不要使用它。下面就来看一下它的弊端吧，首先将MyService的onCreate()方法中让线程睡眠的代码去除掉，然后重新运行程序，并点击一下Bind Service按钮，你会发现程序崩溃了！为什么点击Start Service按钮程序就不会崩溃，而点击Bind Service按钮就会崩溃呢？这是由于在Bind Service按钮的点击事件里面我们会让MainActivity和MyService建立关联，但是目前MyService已经是一个远程Service了，Activity和Service运行在两个不同的进程当中，这时就不能再使用传统的建立关联的方式，程序也就崩溃了。那么如何才能让Activity与一个远程Service建立关联呢？这就要使用AIDL来进行跨进程通信了（IPC）。AIDL（Android Interface Definition Language）是Android接口定义语言的意思，它可以用于让某个Service与多个应用程序组件之间进行跨进程通信，从而可以实现多个应用程序共享同一个Service的功能。下面我们就来一步步地看一下AIDL的用法到底是怎样的。首先需要新建一个AIDL文件，在这个文件中定义好Activity需要与Service进行通信的方法。新建MyAIDLService.aidl文件，代码如下所示：package com.example.
interface MyAIDLService {
int plus(int a, int b);
String toUpperCase(String str);
}点击保存之后，gen目录下就会生成一个对应的Java文件，如下图所示：&然后修改MyService中的代码，在里面实现我们刚刚定义好的MyAIDLService接口，如下所示：public class MyService extends Service {
public IBinder onBind(Intent intent) {
MyAIDLService.Stub mBinder = new Stub() {
public String toUpperCase(String str) throws RemoteException {
if (str != null) {
return str.toUpperCase();
public int plus(int a, int b) throws RemoteException {
return a +
}这里先是对MyAIDLService.Stub进行了实现，重写里了toUpperCase()和plus()这两个方法。这两个方法的作用分别是将一个字符串全部转换成大写格式，以及将两个传入的整数进行相加。然后在onBind()方法中将MyAIDLService.Stub的实现返回。这里为什么可以这样写呢？因为Stub其实就是Binder的子类，所以在onBind()方法中可以直接返回Stub的实现。接下来修改MainActivity中的代码，如下所示：public class MainActivity extends Activity implements OnClickListener {
private Button startS
private Button stopS
private Button bindS
private Button unbindS
private MyAIDLService myAIDLS
private ServiceConnection connection = new ServiceConnection() {
public void onServiceDisconnected(ComponentName name) {
public void onServiceConnected(ComponentName name, IBinder service) {
myAIDLService = MyAIDLService.Stub.asInterface(service);
int result = myAIDLService.plus(3, 5);
String upperStr = myAIDLService.toUpperCase(&hello world&);
Log.d(&TAG&, &result is & + result);
Log.d(&TAG&, &upperStr is & + upperStr);
} catch (RemoteException e) {
e.printStackTrace();
}我们只是修改了ServiceConnection中的代码。可以看到，这里首先使用了MyAIDLService.Stub.asInterface()方法将传入的IBinder对象传换成了MyAIDLService对象，接下来就可以调用在MyAIDLService.aidl文件中定义的所有接口了。这里我们先是调用了plus()方法，并传入了3和5作为参数，然后又调用了toUpperCase()方法，并传入hello world字符串作为参数，最后将调用方法的返回结果打印出来。现在重新运行程序，并点击一下Bind Service按钮，可以看到打印日志如下所示：由此可见，我们确实已经成功实现跨进程通信了，在一个进程中访问到了另外一个进程中的方法。不过你也可以看出，目前的跨进程通信其实并没有什么实质上的作用，因为这只是在一个Activity里调用了同一个应用程序的Service里的方法。而跨进程通信的真正意义是为了让一个应用程序去访问另一个应用程序中的Service，以实现共享Service的功能。那么下面我们自然要学习一下，如何才能在其它的应用程序中调用到MyService里的方法。在上一篇文章中我们已经知道，如果想要让Activity与Service之间建立关联，需要调用bindService()方法，并将Intent作为参数传递进去，在Intent里指定好要绑定的Service，示例代码如下：Intent bindIntent = new Intent(this, MyService.class);
bindService(bindIntent, connection, BIND_AUTO_CREATE);这里在构建Intent的时候是使用MyService.class来指定要绑定哪一个Service的，但是在另一个应用程序中去绑定Service的时候并没有MyService这个类，这时就必须使用到隐式Intent了。现在修改AndroidManifest.xml中的代码，给MyService加上一个action，如下所示：&?xml version=&1.0& encoding=&utf-8&?&
&manifest xmlns:android=&/apk/res/android&
package=&com.example.servicetest&
android:versionCode=&1&
android:versionName=&1.0& &
android:name=&com.example.servicetest.MyService&
android:process=&:remote& &
&intent-filter&
&action android:name=&com.example.servicetest.MyAIDLService&/&
&/intent-filter&
&/service&
&/manifest&这就说明，MyService可以响应带有com.example.servicetest.MyAIDLService这个action的Intent。现在重新运行一下程序，这样就把远程Service端的工作全部完成了。然后创建一个新的Android项目，起名为ClientTest，我们就尝试在这个程序中远程调用MyService中的方法。ClientTest中的Activity如果想要和MyService建立关联其实也不难，首先需要将MyAIDLService.aidl文件从ServiceTest项目中拷贝过来，注意要将原有的包路径一起拷贝过来，完成后项目的结构如下图所示：然后打开或新建activity_main.xml，在布局文件中也加入一个Bind Service按钮：&LinearLayout xmlns:android=&/apk/res/android&
android:layout_width=&match_parent&
android:layout_height=&match_parent&
android:orientation=&vertical&
android:id=&@+id/bind_service&
android:layout_width=&match_parent&
android:layout_height=&wrap_content&
android:text=&Bind Service&
&/LinearLayout&接下来打开或新建MainActivity，在其中加入和MyService建立关联的代码，如下所示：public class MainActivity extends Activity {
private MyAIDLService myAIDLS
private ServiceConnection connection = new ServiceConnection() {
public void onServiceDisconnected(ComponentName name) {
public void onServiceConnected(ComponentName name, IBinder service) {
myAIDLService = MyAIDLService.Stub.asInterface(service);
int result = myAIDLService.plus(50, 50);
String upperStr = myAIDLService.toUpperCase(&comes from ClientTest&);
Log.d(&TAG&, &result is & + result);
Log.d(&TAG&, &upperStr is & + upperStr);
} catch (RemoteException e) {
e.printStackTrace();
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button bindService = (Button) findViewById(R.id.bind_service);
bindService.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
Intent intent = new Intent(&com.example.servicetest.MyAIDLService&);
bindService(intent, connection, BIND_AUTO_CREATE);
}这部分代码大家一定会非常眼熟吧？没错，这和在ServiceTest的MainActivity中的代码几乎是完全相同的，只是在让Activity和Service建立关联的时候我们使用了隐式Intent，将Intent的action指定成了com.example.servicetest.MyAIDLService。在当前Activity和MyService建立关联之后，我们仍然是调用了plus()和toUpperCase()这两个方法，远程的MyService会对传入的参数进行处理并返回结果，然后将结果打印出来。这样的话，ClientTest中的代码也就全部完成了，现在运行一下这个项目，然后点击Bind Service按钮，此时就会去和远程的MyService建立关联，观察LogCat中的打印信息如下所示：不用我说，大家都已经看出，我们的跨进程通信功能已经完美实现了。不过还有一点需要说明的是，由于这是在不同的进程之间传递数据，Android对这类数据的格式支持是非常有限的，基本上只能传递Java的基本数据类型、字符串、List或Map等。那么如果我想传递一个自定义的类该怎么办呢？这就必须要让这个类去实现Parcelable接口，并且要给这个类也定义一个同名的AIDL文件。这部分内容并不复杂，而且和Service关系不大，所以就不再详细进行讲解了，感兴趣的朋友可以自己去查阅一下相关的资料。好了，结合上下两篇，这就是关于Service你所需知道的一切。关注我的技术公众号，每天都有优质技术文章推送。关注我的娱乐公众号，工作、学习累了的时候放松一下自己。
微信扫一扫下方二维码即可关注：
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：7562343次
积分：41267
积分：41267
排名：第99名
原创：101篇
评论：14024条
《第二行代码》已出版新书基于Android 7.0系统全面升级更加入了许多振奋人心的新技术
纸质书购买：
电子书购买：
关注我的技术公众号，每天都有优质技术文章推送。
关注我的娱乐公众号，工作、学习累了的时候放松一下自己。
微信扫一扫上方二维码即可关注
感兴趣的朋友可以加入我的QQ群，一起讨论学习，共同进步。
阅读：168628
阅读：536957
(2)(1)(1)(1)(1)(1)(1)(2)(1)(1)(1)(1)(2)(1)(1)(2)(1)(1)(2)(1)(1)(1)(1)(1)(1)(1)(2)(2)(3)(1)(2)(5)(3)(3)(2)(1)(3)(1)(2)(5)(4)(4)(4)(4)(5)(5)(5)(6)(4)