今天我们就来介绍一下Android中的四大组件中的服务Service，说到Service，

它分为本地服务和远程服务：区分这两种服务就是看客户端和服务端是否在同一个进程中，本地服务是在同一进程中的，远程服务是不在同一个进程中的。

开启服务也有两种方式，一种是startService(),他对应的结束服务的方法是stopService()，另一种是bindService()，结束服务的是unBindService()，这两种方式的区别就是：当客户端Client使用startService方法开启服务的时候，这个服务和Client之间就没有联系了，Service的运行和Client是相互独立的，想结束这个服务的话，就在服务本身中调用stopSelf()方法结束服务。而当客户端Client使用bindService方法开始服务的时候，这个服务和Client是一种关联的关系，他们之间使用Binder的代理对象进行交互，这个在后面会详细说到，要是结束服务的话，需要在Client中和服务断开，调用unBindService方法。

在这里我们只做bindService方式的研究，而startService方式比较独立和简单，这里就不做演示了。

首先来说一下本地服务：

本地服务很简单的，就是Client和这个服务在同一个进程中：

先来看一下代码吧：

下面这张图是项目的结构图：

为了方便数据的访问，这里定义一个数据的访问接口：

[java] view
 plaincopy

package com.nativeservice.demo;  
  
/** 
 * 访问接口 
 * @author weijiang204321 
 */  
public interface IStudent {  
    /** 
     * 通过no访问name 
     * @param no 
     * @return 
     */  
    public String getNameByNumber(int no);  
      
}  

下面再来看一下StudentService的代码：

[java] view
 plaincopy

package com.nativeservice.demo;  
  
import android.app.Service;  
import android.content.Intent;  
import android.os.Binder;  
import android.os.IBinder;  
  
/** 
 * 定义的服务Service 
 * @author weijiang204321 
 */  
public class StudentService extends Service{  
  
    //名称  
    public static String[] nameAry = {“张飞”,“李小龙”,“赵薇”};  
      
    /** 
     * 通过no获取name 
     * @param no 
     * @return 
     */  
    private String getNameByNo(int no){  
        if(no>0 && no<4)  
            return nameAry[no-1];  
        return null;  
    }  
      
    @Override  
    public IBinder onBind(Intent arg0) {  
        return new StudentBinder();  
    }  
      
    /** 
     * 自定义的Binder对象 
     * @author weijiang204321 
     * 
     */  
    private class StudentBinder extends Binder implements IStudent{  
        @Override  
        public String getNameByNumber(int no) {  
            return getNameByNo(no);  
        }  
    }  
  
  
}  

StudentService中就是定义一个访问name的方法，在onBind方法中返回Binder对象，这个就是Client和Service之间交互的关键对象

下面看一下Client代码：

[java] view
 plaincopy

package com.nativeservice.demo;  
  
import android.app.Activity;  
import android.content.ComponentName;  
import android.content.Intent;  
import android.content.ServiceConnection;  
import android.os.Bundle;  
import android.os.IBinder;  
import android.os.Looper;  
import android.widget.Toast;  
  
/** 
 * 测试Service 
 * @author weijiang204321 
 * 
 */  
public class MainActivity extends Activity {  
  
