android四大组件是什么了，android四大组件的作用
来源：网络
关键字： android四大组件
更新时间：
延伸：本文除了聚合《android四大组件是什么了》，免费提供的有关android四大组件和android四大组件的作用的内容之一，已有不少的网友认为此***对自己有帮助！获取更多与《》相关的知识。
网友0的回答
activity 显示界面(显示的界面都是继承activity完成的) service 服务(后台运网友1的回答
Android有四大组件:Activity、Service、Broadcast Receiver、C网友2的回答
Android四大组件分别为activity、service、content provider、br网友1的回答
.自己想被 不会就文人呵呵了网友0的回答
Activity、Service、BroadCastReceiver、ContentProvider网友1的回答
Framework意思是框架,Androidframework就是已经安卓开发框架,提供了Andro网友2的回答
android四大组件分别为Activity、Service、BroadcastReceiver、C网友1的回答
最满意的回答
猜你感兴趣
回答问题赢iPhone 6Android开发之低调的Service - [ Android四大组件 ] - 看云
锲而舍之，朽木不折；锲而不舍，金石可镂。----荀况
今天学习了一下Service的用法就和大家一起来讨论Android中Service的相关知识点，如有谬误，欢迎批评指正，如有疑问欢迎留言。
一、Service用途
Service在Android中和Activity是属于同一级别上的组件，Android中的Service，其意思是“服务”，它在后台运行不可交互。Service自己不能运行，需要通过某一个Activity或者其它Context对象来调用，Context.startService()和Context.bindService()两种方式启动 Service 。 Service在Android中和Activity是属于同一级别上的组件，Android 中的Service ，其意思是“服务”，它是在后台运行，不可交互的。Service自己不能运行，需要通过某一个Activity或者其它Context对象来调用，Context.startService()和Context.bindService()两种方式启动 Service 。
Android 中的服务，它与 Activity不同，它是不能与用户交互的,不能自己启动的，运行在后台的程序(干着重的工作，却连个界面也没有，因此我说它低调)，如果我们退出应用时， Service进程并没有结束，它仍然在后台运行，那我们什么时候会用到Service呢？比如我们播放音乐的时候，有可能想边听音乐边干些其他事情，当我们退出播放音乐的应用，如果不用 Service，我们就听不到歌了，所以这时候就得用到Service了，又比如当我们一个应用的数据是通过网络获取的，不同时间（一段时间）的数据是不同的，这时候我们可以用 Service在后台定时更新，而不用每打开应用的时候在去获取。如果在 Service的 onCreate或者 onStart方法中做一些很耗时的动作，最好是启动一个新线程来运行这个 Service，因为，如果 Service运行在主线程中，会影响到程序的 UI操作或者阻塞主线程中的其它事情。
二、Service的生命周期
首先来看官网给出的Service的生命周期图
1.onCreate() 创建Service
2.onStart(Intent intent, int startId) 启动Service
3.onStartCommand(Intent intent, int flags, int startId)启动Service
4.onDestroy() 销毁Service
5.onBind() 返回一个IBinder接口对象给Service
从这个生命周期图中我们可以看到有两种启动Service的方法Context.startService和Context.bindService，对应的生命周期也分为两种情况：
(1)startService启动模式
从图中可以看出当我们采用Context.startService(intent)这种方式时，系统会实例化一个服务，依次调用onCreate()和onStartCommand()方法，之后服务就进入了运行状态，如果服务已经运行了我们再次启动时不会重新创建服务，系统会自动调用刚才我们启动的服务，并调用其onStart()方法，如果我们想销毁一个服务可以使用stopService(intent)方法，使用stopService()方法会调用onDestroy()方法此时服务就被销毁了，
(2)bindService启动模式
在这种模式下，调用bindService(Intent service, ServiceConnection conn, int flags)来绑定一个Service，这时Service会调用自身的onCreate()方法（前提是该Service未创建），系统会实例化一个服务，接着调用onBind(intent)方法调用onBind方法后调用者就可以和服务进行交互了，当我们采用bindService这种方法创建服务时，如果已经创建好了一个如果再进行创建，系统不会创建新的Service实例，也不会调用onBind方法，这种方式启动的服务的销毁方法是使用unbindService方法,此时onUnbind方法和onDestroy方法都会被调用。
关于bindService(Intent service, ServiceConnection conn, int flags)参数的说明
参数①service: Intent 对象
参数②conn:
ServiceConnection对象，实现其onServiceConnected()和onServiceDisconnected()在连接成功和断开连接时处理。后面有实例来进行说明
参数③flags:Service创建的方式，一般用Service.BIND_AUTO_CREATE表示绑定时自动创建。
可能有的人会问这两种启动模式有什么不同？
strarService和bindService的不同之处：startService模式下调用者与服务无必然联系，即使调用者结束了自己的生命周期，只要没有使用stopService方法停止这个服务，服务仍会运行；然而通常情况下，bindService模式下服务是与调用者同生共死的，在绑定结束之后，一旦调用者被销毁，服务就会终止，我们通常用一句话来形容bindService:不求同生，但求同死。
另外需要注意的是在Android2.0之前我们使用startService启动服务时都是习惯重写onStart方法，在Android2.0时系统引进了onStartCommand方法取代了onStart方法，但是为了兼容以前的程序，在onStartCommand方法中其实是调用了onStart方法，我们之后会做验证，不过我们最好还是重写onStartCommand方法。
小平同志曾经说过，实践是检验真理的唯一标准，下面我们就结合实例对上面的理论来做验证，以便加深印象
布局如下：
代码如下：
1.Service的代码
package com.example.
import android.app.S
import android.content.I
import android.os.B
import android.os.IB
import android.util.L
public class MyService extends Service {
private static final String TAG = "MyService";
public void onCreate() {
super.onCreate();
Log. i(TAG,"onCreate called" );
public void onStart(Intent intent, int startId) {
super. onStart(intent, startId);
Log. i(TAG,"onStart called" );
public int onStartCommand(Intent intent, int flags, int startId) {
Log. i(TAG,"onStartCommand called" );
return super.onStartCommand(intent, flags, startId);
public void onDestroy() {
super.onDestroy();
Log. i(TAG,"onDestroy called" );
public IBinder onBind(Intent intent) {
Log. i(TAG,"onBind called" );
public boolean onUnbind(Intent intent) {
Log. i(TAG,"onUnbind called" );
return super.onUnbind(intent);
2.MainActivity的代码
package com.example.
import android.os.B
import android.os.IB
import android.app.A
import ponentN
import android.content.C
import android.content.I
import android.content.ServiceC
import android.util.L
import android.view.M
import android.view.V
import android.view.View.OnClickL
import android.view.ViewGroup.LayoutP
import android.widget.B
public class MainActivity extends Activity {
protected static final String TAG = "MyService";
private Button btn_
private Button btn_
private Button btn_
private Button btn_
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout. activity_main);
findViews();
setClick();
private void findViews() {
btn_start=(Button) findViewById(R.id. btn_start);
btn_stop=(Button) findViewById(R.id. btn_stop);
btn_bind=(Button) findViewById(R.id. btn_bind);
btn_unbind=(Button) findViewById(R.id. btn_unbind);
private void setClick() {
//采用startService启动服务
btn_start.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
Intent intent= new Intent(MainActivity.this,MyService.class );
startService(intent);
//销毁服务
btn_stop.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
Intent intent= new Intent(MainActivity.this,MyService.class );
stopService(intent);
//绑定服务
btn_bind.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this,MyService.class );
bindService(intent, conn,Context. BIND_AUTO_CREATE);
//解除绑定
btn_unbind.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
unbindService( conn);
private ServiceConnection conn=new ServiceConnection() {
public void onServiceConnected(ComponentName name, IBinder service) {
//connected
Log. i(TAG,"onServiceConnection called." );
public void onServiceDisconnected(ComponentName name) {
因为服务是四大组件之一所以我们要在清单文件中配置，注意：如果启动的服务没有在清单文件中配置并不会报错(这种错误很难发现，切记要配置)，只是启动时不启动这个服务，所以在开发时一定要注意养成一个好的习惯---&对于四大组件一定要声明好之后就去配置否则如果忘记了还得花好长时间去寻找错误
配置代码如下：
android:name="com.example.servicepractice.MyService" &
&intent-filter&
&action android:name="com.example.service" /&
&category android:name="android.intent.category.DEFAULT" /&
&/intent-filter&
&/service&
如果我们的服务只在本应用中调用可以去掉这个属性是其他应用调用本应用中的服务时所配置的属性
从布局中我们可以看到一共有四个按钮我们首先来看前面两个按钮
1、"启动服务"和"销毁服务"学习
//采用startService启动服务
btn_start.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
Intent intent= new Intent(MainActivity.this,MyService.class );
startService(intent);
//销毁服务
btn_stop.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
Intent intent=new Intent(MainActivity.this,MyService. class);
stopService(intent);
首先我们点击启动按钮打印日志如下
我们发现它调用的方法的顺序是onCreate-&onStartCommand-&onStart
然后我们接着点击启动服务按钮打印结果如下
我们发现再次启动时系统并没有重新实例化这个Service，因为系统发现这个服务已经启动了，此时它会直接调用onStartCommand方法，在onStartCommand方法中会调用onStart方法
onStartCommand方法的源码：
/* @param intent The Intent supplied to {@link android.content.Context#startService},
* as given.
This may be null if the service is being restarted after
* its process has gone away, and it had previously returned anything
* except {@link #START_STICKY_COMPATIBILITY}.
* @param flags Additional data about this start request.
Currently either
* 0, {@link #START_FLAG_REDELIVERY}, or {@link #START_FLAG_RETRY}.
* @param startId A unique integer representing this specific request to
Use with {@link #stopSelfResult(int)}.
* @return The return value indicates what semantics the system should
* use for the service's current started state.
It may be one of the
* constants associated with the {@link #START_CONTINUATION_MASK} bits.
* @see #stopSelfResult(int)
public int onStartCommand(Intent intent, int flags, int startId) {
onStart(intent , startId);
return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY;
操作完启动服务按钮后我们接着点击销毁服务按钮打印日志如下
发现当调用 stopService(intent)这个方法是会调用Service的onDestroy方法从而销毁服务。
2."绑定服务"和"解除绑定"的学习
//绑定服务
btn_bind.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this,MyService.class );
bindService(intent, conn,Context. BIND_AUTO_CREATE);
//解除绑定
btn_unbind.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
unbindService( conn);
通过上面的 bindService(intent,conn,Context. BIND_AUTO_CREATE)这个方法我们发现通过需要一个ServiceConnection对象，ServiceConnection代表与服务的连接，它只有两个方法，onServiceConnected和onServiceDisconnected，前者是在操作者在连接一个服务成功时被调用，而后者是在服务崩溃或被杀死导致的连接中断时被调用，而如果我们自己解除绑定时则不会被调用，所以我们这里只研究onServiceConnected这个方法。
我们首先来看下ServiceConnection的代码
private ServiceConnection conn= new ServiceConnection() {
* Called when a connection to the Service has been established, with
* the {@link android.os.IBinder} of the communication channel to the
* Service.
* @param name The concrete component name of the service that has
* been connected.
* @param service The IBinder of the Service's communication channel,
* which you can now make calls on.
public void onServiceConnected(ComponentName name, IBinder service) {
//connected
Log. i( TAG,"onServiceConnection called." );
* Called when a connection to the Service has been lost.
This typically
* happens when the process hosting the service has crashed or been killed.
* This does &em¬ &/em& remove the ServiceConnection itself -- this
* binding to the service will remain active, and you will receive a call
* to {@link #onServiceConnected} when the Service is next running.
* @param name The concrete component name of the service whose
* connection has been lost.
public void onServiceDisconnected(ComponentName name) {
到这我们还差一步就可以绑定服务了，因为在前面服务中的onBind方法返回值为null,这样是不行的，要想实现绑定操作，必须返回一个实现了IBinder接口类型的实例，该接口描述了与远程对象进行交互的抽象协议，有了它我们才能与服务进行交互。所以我们要修改代码
public IBinder onBind(Intent intent) {
Log. i(TAG,"onBind called" );
return new Binder(){};
上面的代码中返回了一个Binder的实例，而这个Binder恰恰是实现了IBinder接口，所以这样就可以实现绑定服务的操作了
首先我们点击一下”绑定服务“按钮打印日志如下
我们发现onCreate方法、onBind方法和onServiceConnection方法被调用了，此时服务已经进入运行状态，如果此时我们再次点击”绑定服务“按钮,这三个方法都不会被调用然后点击”解除绑定“按钮打印日志如下
可以看到onUnbind方法和onDestroy方法被调用了，此时Service已经被销毁，整个生命周期结束。
由于bindService启动的服务是和应用绑定到一起的所以当MainActivity退出程序时，服务也会随之结束。
下面我们来说一种情况当我们点击"绑定服务"按钮之后我们点击两次“解除绑定”按钮会发现程序崩溃了，日志如下
还有一种情况，当我们点击“绑定服务”按钮后此时服务已经运行了，此时我们直接按“返回”键程序退出了，我们看到日志会报一个错
我们要解决这两种问题，我们可以定义一个变量，然后在Activity的onDestroy方法中解除绑定就ok了，也就是做如下修改
//定义一个变量，标识这个服务是否处于绑定状态
//定义一个绑定服务的方法
private void unbindService(){
if( binded){
unbindService( conn);
//解除绑定
btn_unbind.setOnClickListener( new OnClickListener() {
public void onClick(View v) {
unbindService();
//在onDestroy方法中调用解除绑定的方法
protected void onDestroy() {
unbindService();
这样上面两种错误就解决了，也体现了我们写代码的严谨性。
3.以上两种启动方法混合使用的学习
在上面我们讨论的都是一对相匹配的启动和销毁方式，可能有的人会问，那我这四个按钮混合着点击会有什么效果呢，接着我们来验证一下
首先我们点击"启动服务"按钮打印日志如下
这个和我们前面讨论的匹配没有问题，接着我们按下绑定服务按钮打印日志如下
调用了onBind方法接着我们点击解除绑定按钮日志如下
此时调用了onUbind方法，值得注意的是此时服务虽然解除了但是没有终止，而是继续运行，这时我们再次点击绑定服务按钮和解除服务按钮发现onbind和onUnbind方法都不会被调用，那么是不是没有绑定成功呢？***是虽然没有调用onBind方法但是还是绑定成功了，我们可以从如下日志验证
但是我们怎么销毁掉这个服务呢？***是：如果我们同时使用startService与bindService，Service终止需要unbindService与stopService同时调用，才能终止Service，不管startService与bindServicede的调用顺序，如果先调用unbindService此时服务不会自动终止，再调用stopService之后服务才会停止，如果先调用stopService此时服务也不会终止，而再调用unbindService或者之前调用bindService的context不在了(如Activity被finish的时候)之后服务才会自动停止；
总结+特别注意：
1、在调用 bindService 绑定到Service的时候，你就应当保证在某处调用 unbindService 解除绑定（尽管 Activity 被 finish 的时候绑定会自动解除，并且Service会自动停止）；
2、在使用 startService 启动服务之后，一定要使用 stopService停止服务，不管你是否使用bindService；
3、同时使用 startService 与 bindService 要注意到，Service 的终止，需要unbindService与stopService同时调用，才能终止 Service，不管 startService 与 bindService 的调用顺序，如果先调用 unbindService 此时服务不会自动终止，再调用 stopService 之后服务才会停止，如果先调用 stopService 此时服务也不会终止，而再调用 unbindService 或者 之前调用 bindService 的 Context 不存在了（如Activity 被 finish 的时候）之后服务才会自动停止；
4、当在旋转手机屏幕的时候，当手机屏幕在“横”“竖”变换时，此时如果你的Activity 如果会自动旋转的话，旋转其实是 Activity 的重新创建，因此旋转之前的使用 bindService 建立的连接便会断开（Context 不存在了），对应服务的生命周期与上述相同。
5、在 sdk 2.0 及其以后的版本中，对应的 onStart 已经被否决变为了 onStartCommand，不过之前的 onStart 任然有效。这意味着，如果你开发的应用程序用的 sdk 为 2.0 及其以后的版本，那么你应当使用 onStartCommand 而不是 onStart。
6、startService 启动服务想要用startService启动服务，不管Local (本地)还是 Remote(远程) 我们需要做的工作都是一样简单。当然要记得在Androidmanifest.xml 中注册 service。
好了这一篇就到这里了，欢迎大家留言交流，批评指正。
页面正在加载中Android开发四大组件之Service（详解篇），android四大-android100学习网
Android开发四大组件之Service（详解篇），android四大
Android开发四大组件之Service（详解篇），android四大
Android开发之四大组件——Service 一、Service
Service是android系统中的
Android开发四大组件之Service（详解篇），android四大
Android开发之四大组件——Service
一、Service
Service是android系统中的四大组件之一（Activity、Service、BroadcastReceiver、ContentProvider），它跟Activity的级别差不多，区别是Service只能运行在后台不提供用户界面，并且可以和其他组件进行交互。一个Service是一个可以长期运行在后台的应用程序组件,不提供用户界面。
另一个应用程序组件可以启动一个服务,它将继续在后台运行,即使 用户切换到另一个应用程序。 此外,一个组件可以绑定到一个服务 与之交互,甚至执行进程间通信(IPC)。 例如,一个服务可以在后台处理网络交易、播放音乐、执行文件I / O,或与内容提供者交互等。
一个服务可以基本上有两种形式：
一个服务将被开启,当一个应用程序组件(例如,一个Activity)启动它 调用startService()。一个服务一旦启动,可以无限期地在后台运行,即使启动它的组件被摧毁。通常情况下,
开始服务执行一个操作,不向调用者返回一个结果。 例如,它可能通过网络下载或上传文件。 当操作完成, 服务应该自动销毁。
一个服务被“绑定”当一个应用程序组件绑定到它通过调用bindService（）。一个绑定服务提供了一个客户端 - 服务器接口，允许组件与服务交互，发送请求，得到的结果，甚至这样做跨进程与进程间通信（IPC）。一个service可以同时和多个客户绑定，当多个客户都解除绑定之后，系统会销毁service
注意：一个服务运行在其宿主进程，该服务不会创建自己的线程，并不在一个单独的进程中运行的主线程（除非另行指定）。这意味着，如果你的服务是打算进行任何耗时操作（例如MP3播放或网络下载等），你应该在该服务中创建一个新的线程来执行该工作。通过使用一个单独的线程，你会减少应用程序的不响应（ANR）错误和应用程序的UI主线程可以继续致力于为响应用户的操作。
二、创建Service
要创建一个服务，你必须创建Service的子类（或者其现有的一个子类）。在实现的子类中处理Service生命周期的关键方面的一些回调方法，并提供了一种机制，组件绑定到该服务，可以根据需要重写这些回调方法：
onStartCommand()
每次客户端调用startService()方法启动该Service都会回调该方法。
该方法是每个Service的子类必须实现的方法。该方法返回一个IBinder对象，应用程序可以通过该对象和Service组件进行通信。如果你不希望允许绑定,那么应该返回null。
onCreate()
当Service第一次被创建后将立即回调该方法。
onDestroy()
当Service被销毁之前回调该方法，你创建的Service应该在这个方法中清理不在使用的资源,如线程，注册的侦听器，接收器等。
在配置文件中注册Service：
&manifest ...
...&application ...
&&service android:name=".ExampleService"/&
...&/application&&/manifest&
三、IntentService类
因为最开始的服务不需要同时处理多个请求（实际上是一个危险的多线程的情况下），这可能是最好的如果你实现你的服务使用intentservice类。
　IntentService是Service类的子类，用来处理异步请求。客户端可以通过startService(Intent)方法传递请求给IntentService。IntentService在onCreate()函数中通过HandlerThread单独开启一个线程来处理所有Intent请求对象（通过startService的方式发送过来的）所对应的任务，这样以免事务处理阻塞主线程。执行完所一个Intent请求对象所对应的工作之后，如果没有新的Intent请求达到，则自动停止Service；否则执行下一个Intent请求所对应的任务。
IntentService在处理事务时，还是采用的Handler方式，创建一个名叫ServiceHandler的内部Handler，并把它直接绑定到HandlerThread所对应的子线程。 ServiceHandler把处理一个intent所对应的事务都封装到叫做onHandleIntent的虚函数；因此我们直接实现虚函数onHandleIntent，再在里面根据Intent的不同进行不同的事务处理就可以了。
另外，IntentService默认实现了Onbind（）方法，返回值为null。
　　使用IntentService需要两个步骤：
　　1、写构造函数
　　2、实现虚函数onHandleIntent，并在里面根据Intent的不同进行不同的事务处理就可以了。
好处：处理异步请求的时候可以减少写代码的工作量，比较轻松地实现项目的需求
注意：IntentService的构造函数一定是参数为空的构造函数，然后再在其中调用super("name")这种形式的构造函数。
因为Service的实例化是系统来完成的，而且系统是用参数为空的构造函数来实例化Service的
下面是IntentService的一个实例：
class HelloIntentService
extends IntentService
* A constructor is required, and must call the super
IntentService(String)
* constructor with a name for the worker thread.
*/public HelloIntentService(){super("HelloIntentService");}/**
* The IntentService calls this method from the default workerthread with
* the intent that started the service. When this method returns,IntentService
* stops the service, as appropriate.
*/@Overrideprotected void onHandleIntent(Intent intent){// Normally we would do some work here, like download a file.// For our sample, we just sleep for 5 seconds.long endTime
= System.currentTimeMillis()+5*1000;while (System.currentTimeMillis()& endTime){synchronized
(this){try
wait(endTime
- System.currentTimeMillis());} catch(Exception e){}}}}}
四、The Lifecycle of a Service
不像是activity的生命周期回调函数，你不需要调用父类执行这些回调方法。
注：左边的图显示了使用的StartService（）创建的服务的生命周期和右边的图显示了使用StartService（）创建的服务的生命周期。
Service整体的生命时间是从onCreate()被调用开始，到onDestroy()方法返回为止。和Activity一样，Service在onCreate()中进行它的初始化工作，在onDestroy()中释放残留的资源。比如，一个音乐播放Service可以在onCreate()中创建播放音乐的线程，在onDestory()中停止这个线程。　　onCreate() 和 onDestroy()会被所有的Service调用，不论Service是通过startService()还是bindService()建立。
Service积极活动的生命时间（activelifetime）是从onStartCommand() 或onBind()被调用开始，它们各自处理由startService()或 bindService()方法传过来的Intent对象。
　　如果Service是通过startService()开启的，那么它的活动生命周期和整个生命周期一同结束。
　　如果Service是通过bindService ()开启的，它们它的活动生命周期是在onUnbind()方法返回后结束。
　　注意：尽管一个被开启的Service是通过调用 stopSelf() 或 stopService()来停止的，没有一个对应的回调函数与之对应，即没有onStop()回调方法。所以，当调用了停止的方法，除非这个Service和客户组件绑定，否则系统将会直接销毁它，onDestory()方法会被调用，并且是这个时候唯一会被调用的回调方法。
五、Managing the Lifecycleof a Bound Service
当绑定Service和所有客户端解除绑定之后，Android系统将会销毁它，（除非它同时被onStartCommand()方法开启）。
因此，如果你的Service是一个纯粹的绑定Service，那么你不需要管理它的生命周期。
然而，如果你选择实现onStartCommand()回调方法，那么你必须显式地停止service，因为service此时被看做是开启的。
这种情况下，Service会一直运行到它自己调用 stopSelf()或另一个组件调用stopService()，不论它是否和客户端绑定。
另外，如果你的Service被开启并且接受绑定，那么当系统调用你的 onUnbind()方法时，如果你想要在下次客户端绑定的时候接受一个onRebind()的调用（而不是调用 onBind()），你可以选择在 onUnbind()中返回true。onRebind()的返回值为void，但是客户端仍然在它的 onServiceConnected()回调方法中得到 IBinder 对象。
下图展示了这种Service（被开启，还允许绑定）的生命周期：
未完待续.............
Android有四大组件：Activity、Service、Broadcast Receiver、Content Provider。Activity做一个完整的Android程序，不想用到Activity，真的是比较困难的一件事情，除非是想做绿叶想疯了。因为Activity是Android程序与用户交互的窗口，在我看来，从这个层面的视角来看，Android的Activity特像网站的页面。Activity，在四大组件中，无疑是最复杂的，这年头，一样东西和界面挂上了勾，都简化不了，想一想，独立做一个应用有多少时间沦落在了界面上，就能琢磨清楚了。从视觉效果来看，一个Activity占据当前的窗口，响应所有窗口事件，具备有控件，菜单等界面元素。从内部逻辑来看，Activity需要为了保持各个界面状态，需要做很多持久化的事情，还需要妥善管理生命周期，和一些转跳逻辑。对于开发者而言，就需要派生一个Activity的子类，然后埋头苦干上述事情。对于Activity的更多细节，先可以参见：reference/android/app/Activity.html。后续，会献上更为详尽的剖析。Service服务，从最直白的视角来看，就是剥离了界面的Activity，它们在很多Android的概念方面比较接近，都是封装有一个完整的功能逻辑实现，只不过Service不抛头露脸，只是默默无声的做坚实的后盾。但其实，换个角度来看，Android中的服务，和我们通常说的Windows服务，Web的后台服务又有一些相近，它们通常都是后台长时间运行，接受上层指令，完成相关事务的模块。用运行模式来看，Activity是跳，从一个跳到一个，呃...，这有点像模态对话框（或者还像web页面好了...），给一个输入（抑或没有...），然后不管不顾的让它运行，离开时返回输出（同抑或没有...）。而Service不是，它是等，等着上层连接上它，然后产生一段持久而缠绵的通信，这就像一个用了Ajax页面，看着没啥变化，偷偷摸摸的和Service不知眉来眼去多少回了。但和一般的Service还是有所不同，Android的Service和所有四大组件一样，其进程模型都是可以配置的，调用方和发布方都可以有权利来选择是把这个组件运行在同一个进程下，还是不同的进程下。这句话，可以拿把指甲刀刻进脑海中去，它凸显了Android的运行特征。如果一个 Service，是有期望运行在于调用方不同进程的时候，就需要利用Android提供的RPC机制，为其部署一套进程间通信的策略。Android的RPC实现，如上图所示（好吧，也是从SDK中拿来主义的...），无甚稀奇，基于代理模式的一个实现，在调用端和服务端都去生成一个代理类，做一些序列化和反序列化的事情，使得调用端和服务器端都可以像调用一个本地接口一样使用RPC接口。Android中用来做数据序列化的类是Parcel，参见：/reference/android/os/Parcel.html，封装了序列化的细节，向外提供了足够对象化的访问接口，Android号称实现非常高效。还有就是AIDL (Android Interface Definition Language) ，一种接口定义的语言，服务的RPC接口，可以用AIDL来描述，这样，ADT就可以帮助你自动生成一整套的代理模式需要用到的类，都是想起来很乏力写起来很苦力的那种。更多内容，可以再看看：guide/......余下全文&&