在这里，我们将给大家分享关于您更喜欢哪种JavaWebServiceFramework？的知识，让您更了解您更喜欢哪种类型的阅读活动的本质，同时也会涉及到如何更有效地AndroidService学习篇
在这里，我们将给大家分享关于您更喜欢哪种Java Web Service Framework？的知识，让您更了解您更喜欢哪种类型的阅读活动的本质，同时也会涉及到如何更有效地Android Service 学习篇三：Service 启动方式之 bindService、Android Service 服务（一）—— Service、Android Service 详解四：开始停止 service、Android 之 Service 学习篇一：Service 启动方式之 startService的内容。
本文目录一览：- 您更喜欢哪种Java Web Service Framework？（您更喜欢哪种类型的阅读活动）
- Android Service 学习篇三：Service 启动方式之 bindService
- Android Service 服务（一）—— Service
- Android Service 详解四：开始停止 service
- Android 之 Service 学习篇一：Service 启动方式之 startService
您更喜欢哪种Java Web Service Framework？（您更喜欢哪种类型的阅读活动）
你有什么建议吗？
解决方法
Two examples
使用EJB3 Web服务可确保您的Web服务可以在任何符合Java EE的服务器上运行,而无需对服务器进行任何修改.
Android Service 学习篇三：Service 启动方式之 bindService
客户端通过调用 bindService 方法能够绑定服务，然后 Android 系统会调用服务的 onBind 回调方法，这个方法会返回一个跟服务端交互的 IBinder 对象。这个绑定是异步的，bindService 方法立即返回，并且不给客户端返回 IBinder 对象。要接受 IBinder 对象，客户端必须创建一个 ServiceConnection 类的实例，并且把这个实例传递给 bindService 方法。
注意：只有 Activity、Service 和内容提供器 (content provider) 能够绑定服务，广播接收器是不能绑定服务的。
通过绑定服务来实现功能有以下几个步骤：
实现一个 ServiceConnection 接口，并重写里面的 onServiceConnected 和 onServiceDisconnected 两个方法，其中，前者是在服务已经绑定成功后回调的方法，后者是在服务发生异常终止时调用的方法。
在客户端，通过 bindService 方法来异步地绑定一个服务对象，如果绑定成功，则会回调 ServiceConnection 接口方法中的 onServiceConnected 方法，并得到一个 IBinder 对象。
服务端通过创建一个 *.aidl 文件来定义一个可以被客户端调用的业务接口，同时，服务端还需要提供一个业务接口的实现类，并实现 *.aidl 中定义的所有方法，通常让这个实现类去继承 Stub 类。
注意：创建 aidl 文件时有几个注意点：
（1）定义的方法前面不能有修饰符，类似于接口的写法。
（2）支持的类型有：8 大基本数据类型，CharSequence，String，List<String>，Map，以及自定义类型。
自定义类型需要做到以下几点：
实现 Parcelable 接口。
定义一个 aidl 文件来声明该类型。
如果要在其他的 aidl 文件中使用，则必须要使用 import 来引用。
通过 Service 组件来暴露业务接口。
通过 Service 的 onBind 方法来返回被绑定的业务对象。
客户端如果绑定成功，就可以像调用自己的方法一样去调用远程的业务对象方法。
为了便于理解，可以看一看下面的这个项目，项目名为 ServiceINS。
先来看看项目的构成：
MainActivity：
package com.example.serviceins;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;
import android.widget.Toast;
public class MainActivity extends Activity {
private ICat cat;
private boolean isBound = false;// 用于判断是否绑定
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
// 绑定服务的连接回调接口
private ServiceConnection conn = new ServiceConnection() {
// 已经绑定完成时调用
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// 绑定成功后回调的方法
cat = ICat.Stub.asInterface(service);
isBound = true;
Toast.makeText(MainActivity.this, "绑定成功", Toast.LENGTH_SHORT)
.show();
}
// 服务发生异常终止时调用的方法
@Override
public void onServiceDisconnected(ComponentName name) {
isBound = false;
}
};
// 绑定服务
public void boundClick(View view) {
Intent intent = new Intent(this, MyBoundService.class);
// 这个绑定的步骤是异步的，绑定成功后会回调onServiceConnected方法
bindService(intent, conn, Context.BIND_AUTO_CREATE);
}
// 解除绑定
public void unBoundClick(View view) {
if (isBound) {
unbindService(conn);
Toast.makeText(MainActivity.this, "解除绑定成功", Toast.LENGTH_SHORT)
.show();
}
}
// 通过IPC调用业务方法
public void callClick(View view) {
if (cat == null) {
return;
}
try {
cat.setName("黑猫警长");
Toast.makeText(this,
cat.desc() + "\n" + cat.getPerson().toString(),
Toast.LENGTH_LONG).show();
} catch (RemoteException e) {
e.printStackTrace();
}
}
}activity_main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:onClick="boundClick"
android:text="绑定一个服务" />
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:onClick="unBoundClick"
android:text="解除绑定服务" />
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:onClick="callClick"
android:text="通过IPC调用业务方法" />
</LinearLayout>ICat.aidl：
package com.example.serviceins;
import com.example.serviceins.Person;
interface ICat {
void setName(String name);
String desc();
}ICatImpl：
package com.example.serviceins;
import android.os.RemoteException;
import com.example.serviceins.ICat.Stub;
/*
* 业务接口的具体实现类
*/
public class CatImpl extends Stub {
private String name;
@Override
public void setName(String name) throws RemoteException {
this.name = name;
}
@Override
public String desc() throws RemoteException {
return "hello! my name is " + name + "," + "I am a police.";
}
}MyBoundService：
package com.example.serviceins;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class MyBoundService extends Service {
public MyBoundService() {
}
@Override
public void onCreate() {
super.onCreate();
}
@Override
public IBinder onBind(Intent intent) {
return new CatImpl();
}
@Override
public boolean onUnbind(Intent intent) {
return super.onUnbind(intent);
}
@Override
public void onDestroy() {
super.onDestroy();
}
}
Android Service 服务（一）—— Service
一、 Service 简介
Service 是 android 系统中的四大组件之一（Activity、Service、BroadcastReceiver、ContentProvider），它跟 Activity 的级别差不多，但不能自己运行只能后台运行，并且可以和其他组件进行交互。service 可以在很多场合的应用中使用，比如播放多媒体的时候用户启动了其他 Activity 这个时候程序要在后台继续播放，比如检测 SD 卡上文件的变化，再或者在后台记录你地理信息位置的改变等等，总之服务总是藏在后台的。
Service 的启动有两种方式：context.startService() 和 context.bindService()
二、 Service 启动流程
context.startService () 启动流程：
context.startService() -> onCreate() -> onStart() -> Service running -> context.stopService() -> onDestroy() -> Service stop
如果 Service 还没有运行，则 android 先调用 onCreate ()，然后调用 onStart ()；
如果 Service 已经运行，则只调用 onStart ()，所以一个 Service 的 onStart 方法可能会重复调用多次。
如果 stopService 的时候会直接 onDestroy，如果是调用者自己直接退出而没有调用 stopService 的话，Service 会一直在后台运行，该 Service 的调用者再启动起来后可以通过 stopService 关闭 Service。
所以调用 startService 的生命周期为：onCreate --> onStart (可多次调用) --> onDestroy
context.bindService () 启动流程：
context.bindService() -> onCreate() -> onBind() -> Service running -> onUnbind() -> onDestroy() -> Service stop
onBind () 将返回给客户端一个 IBind 接口实例，IBind 允许客户端回调服务的方法，比如得到 Service 的实例、运行状态或其他操作。这个时候把调用者（Context，例如 Activity）会和 Service 绑定在一起，Context 退出了，Srevice 就会调用 onUnbind->onDestroy 相应退出。
所以调用 bindService 的生命周期为：onCreate --> onBind (只一次，不可多次绑定) --> onUnbind --> onDestory。
在 Service 每一次的开启关闭过程中，只有 onStart 可被多次调用 (通过多次 startService 调用)，其他 onCreate，onBind，onUnbind，onDestory 在一个生命周期中只能被调用一次。
三、 Service 生命周期
Service 的生命周期并不像 Activity 那么复杂，它只继承了 onCreate ()、onStart ()、onDestroy () 三个方法
当我们第一次启动 Service 时，先后调用了 onCreate ()、onStart () 这两个方法；当停止 Service 时，则执行 onDestroy () 方法。
这里需要注意的是，如果 Service 已经启动了，当我们再次启动 Service 时，不会在执行 onCreate () 方法，而是直接执行 onStart () 方法。
它可以通过 Service.stopSelf () 方法或者 Service.stopSelfResult () 方法来停止自己，只要调用一次 stopService () 方法便可以停止服务，无论调用了多少次的启动服务方法。
例子:
startService () 方式
MainActivity 代码:
package com.example.service_basic;
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.view.View;
import android.widget.Button;
import com.example.service_basic.service.Service_player;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button btn_start = (Button) findViewById(R.id.btn_start);
Button btn_stop = (Button) findViewById(R.id.btn_stop);
//启动service
btn_start.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//startService(new Intent("com.example.service_basic.MainActivity"));
startService(new Intent("com.music"));
}
});
//停止service
btn_stop.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//stopService(new Intent("com.example.service_basic.MainActivity"));
stopService(new Intent("com.music"));
}
});
}
}service 代码:
package com.example.service_basic.service;
import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;
import com.example.service_basic.R;
public class Service_player extends Service{
private static final String TAG = Service_player.class.getSimpleName();
private final IBinder mBinder = new LocalBinder();
MediaPlayer mp;
@Override
public void onCreate() {
Log.i(TAG, "onCreate()");
mp = MediaPlayer.create(Service_player.this, R.raw.h1);
super.onCreate();
}
@Override
public void onStart(Intent intent, int startId) {
Log.i(TAG, "onStart()");
mp.start();
}
@Override
public void onDestroy() {
Log.i(TAG, "onDestroy()");
super.onDestroy();
mp.stop();
}
@Override
public IBinder onBind(Intent arg0) {
Log.i(TAG, "onBind()");
mp.start();
return mBinder;
}
public class LocalBinder extends Binder{
public Service_player getService(){
return Service_player.this;
}
}
@Override
public boolean onUnbind(Intent intent) {
Log.i(TAG, "onUnbind()");
return super.onUnbind(intent);
}
}AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.service_basic"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="21" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name=".MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!-- 声明service android:name 指明 service 在项目中的路径 -->
<service android:name=".service.Service_player">
<intent-filter>
<!-- android:name="com.music" 可理解为通配符的意思-->
<action android:name="com.music"/>
<category android:name="android.intent.category.DEFAULT"/>
</intent-filter>
</service>
</application>
</manifest>bindService () 方式:
package com.example.service_basic;
import android.app.Activity;
import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.widget.Button;
public class BinderServiceActivity extends Activity{
private IBinder mBinder;
private ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName arg0) {
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mBinder = service;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button btn_start = (Button) findViewById(R.id.btn_start);
Button btn_stop = (Button) findViewById(R.id.btn_stop);
btn_start.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
bindService(new Intent("com.example.service_basic.MainActivity"), conn, Service.BIND_AUTO_CREATE);
}
});
btn_stop.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
unbindService(conn);
}
});
}
}五、 代码解析
1、Activity 中，PlayMusicService 中通过重写 OnClickListener 接口 onClick () 方法实现对播放音乐的控制，把音乐各种操作用数字通过 Intent 传递给 service
然后通过构造一个 Intent ， intent = new Intent ("com.homer.service.musicService");
其中，com.homer.service.musicService 是 AndroidManifest.xml 对 service 的定义，即上面 “注册 service”
2、Activity 中，音乐播放的控制，利用 Bundle 绑定数字 op 后，通过 startService (intent); 服务后发送出去
Bundle bundle = new Bundle();
bundle.putInt("op", op);
intent.putExtras(bundle);
startService(intent);
3、 Service 中，会处理 Activity 启动的 startService (intent); 服务，依次调用 service 的启动过程：onCreate --> onStart (可多次调用) --> onDestroy
onCreate()， 创建 mediaPlayer
onStart ()， 通过获取 Bundle bundle = intent.getExtras ();，提取 int op = bundle.getInt ("op");，然后执行响应的音乐播放操作
onDestroy()，停止并释放 mediaPlayer 音乐资源，如果当执行 context.stopService() 时调用此方法
4、Activity 中，onClick () 函数中 close 与 exit 是执行含义是不同的：
close ： 只是执行了 this.finish (); 关闭了本 Activity 窗体，service 并没有被关掉，音乐依然会继续在后台播放
exit ： 先调用了 stopService (intent); 关闭了 service 服务，在 Service 中会调用 3 中的 onDestroy () 停止并释放音乐资源，后才执行 this.finish (); 关闭了本 Activity 窗体
源码下载
六、 拓展知识（进程和声明周期）
Android 操作系统尝试尽可能长时间的保持应用的进程，但当可用内存很低时最终要移走一部分进程。怎样确定那些程序可以运行，那些要被销毁，Android 让每一个进程在一个重要级的基础上运行，重要级低的进程最有可能被淘汰，一共有 5 级，下面这个列表就是按照重要性排列的：
1 一个前台进程显示的是用户此时需要处理和显示的。下列的条件有任何一个成立，这个进程都被认为是在前台运行的。
a 与用户正发生交互的。
b 它控制一个与用户交互的必须的基本的服务。
c 有一个正在调用生命周期的回调函数的 service（如 onCreate ()、onStar ()、onDestroy ()）
d 它有一个正在运行 onReceive () 方法的广播接收对象。
只有少数的前台进程可以在任何给定的时间内运行，销毁他们是系统万不得已的、最后的选择 —— 当内存不够系统继续运行下去时。通常，在这一点上，设备已经达到了内存分页状态，所以杀掉一些前台进程来保证能够响应用户的需求。
2 一个可用进程没有任何前台组件，但它仍然可以影响到用户的界面。下面两种情况发生时，可以称该进程为可用进程。
它是一个非前台的 activity，但对用户仍然可用（onPause () 方法已经被调用）这是可能发生的，例如：前台的 activity 是一个允许上一个 activity 可见的对话框，即当前 activity 半透明，能看到前一个 activity 的界面，它是一个服务于可用 activity 的服务。
3 一个服务进程是一个通过调用 startService () 方法启动的服务，并且不属于前两种情况。尽管服务进程没有直接被用户看到，但他们确实是用户所关心的，比如后台播放音乐或网络下载数据。所以系统保证他们的运行，直到不能保证所有的前台可见程序都正常运行时才会终止他们。
4 一个后台进程就是一个非当前正在运行的 activity（activity 的 onStop () 方法已经被调用），他们不会对用户体验造成直接的影响，当没有足够内存来运行前台可见程序时，他们将会被终止。通常，后台进程会有很多个在运行，所以他们维护一个 LRU 最近使用程序列表来保证经常运行的 activity 能最后一个被终止。如果一个 activity 正确的实现了生命周期的方法，并且保存它当前状态，杀死这些进程将不会影响到用户体验。
5 一个空线程没有运行任何可用应用程序组，保留他们的唯一原因是为了设立一个缓存机制，来加快组件启动的时间。系统经常杀死这些内存来平衡系统的整个系统的资源，进程缓存和基本核心缓存之间的资源。
Android 把进程里优先级最高的 activity 或服务，作为这个进程的优先级。例如，一个进程拥有一个服务和一个可见的 activity，那么这个进程将会被定义为可见进程，而不是服务进程。
此外，如果别的进程依赖某一个进程的话，那么被依赖的进程会提高优先级。一个进程服务于另一个进程，那么提供服务的进程不会低于获得服务的进程。例如，如果进程 A 的一个内容提供商服务于进程 B 的一个客户端，或者进程 A 的一个 service 被进程 B 的一个组件绑定，那么进程 A 至少拥有和进程 B 一样的优先级，或者更高。
因为一个运行服务的进程的优先级高于运行后台 activity 的进程，一个 activity 会准备一个长时间运行的操作来启动一个服务，而不是启动一个线程–尤其是这个操作可能会拖垮这个 activity。例如后台播放音乐的同时，通过照相机向服务器发送一张照片，启动一个服务会保证这个操作至少运行在 service 进程的优先级下，无论这个 activity 发生了什么，广播接收者应该作为一个空服务而不是简单的把耗时的操作单独放在一个线程里。
Android Service 详解四：开始停止 service
开始一个 Service
你可以从一个 activity 或从其它应用的组件通过传递一个 Intent(指定了要启动的服务) 给 startService() 启动一个服务．Android 系统然后调用 service 的 onStartCommand() 方法并且把 Intent 传递给它．(你永远不能直接调用 onStartCommand()．)
例如，一个 activity 可以在调用 startService() 时使用一个明确的 intent 开始前文的例子中的 service(HelloSevice)：
Intentintent = new Intent(this, HelloService.class);
startService(intent);
startService() 方法会立即返回然后 Android 系统调用 service 的 onStartCommand() 方法．但是如果 service 尚没有运行，系统会先调用 onCreate()，然后调用 onStartCommand().
如果 service 没有提供绑定功能，传给 startService() 的 intent 是应用组件与 service 之间唯一的通讯方式．然而，如果你希望 service 回发一个结果，那么启动这个 service 的客户端可以创建一个用于广播 (使用 getBroadcast()) 的 PendingIntent 然后放在 intent 中传给 service，service 然后就可以使用广播来回送结果．
不同的启动请求导致对 service 的 onStartCommand() 的不同调用，但停止 service 的请求只有一个 (使用 stopSelf() 或 stopService())．
停止一个 service
一个＂启动的＂service 必须管理其自己的生命期．这表示，系统不会停止或销毁这种 service，除非内存不够用了并且 service 在 onStartCommand() 返回后会继续运行．所以，service 必须调用 stopSelf() 停止自己或由另一个组件调用 stopService() 来停止它．
一旦通过 stopSelf() 或 stopService() 发出了停止请求，系统就会尽可能快地销毁 service．
然而，如果你的 service 同时处理多个对 onStartCommand() 的请求，那么你不应在处理完一个请求之后就停止 service，因为你可能已经又收到了新的启动请求 (在第个完成后停止将会结束掉第二个)．要避免这个问题，你可以使用 stopSelf(int) 来保证你的停止请求对应于你最近的开始请求．也就是，当你调用 stopSelf(int) 时，你传递开始请求的 ID(传递给 onStartCommand() 的 startId) 给 service，如果 service 在你调用 stopSelf(int) 之前收到一了个新的开始请求，发现 ID 不同，于是 service 将不会停止．
注意：你的应用在完成工作后停止它所有的 service 是非常重要的．这可以避免浪费系统资源和消耗电量．如果需要，其它的组件可以调用 stopService() 停止 service．即使你为 service 启用了绑定，你也必须自己停止 service，甚至它收到了对 onStartCommand() 的调用也这样．
创建一个绑定的 Service
一个绑定的 service 是允许应用的组件通过调用 bindService() 来绑定它以创建一个能长期存在的连接 (并且一般不允许组件调用 startService() 来启动它)．
当你的 activity 或其它组件想与 service 交互或你的应用想基于 IPC 的向其它应用提供功能时，你应该创建一个绑定的 service．
要创建一个绑定的 service，你必须实现回调方法 onBind()，还要在其中返回一个 IBinder，这个 IBinder 定义了与 service 通讯的接口．其它应用组件就可以在之后调用 bindService() 来接收这个接口并开始调用 service 的方法．service 只在有应用组件绑定到它时才活着，所以当没有组件绑定到它时，系统就会宰了它 (你不需去停止一个绑定的 service，跟用 onStartCommand() 启动的 service 不一样)．
要创建一个绑定的 service，首先要做的就是定义客户端如何与 service 通讯的接口．这个接口必须是 IBinder 的一个实现，并且必须被回调方法 onBind() 返回．一旦客户端接收到 IBinder，它就可以开始与 service 进行交互．
多个客户端可以一起绑定到一个 service．当一个客户端完成与 service 的交互，它调用 unbindService() 来解除绑定．一旦不再有任何客户端绑定到 service，系统就宰了这个 service．
有很多方法来实现一个绑定的 service 并且这些实现要比＂开始的＂service 难懂得多．
发送通知给用户
一旦开始运行，一个 service 可以通过 Toast 通知或状态栏通来通知用户一些事件．
一个 toast 通知是一个出现在当前窗口表面上并过一会就消失的消息．当一个状态栏通知提供一个带有消息的图标到状态栏，用就可以先定它来执行一些动作 (比如启动一个 activity)．
通常，一个状态栏通知是当一些后台工作 (比如一个文件下载完成了) 完成后通知用户可以对它进行动作的最佳方式．当用户选择这个通知时，它可以开始一个 activity(比如可以查看下载的文件)．
原文链接： http://blog.csdn.net/nkmnkm/article/details/7331297
Android 之 Service 学习篇一：Service 启动方式之 startService
Service 概念及用途:
A service is an application component that can perform long-running operations in the background and does not provide a user interface。
通常 service 用来执行一些耗时操作，或者后台执行不提供用户交互界面的操作，例如：下载、播放音乐。
Service 生命周期 :
Android Service 的生命周期并不像 Activity 那么复杂，它只继承了 onCreate (),onStart (),onDestroy () 三个方法，当我们第一次启动 Service 时，先后调用了 onCreate (),onStart () 这两个方法，当停止 Service 时，则执行 onDestroy () 方法，这里需要注意的是，如果 Service 已经启动了，当我们再次启动 Service 时，不会在执行 onCreate () 方法，而是直接执行 onStart () 方法，具体的可以看下面的实例。
Service 与 Activity 通信:
Service 后端的数据最终还是要呈现在前端 Activity 之上的，因为启动 Service 时，系统会重新开启一个新的进程，这就涉及到不同进程间通信的问题了 (AIDL) 这一节我不作过多描述，当我们想获取启动的 Service 实例时，我们可以用到 bindService 和 onBindService 方法，它们分别执行了 Service 中 IBinder () 和 onUnbind () 方法。
这里要提及一点：继承 service 的子类在重写 service 的方法中，除了一个 onStart () 方法之外，还有一个 onStartCommand () 方法，有关 onStartCommand () 方法稍微作点介绍：
有了 Service 类我们如何启动他呢，有两种方法：
• Context.startService()
• Context.bindService()
1. 在同一个应用任何地方调用 startService () 方法就能启动 Service 了，然后系统会回调 Service 类的 onCreate () 以及 onStart () 方法。这样启动的 Service 会一直运行在后台，直到 Context.stopService () 或者 selfStop () 方法被调用。另外如果一个 Service 已经被启动，其他代码再试图调用 startService () 方法，是不会执行 onCreate () 的，但会重新执行一次 onStart () 。
2. 另外一种 bindService () 方法的意思是，把这个 Service 和调用 Service 的客户类绑起来，如果调用这个客户类被销毁，Service 也会被销毁。用这个方法的一个好处是，bindService () 方法执行后 Service 会回调上边提到的 onBind () 方发，你可以从这里返回一个实现了 IBind 接口的类，在客户端操作这个类就能和这个服务通信了，比如得到 Service 运行的状态或其他操作。如果 Service 还没有运行，使用这个方法启动 Service 就会 onCreate () 方法而不会调用 onStart ()。
区别概况为：运行界面：
工程目录结构：
ExampleService.java
package com.service.activity;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class ExampleService extends Service{
private static final String TAG = "ExampleService";
@Override
public void onCreate() {
Log.i(TAG, "ExampleService-onCreate");
super.onCreate();
}
@Override
public void onStart(Intent intent, int startId) {
Log.i(TAG, "ExampleService-onStart");
super.onStart(intent, startId);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
//执行文件的下载或者播放等操作
Log.i(TAG, "ExampleService-onStartCommand");
/*
* 这里返回状态有三个值，分别是:
* 1、START_STICKY：当服务进程在运行时被杀死，系统将会把它置为started状态，但是不保存其传递的Intent对象，之后，系统会尝试重新创建服务;
* 2、START_NOT_STICKY：当服务进程在运行时被杀死，并且没有新的Intent对象传递过来的话，系统将会把它置为started状态，
* 但是系统不会重新创建服务，直到startService(Intent intent)方法再次被调用;
* 3、START_REDELIVER_INTENT：当服务进程在运行时被杀死，它将会在隔一段时间后自动创建，并且最后一个传递的Intent对象将会再次传递过来。
*/
return super.onStartCommand(intent, flags, startId);
}
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG, "ExampleService-onBind");
return null;
}
@Override
public void onDestroy() {
Log.i(TAG, "ExampleService-onDestroy");
super.onDestroy();
}
}MainActivity.java
package com.service.activity;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity implements OnClickListener{
private static final String TAG = "MainActivity"; //日志输出标志
private Button btnStartService;
private Button btnStopService;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnStartService = (Button)findViewById(R.id.btnStartService);
btnStopService = (Button)findViewById(R.id.btnStopService);
btnStartService.setOnClickListener(this);
btnStopService.setOnClickListener(this);
}
//点击事件处理监听器
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this,ExampleService.class);
switch(v.getId()){
case R.id.btnStartService:
startService(intent);
break;
case R.id.btnStopService:
stopService(intent);
break;
default:
break;
}
}
}
<service android:name=".ExampleService"/>
创建完运行
在运行点击 "启动 service" 之后 (第一次启动 service)，我们可以查看 LogCat 控制台输出的日志如下：
这个时候我们点击 "返回"，Activity 被干掉了，但是我们的服务仍然在运行，可以查看 Setting-->Application-->Running Service, 截图如下：
然后回到我们的 Activity，再次点击启动 Service，控制台输出日志如下：
onCreate () 方法没有被调用，说明它并没有重新被创建。
然后我们点击停止 Service，输出日志如下：
今天关于您更喜欢哪种Java Web Service Framework？和您更喜欢哪种类型的阅读活动的讲解已经结束，谢谢您的阅读，如果想了解更多关于Android Service 学习篇三：Service 启动方式之 bindService、Android Service 服务（一）—— Service、Android Service 详解四：开始停止 service、Android 之 Service 学习篇一：Service 启动方式之 startService的相关知识，请在本站搜索。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