    private IStudent student;  
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        //开启查询名称的服务  
        Intent service = new Intent(this,StudentService.class);  
        bindService(service,new StudentConnection(),BIND_AUTO_CREATE);  
        //延迟2s在显示查询的内容，不然开启服务也是需要时间的，如果不延迟一段时间的话,student对象为null;  
        new Thread(){  
            @Override  
            public void run(){  
                try {  
                    Thread.sleep(2*1000);  
                    Looper.prepare();  
                    Toast.makeText(getApplicationContext(), student.getNameByNumber(1), Toast.LENGTH_LONG).show();  
                    Looper.loop();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }.start();  
    }  
      
    /** 
     * 自定义的服务连接connection 
     * @author weijiang204321 
     * 
     */  
    private class StudentConnection implements ServiceConnection{  
          
        @Override  
        public void onServiceConnected(ComponentName name, IBinder service) {  
            student = (IStudent)service;  
        }  
        @Override  
        public void onServiceDisconnected(ComponentName name) {  
        }  
          
    }  
}  

在这里，用到了bindService方法，该方法的参数是：第一个参数是服务的intent,第二参数是一个ServiceConnection接口，第三个参数是启动服务的方式常量，这里最主要的就是第二个参数ServiceConnection接口，我们自己定义一个实现该接口的类。

StudentConnection,必须实现两个方法，这两个方法见名思议，一个是连接时调用的方法，一个是断开连接时的方法，在开始连接的方法onServiceConnected中传回来一个IBinder对象，这个时候需要将其转化一下，这个就是为什么要在开始的时候定义一个IStudent接口，在这里访问数据就方便了，同时在Client代码中要做个延迟的操作来访问数据，因为开启服务，连接这个过程是需要时间的，所以在这里就延迟了2s，这里只是为了能够正常显示数据，才这么做的，不然student对象是为null的，当然要根据自己的实际情况操作。最后还要在AndroidMainfest.xml中配置Service：

[html] view
 plaincopy

<service android:name=“.StudentService”></service>  

这里开启服务用的是显示意图，所以没有定义action过滤器了，运行结果很简单这里就不截图了

下面在来说一下远程服务：

在说到远程服务的时候，我们需要先了解一些预备的知识：

首先来了解一下AIDL机制：

AIDL的作用

由于每个应用程序都运行在自己的进程空间，并且可以从应用程序UI运行另一个服务进程，而且经常会在不同的进程间传递对象。在Android平台，一个进程通常不能访问另一个进程的内存空间，所以要想对话，需要将对象分解成操作系统可以理解的基本单元，并且有序的通过进程边界。

通过代码来实现这个数据传输过程是冗长乏味的，Android提供了AIDL工具来处理这项工作。

AIDL (Android Interface Definition Language) 是一种IDL 语言，用于生成可以在Android设备上两个进程之间进行进程间通信(interprocess communication, IPC)的代码。如果在一个进程中（例如Activity）要调用另一个进程中（例如Service）对象的操作，就可以使用AIDL生成可序列化的参数。

AIDL IPC机制是面向接口的，像COM或Corba一样，但是更加轻量级。它是使用代理类在客户端和实现端传递数据。

在Android中, 每个应用程序都有自己的进程，当需要在不同的进程之间传递对象时，该如何实现呢? 显然, Java中是不支持跨进程内存共享的。因此要传递对象, 需要把对象解析成操作系统能够理解的数据格式, 以达到跨界对象访问的目的。在JavaEE中，采用RMI通过序列化传递对象。在Android中, 则采用AIDL(Android Interface Definition Language：接口描述语言)方式实现。

AIDL是一种接口定义语言，用于约束两个进程间的通讯规则，供编译器生成代码，实现Android设备上的两个进程间通信(IPC)。AIDL的IPC机制和EJB所采用的CORBA很类似，进程之间的通信信息，首先会被转换成AIDL协议消息，然后发送给对方，对方收到AIDL协议消息后再转换成相应的对象。由于进程之间的通信信息需要双向转换，所以android采用代理类在背后实现了信息的双向转换，代理类由android编译器生成，对开发人员来说是透明的。

选择AIDL的使用场合

官方文档特别提醒我们何时使用AIDL是必要的：只有你允许客户端从不同的应用程序为了进程间的通信而去访问你的service，以及想在你的service处理多线程。

了解了AIDL之后下面来看一下项目的结构：

我们这个远程服务是想在将服务端和客户端分别放到一个应用中，所以这里要建立两个Android项目一个是remoteService,一个是remoteClient

首先来看一下Service端的项目结构：

在这里我们需要定义一个aidl文件，具体步骤很简单的：

因为AIDL相当于是一个接口，所以它的定义和interface的定义很类似的，使用interface关键字，有一点不同的是，AIDL中不能有修饰符(public,protected,private)，不然报错，这个你们可以自己尝试一下，然后将定义好的AIDL文件的后缀名.java改成.aidl，此时在gen文件夹下面就会多出一个与之对应的java文件，这个是编译器干的事情。这个AIDL接口中定义的一般都是Client和Service交互的接口。

下面来看一下StudentQuery.aidl文件：

[java] view
 plaincopy

package cn.itcast.aidl;  
//注意没有任何的访问权限修饰符  
interface StudentQuery {  
    //通过number来访问学生的name  
    String queryStudent(int number);  
}  

代码结构和接口是大同小异的。

再来看一下服务端的代码：

[java] view
 plaincopy

package cn.itcast.remote.service;  
  
import cn.itcast.aidl.StudentQuery;  
import android.app.Service;  
import android.content.Intent;  
import android.os.IBinder;  
import android.os.RemoteException;  
/** 
 * 远程服务端 
 */  
public class StudentQueryService extends Service {  
    //姓名名称  
    private String[] names = {“张飞”, “李静”, “赵薇”};  
      
    private IBinder binder = new StudentQueryBinder();  
      
    @Override  
    public IBinder onBind(Intent intent) {  
        return binder;  
    }  
    /** 
     * 服务中定义的访问方法 
     * @param number 
     * @return 
     */  
    private String query(int number){  
        if(number > 0 && number < 4){  
            return names[number – 1];  
        }  
        return null;  
    }  
      
    /** 
     * 定义Binder，这里需要继承StudentQuery.Stub 
     * StudentQuery是我们定义的AIDL 
     * @author weijiang204321 
     * 
     */  
    private final class StudentQueryBinder extends StudentQuery.Stub{  
        public String queryStudent(int number) throws RemoteException {           
            return query(number);  
        }         
    }  
  
}  

这个服务端的代码和我们之前的本地服务代码差不多，不同的是我们定义的Binder类是继承了StudentQuery.Stub类，其中StudentQuery是我们定义的AIDL文件，编译器帮我们生成的StudentQuery.java（在gen文件夹中）这个类，下面来看一下这个类吧：

[java] view
 plaincopy

/* 
 * This file is auto-generated.  DO NOT MODIFY. 
 * Original file: C:\\Users\\weijiang204321\\Desktop\\传智播客Android视频教程_源代码\\remoteService\\src\\cn\\itcast\\aidl\\StudentQuery.aidl 
 */  
package cn.itcast.aidl;  
//注意没有任何的访问权限修饰符  
  
public interface StudentQuery extends android.os.IInterface  
{  
/** Local-side IPC implementation stub class. */  
public static abstract class Stub extends android.os.Binder implements cn.itcast.aidl.StudentQuery  
{  
private static final java.lang.String DESCRIPTOR = “cn.itcast.aidl.StudentQuery”;  
/** Construct the stub at attach it to the interface. */  
public Stub()  
{  
this.attachInterface(this, DESCRIPTOR);  
}  
/** 
 * Cast an IBinder object into an cn.itcast.aidl.StudentQuery interface, 
 * generating a proxy if needed. 
 */  
public static cn.itcast.aidl.StudentQuery asInterface(android.os.IBinder obj)  
{  
if ((obj==null)) {  
return null;  
}  
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);  
if (((iin!=null)&&(iin instanceof cn.itcast.aidl.StudentQuery))) {  
return ((cn.itcast.aidl.StudentQuery)iin);  
}  
return new cn.itcast.aidl.StudentQuery.Stub.Proxy(obj);  
}  
@Override public android.os.IBinder asBinder()  
{  
return this;  
}  
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
{  
switch (code)  
{  
case INTERFACE_TRANSACTION:  
{  
reply.writeString(DESCRIPTOR);  
return true;  
}  
case TRANSACTION_queryStudent:  
{  
data.enforceInterface(DESCRIPTOR);  
int _arg0;  
_arg0 = data.readInt();  
java.lang.String _result = this.queryStudent(_arg0);  
reply.writeNoException();  
reply.writeString(_result);  
return true;  
}  
}  
return super.onTransact(code, data, reply, flags);  
}  
private static class Proxy implements cn.itcast.aidl.StudentQuery  
{  
private android.os.IBinder mRemote;  
Proxy(android.os.IBinder remote)  
{  
mRemote = remote;  
}  
@Override public android.os.IBinder asBinder()  
{  
return mRemote;  
}  
public java.lang.String getInterfaceDescriptor()  
{  
return DESCRIPTOR;  
}  
//通过number来访问学生的name  
  
@Override public java.lang.String queryStudent(int number) throws android.os.RemoteException  
{  
android.os.Parcel _data = android.os.Parcel.obtain();  
android.os.Parcel _reply = android.os.Parcel.obtain();  
java.lang.String _result;  
try {  
_data.writeInterfaceToken(DESCRIPTOR);  
_data.writeInt(number);  
mRemote.transact(Stub.TRANSACTION_queryStudent, _data, _reply, 0);  
_reply.readException();  
_result = _reply.readString();  
}  
finally {  
_reply.recycle();  
_data.recycle();  
}  
return _result;  
}  
}  
static final int TRANSACTION_queryStudent = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
}  
//通过number来访问学生的name  
  
public java.lang.String queryStudent(int number) throws android.os.RemoteException;  
}  

感觉好复杂，其实我们没必要看懂的，这个是Android内部实现的，我们在这里可以了解一下，看一下那个Stub抽象类，他实现了Binder接口，所以我们需要继承这个类就可以了，还有一个问题就是我们注意到，就是返回StudentQuery接口对象的问题：

[java] view
 plaincopy

public static cn.itcast.aidl.StudentQuery asInterface(android.os.IBinder obj)  
{  
if ((obj==null)) {  
return null;  
}  
//如果bindService绑定的是同一进程的service,返回的是服务端Stub对象本身，那么在客户端是直接操作Stub对象，并不进行进程通信了  
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);  
if (((iin!=null)&&(iin instanceof cn.itcast.aidl.StudentQuery))) {  
return ((cn.itcast.aidl.StudentQuery)iin);  
}  
//bindService绑定的不是同一进程的service，返回的是代理对象，obj==android.os.BinderProxy对象，被包装成一个AIDLService.Stub.Proxy代理对象  
//不过AIDLService.Stub.Proxy进程间通信通过android.os.BinderProxy实现  
return new cn.itcast.aidl.StudentQuery.Stub.Proxy(obj);  
}  

/*</p><p> * Copyright (C) 2006 The <b style="color:black;background-color:#ffff66">Android</b> Open Source Project</p><p> *</p><p> * Licensed under the Apache License, Version 2.0 (the "License");</p><p> * you may not use this file except in compliance with the License.</p><p> * You may obtain a copy of the License at</p><p> *</p><p> *      http://www.apache.org/licenses/LICENSE-2.0</p><p> *</p><p> * Unless required by applicable law or agreed to in writing, software</p><p> * distributed under the License is distributed on an "AS IS" BASIS,</p><p> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</p><p> * See the License for the specific language governing permissions and</p><p> * limitations under the License.</p><p> */</p><p>package <b style="color:black;background-color:#ffff66">android</b>.os;</p><p>/**</p><p> * Base class for Binder interfaces.  When defining a new interface,</p><p> * you must derive it from IInterface.</p><p> */</p><p>public interface IInterface</p><p>{</p><p>    /**</p><p>     * Retrieve the Binder object associated with this interface.</p><p>     * You must use this instead of a plain cast, so that proxy objects</p><p>     * can return the correct result.</p><p>     */</p><p>    public IBinder asBinder();</p><p>}</p><p>

上面的是Interface接口，他只有一个方法asBinder()这个方法就是返回一个IBinder对象，而我们的AIDL接口需要实现这个接口的，所以说这个asBinder()方法的功能就是将AIDL接口转化成IBinder对象，这个是内部实现的，在asInterface()方法中可以看到：

private static class Proxy implements com.demo.aidl.StudentAIDL</p><p>		{</p><p>			private <b style="color:black;background-color:#ffff66">android</b>.os.IBinder mRemote;</p><p>			Proxy(<b style="color:black;background-color:#ffff66">android</b>.os.IBinder remote)</p><p>			{</p><p>				mRemote = remote;</p><p>			}</p><p>			@Override public <b style="color:black;background-color:#ffff66">android</b>.os.IBinder asBinder()</p><p>			{</p><p>				return mRemote;</p><p>			}</p><p>			public java.lang.String getInterfaceDescriptor()</p><p>			{</p><p>				return DESCRIPTOR;</p><p>			}</p><p>			@Override public java.lang.String queryNameByNo(int no) throws <b style="color:black;background-color:#ffff66">android</b>.os.RemoteException</p><p>			{</p><p>				<b style="color:black;background-color:#ffff66">android</b>.os.Parcel _data = <b style="color:black;background-color:#ffff66">android</b>.os.Parcel.obtain();</p><p>				<b style="color:black;background-color:#ffff66">android</b>.os.Parcel _reply = <b style="color:black;background-color:#ffff66">android</b>.os.Parcel.obtain();</p><p>				java.lang.String _result;</p><p>				try {</p><p>					_data.writeInterfaceToken(DESCRIPTOR);</p><p>					_data.writeInt(no);</p><p>					mRemote.transact(Stub.TRANSACTION_queryNameByNo, _data, _reply, 0);</p><p>					_reply.readException();</p><p>					_result = _reply.readString();</p><p>				}</p><p>				finally {</p><p>					_reply.recycle();</p><p>					_data.recycle();</p><p>				}</p><p>				return _result;</p><p>			}</p><p>		}

这个是代理生成类，我们可以看到这个类中是返回的mRemote对象就是IBinder的一个引用，同时也返回了一个StudentQuery实现对象。

在StudentQuery.Stub中有一个asInterface方法，这个方法中我们可以看到，如果这个Service和Client是在同一个进程中，则在Client中的StudentConnection类中返回的是IBinder就是实际的对象，如果不是在同一个进程中的话，返回的是IBinder的代理对象。

其他的问题我们暂时不看了，也不去做深入的了解了，

再来看一下AndroidMainfest.xml文件中配置Service:

[java] view
 plaincopy

<service android:name=“.StudentQueryService”>  
            <intent-filter >  
                <action android:name=“cn.itcast.student.query”/>                  
            </intent-filter>              
</service>  

这里我们开启服务的话，需要用到隐式意图了，而不能直接用Service类了，因为是在不同的应用中，这样服务端的代码就差不多了，我们现在来看一下客户端的代码结构：

首先来看一下，客户端肯定要有aidl文件，所以我们将服务端的aidl的文件拷到Client中(包括AIDL所在的包也要拷过来，刷新一下，在gen文件夹中出现了StudentQuery.java类)，下面来看一下Client的代码(MainActivity.java):

[java] view
 plaincopy

package cn.itcast.remoteservice.client;  
  
import android.app.Activity;  
import android.content.ComponentName;  
import android.content.Intent;  
import android.content.ServiceConnection;  
import android.os.Bundle;  
import android.os.IBinder;  
import android.os.RemoteException;  
import android.util.Log;  
import android.view.View;  
import android.widget.EditText;  
import android.widget.TextView;  
import cn.itcast.aidl.StudentQuery;  
  
/** 
 * 客户端的测试代码 
 * @author weijiang204321 
 * 
 */  
public class MainActivity extends Activity {  
    //定义控件  
    private EditText numberText;  
    private TextView resultView;  
    private StudentQuery studentQuery;  
      
    //定义一个连接  
    private StudentConnection conn = new StudentConnection();  
  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
  
        numberText = (EditText) this.findViewById(R.id.number);  
        resultView = (TextView) this.findViewById(R.id.resultView);  
        //这里开启一个Service使用隐式意图action的名称必须和remoteService中AndroidMainfest.xml中定义的服务的action的name一样  
        Intent service = new Intent(“cn.itcast.student.query”);  
        bindService(service, conn, BIND_AUTO_CREATE);  
    }  
      
    /** 
     * 给按钮定义点击事件 
     * @param v 
     */  
    public void queryStudent(View v) {  
        String number = numberText.getText().toString();  
        int num = Integer.valueOf(number);  
        try {  
            resultView.setText(studentQuery.queryStudent(num));  
        } catch (RemoteException e) {  
            e.printStackTrace();  
        }  
    }  
  
    @Override  
    protected void onDestroy() {  
        unbindService(conn);  
        super.onDestroy();  
    }  
  
    /** 
     * 自定义StudentConnection实现了ServiceConnection 
     * @author weijiang204321 
     * 
     */  
    private final class StudentConnection implements ServiceConnection {  
        public void onServiceConnected(ComponentName name, IBinder service) {  
            //这里就用到了Stub类中的asInterface方法，将IBinder对象转化成接口  
            studentQuery = StudentQuery.Stub.asInterface(service);  
        }  
        public void onServiceDisconnected(ComponentName name) {  
            studentQuery = null;  
        }  
    }  
}  

Client端的代码结构和我们之前的本地服务的代码结构差不多，有几处不同，第一处不同就是那个开启服务的方式，这里使用的是隐式的方式开启服务的，因为是跨应用访问的，还有一处不同的是返回的StudentQuery接口对象不同，本地服务的话是通过强制转化的，而远程服务这里是用asInterface方法进行转化的。

客户端和服务端的代码结构看完了，下面我们来运行一下，首先安装remoteService包，然后运行remoteClient包，在文本框中输入学号，查询到名称了，运行成功。在不同的应用中，一定是跨进程的，不行我们可以查看一下系统的进程：

这里我们使用adb命令查看：

http://blog.csdn.net/jiangwei0910410003/article/details/17114491

在这篇blog中我说到了怎么使用这条命令

我们可以看到有两个进程Proc #9和Proc #12

到这里我们就介绍了本地服务和远程服务的使用了，下面我们再来看一下额外的知识，就是怎么在一个应用中进行远程服务的访问，我们之前涉及到的是跨应用的访问，这里其实很简单，只需要改动一处就可以：下面是我改过的一个项目，在同一个应用中进行远程服务的访问，代码都是一样的，这里就不做介绍了；

这里需要修改的地方就是要在AndroidManifest.xml中修改一下Service的定义属性：

[html] view
 plaincopy

<service   
            android:name=“com.demo.remoteservice.StudentService”  
            android:process=“:remote”>  
            <intent-filter >  
                <action android:name=“com.demo.remoteservice.studentservice”/>  
            </intent-filter>  
</service>  

这里我们添加了一个属性就是android:process=”:remote”,这个属性就是将该服务设置成远程的，就是和Activity不在同一个进程中，具体的Service属性说明请看我的另外的一篇blog:

http://blog.csdn.net/jiangwei0910410003/article/details/18794945

运行结果是一样的，为了证明服务是远程服务，我们在使用上面的命令打印一下当前系统中的进程信息：

系统中的Proc #9和Proc #10两个进程，这里就介绍了怎么在同一个应用中跨进程访问服务。

下面在来看一下AIDL:

我们上面说到的AIDL是说他怎么用，而且很是简单，我现在来具体看一下AIDL文件的定义：

Aidl默认支持的类型包话java基本类型（int、long、boolean等）和（String、List、Map、CharSequence），如果要传递自定义的类型该如何实现呢？

要传递自定义类型，首先要让自定义类型支持parcelable协议，实现步骤如下：

1>自定义类型必须实现Parcelable接口，并且实现Parcelable接口的publicvoid writeToParcel(Parcel dest, int flags)方法。

2>自定义类型中必须含有一个名称为CREATOR的静态成员，该成员对象要求实现Parcelable.Creator接口及其方法。

3> 创建一个aidl文件声明你的自定义类型。

Parcelable接口的作用：实现了Parcelable接口的实例可以将自身的状态信息（状态信息通常指的是各成员变量的值）写入Parcel，也可以从Parcel中恢复其状态。Parcel用来完成数据的序列化传递。

下面来看一下例子：

1> 创建自定义类型，并实现Parcelable接口,使其支持parcelable协议。如：在cn.itcast.domain包下创建Person.java:

[java] view
 plaincopy

package cn.itcast.domain;  
import android.os.Parcel;  
import android.os.Parcelable;  
public class Person implements Parcelable  
  privateInteger id;  
  private Stringname;  
   
  public Person(){}  
  publicPerson(Integer id, String name) {  
  this.id = id;  
  this.name = name;  
  }  
  public IntegergetId() {  
  return id;  
  }  
  public voidsetId(Integer id) {  
  this.id = id;  
  }  
  public StringgetName() {  
  return name;  
  }  
  public voidsetName(String name) {  
  this.name = name;  
  }   
  @Override  
  public intdescribeContents() {  
  return 0;  
  }  
  @Override  
  public voidwriteToParcel(Parcel dest, int flags) {//把javanbean中的数据写到Parcel  

来源URL：http://cache.baiducontent.com/c?m=9d78d513d9901df918b0cf281a16a6274e14c4386d80c7150ec3e34d84145c563716f4cd2d351174c4b37e7070a85e2d9ee74572200250a0ebc29f3ed7ac935838f85323016a913162c46aaadc4755d650944d98df0da0faae3dc9e89491c85520d74e5524dda59c5a77458b39ac033194face0e08074be9b16520a80275229c2146b545fbe2337354c1b0860d129437863657c4f46bf12311bf18a1151d2643&p=8c759a45d5c15db949be9b7c1e4d89&newp=9363c815d9c342ad1ebcc7710f5491231610db2151d4d2173985&user=baidu&fm=sc&query=android+service+%B7%B5%BB%D8%D0%C5%CF%A2%B8%F8%BF%CD%BB%A7%B6%CB&qid=886e02bb00015df7&p1=5

http://blog.csdn.net/jiangwei0910410003/article/details/18978405