服务器service系统,关于Service你所需要知道内容（一）

根据下面的目录来介绍和理解Service中的知识点：

一.Service的两种生命周期

service启动有两种方式：启动服务startService，绑定服务bindService。有不同是生命周期，如下所示：

image

1.若一个Service被多次startService启动，onCreate被调用一次，只有onStartCommand被调用多次。

2.onStartCommand必须放回一个整数=描述系统在杀死服务后应该如何继续运行：

a.START_NOT_STICKY;不会重建服务，除非还存在未发送的intent。当服务不再是必需的，并且应用程序能够简单地重启那些未完成的工作时，这是避免服务运行的最安全的选项。

b.START_STICKY；如果系统在onStartCommand()返回后杀死了这个service，会重新创建这个service并且调用onStartCommand()，但是不再重新发送上次最后一个intent，而是使用一个nullintent调用onStartCommand()，除非有一些挂起的intent，在此情况下，这些挂起的intent被派送。(适用媒体播放器类似服务，它们不执行命令，但需要一直运行并随时待命)

c.START_REDELIVER_INTENT；如果系统在onStartCommand()返回后杀死了service，重新创建这个service并且使用上次最后一个intent调用onStartCommand()．任何挂起的intent都顺序地被派送。(这适合于活跃地执行一个工作并且应被立即恢复的服务，比如下载一个文件)

3.启动并绑定一个service，如果没有解绑，调用stopService无法杀死服务。

4.unBindService()解除绑定服务，内部调用服务的生命周期方法onUnbind()，然后调用onDestory()销毁服务。服务只能被解除绑定一次，如果unBindService方法被调用多次，就会出错。

5.startService启动服务，调用者退出，service依旧还在；bindService绑定服务，调用者退出，service也就退出。

二.Service的两种启动方式

启动服务startService代码

Intent intent = new Intent(TestActivity.this,TestService.class);

startService(intent);

绑定服务bindService代码

private ServiceConnection mTestServiceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName componentName, IBinder iBinder) {

myBinder = (TestService.MyBinder) iBinder;

}

@Override

public void onServiceDisconnected(ComponentName componentName) {

}

};

Intent intent = new Intent(TestActivity.this,TestService.class);

bindService(intent,mTestServiceConnection,BIND_AUTO_CREATE);

绑定服务，首先要做的事情就是先用Map记录当前绑定服务所需的一些信息。 然后启动服务。

解绑服务，先从早前的Map集合中移除记录，然后停止服务。

如果再次解绑，无非就是再到这个map集合中找找有没有这条记录，没有就抛出服务没有注册的异常，也就是早前根本没有注册过任何服务。

三.远程服务

下图是根据不同方式对服务的分类，这里重点介绍实现远程服务

服务分类.png

实现远程服务的代码：

AIDL代码

// IRemoteService.aidl

package com.example.chenpeng.julyapplication.service;

// Declare any non-default types here with import statements

import com.example.chenpeng.julyapplication.IParticipateCallback;

interface IRemoteService {

int add(int a , int b);

void join(IBinder token,String userName);

void leave(IBinder token);

List getParticipators();

void registerParticipateCallback(IParticipateCallback cb);

void unregisterParticipateCallback(IParticipateCallback cb);

}

创建完AIDL文件以后，点击Build->Rebuild Project，在app\build\generated\source\aidl\debug中会有对应的ADIL的Java接口文件。生成如下代码：

package com.example.chenpeng.julyapplication.service;

public interface IRemoteService extends android.os.IInterface

{

/** 内部类Stub，继承Binder */

public static abstract class Stub extends android.os.Binder implements com.example.chenpeng.julyapplication.service.IRemoteService

{

/**Binder的唯一标识，一般用当前的类名表示*/

private static final java.lang.String DESCRIPTOR = "com.example.chenpeng.julyapplication.service.IRemoteService";

public Stub()

{

this.attachInterface(this, DESCRIPTOR);

}

/**

* 用于将服务端的Binder对象转换成客户端所需的AIDL接口类型的对象，这种转换过程区分进程

* 如果客户端和服务端位于同一个进程，返回服务端的Stub对象本身；否则返回系统封装后的Stub.proxy对象

*/

public static com.example.chenpeng.julyapplication.service.IRemoteService asInterface(android.os.IBinder obj)

{

if ((obj==null)) {

return null;

}

android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);

if (((iin!=null)&&(iin instanceof com.example.chenpeng.julyapplication.service.IRemoteService))) {

return ((com.example.chenpeng.julyapplication.service.IRemoteService)iin);

}

return new com.example.chenpeng.julyapplication.service.IRemoteService.Stub.Proxy(obj);

}

/**返回当前Binder对象*/

@Override public android.os.IBinder asBinder()

{

return this;

}

/**

* 这个方法运行在服务端中的Binder线程池中，当客户端发起跨进程请求时，远程请求会通过系统底层封装后交由此方法处理。

* 通过code可以确定调用哪个方法，如有入参，从data中获取，方法完成后，如需要返回参数，将参数存入result中。

* 若果，onTransact返回false，则客户端的请求失败，因此可以利用这个特征来做权限验证。

* */

@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_add:

{

data.enforceInterface(DESCRIPTOR);

int _arg0;

_arg0 = data.readInt();

int _arg1;

_arg1 = data.readInt();

int _result = this.add(_arg0, _arg1);

reply.writeNoException();

reply.writeInt(_result);

return true;

}

case TRANSACTION_join:

{

data.enforceInterface(DESCRIPTOR);

android.os.IBinder _arg0;

_arg0 = data.readStrongBinder();

java.lang.String _arg1;

_arg1 = data.readString();

this.join(_arg0, _arg1);

reply.writeNoException();

return true;

}

case TRANSACTION_leave:

{

data.enforceInterface(DESCRIPTOR);

android.os.IBinder _arg0;

_arg0 = data.readStrongBinder();

this.leave(_arg0);

reply.writeNoException();

return true;

}

case TRANSACTION_getParticipators:

{

data.enforceInterface(DESCRIPTOR);

java.util.List _result = this.getParticipators();

reply.writeNoException();

reply.writeStringList(_result);

return true;

}

case TRANSACTION_registerParticipateCallback:

{

data.enforceInterface(DESCRIPTOR);

com.example.chenpeng.julyapplication.IParticipateCallback _arg0;

_arg0 = com.example.chenpeng.julyapplication.IParticipateCallback.Stub.asInterface(data.readStrongBinder());

this.registerParticipateCallback(_arg0);

reply.writeNoException();

return true;

}

case TRANSACTION_unregisterParticipateCallback:

{

data.enforceInterface(DESCRIPTOR);

com.example.chenpeng.julyapplication.IParticipateCallback _arg0;

_arg0 = com.example.chenpeng.julyapplication.IParticipateCallback.Stub.asInterface(data.readStrongBinder());

this.unregisterParticipateCallback(_arg0);

reply.writeNoException();

return true;

}

}

return super.onTransact(code, data, reply, flags);

}

/**

* 这个方法运行在客户端

* 先把参数写入_data中，接着调用transact方法发起RPC(远程过程调用)请求，同时当前线程挂起；然后服务端的onTransact方法被调用，

* 直到RPC过程返回后，当前线程继续执行，并从_reply中取出RPC过程的返回结果，最后返回_reply中的数据

* */

private static class Proxy implements com.example.chenpeng.julyapplication.service.IRemoteService

{

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;

}

@Override public int add(int a, int b) throws android.os.RemoteException

{

android.os.Parcel _data = android.os.Parcel.obtain();

android.os.Parcel _reply = android.os.Parcel.obtain();

int _result;

try {

_data.writeInterfaceToken(DESCRIPTOR);

_data.writeInt(a);

_data.writeInt(b);

mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);

_reply.readException();

_result = _reply.readInt();

}

finally {

_reply.recycle();

_data.recycle();

}

return _result;

}

@Override public void join(android.os.IBinder token, java.lang.String userName) throws android.os.RemoteException

{

android.os.Parcel _data = android.os.Parcel.obtain();

android.os.Parcel _reply = android.os.Parcel.obtain();

try {

_data.writeInterfaceToken(DESCRIPTOR);

_data.writeStrongBinder(token);

_data.writeString(userName);

mRemote.transact(Stub.TRANSACTION_join, _data, _reply, 0);

_reply.readException();

}

finally {

_reply.recycle();

_data.recycle();

}

}

@Override public void leave(android.os.IBinder token) throws android.os.RemoteException

{

android.os.Parcel _data = android.os.Parcel.obtain();

android.os.Parcel _reply = android.os.Parcel.obtain();

try {

_data.writeInterfaceToken(DESCRIPTOR);

_data.writeStrongBinder(token);

mRemote.transact(Stub.TRANSACTION_leave, _data, _reply, 0);

_reply.readException();

}

finally {

_reply.recycle();

_data.recycle();

}

}

@Override public java.util.List getParticipators() throws android.os.RemoteException

{

android.os.Parcel _data = android.os.Parcel.obtain();

android.os.Parcel _reply = android.os.Parcel.obtain();

java.util.List _result;

try {

_data.writeInterfaceToken(DESCRIPTOR);

mRemote.transact(Stub.TRANSACTION_getParticipators, _data, _reply, 0);

_reply.readException();

_result = _reply.createStringArrayList();

}

finally {

_reply.recycle();

_data.recycle();

}

return _result;

}

@Override public void registerParticipateCallback(com.example.chenpeng.julyapplication.IParticipateCallback cb) throws android.os.RemoteException

{

android.os.Parcel _data = android.os.Parcel.obtain();

android.os.Parcel _reply = android.os.Parcel.obtain();

try {

_data.writeInterfaceToken(DESCRIPTOR);

_data.writeStrongBinder((((cb!=null))?(cb.asBinder()):(null)));

mRemote.transact(Stub.TRANSACTION_registerParticipateCallback, _data, _reply, 0);

_reply.readException();

}

finally {

_reply.recycle();

_data.recycle();

}

}

@Override public void unregisterParticipateCallback(com.example.chenpeng.julyapplication.IParticipateCallback cb) throws android.os.RemoteException

{

android.os.Parcel _data = android.os.Parcel.obtain();

android.os.Parcel _reply = android.os.Parcel.obtain();

try {

_data.writeInterfaceToken(DESCRIPTOR);

_data.writeStrongBinder((((cb!=null))?(cb.asBinder()):(null)));

mRemote.transact(Stub.TRANSACTION_unregisterParticipateCallback, _data, _reply, 0);

_reply.readException();

}

finally {

_reply.recycle();

_data.recycle();

}

}

}

static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);

static final int TRANSACTION_join = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

static final int TRANSACTION_leave = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);

static final int TRANSACTION_getParticipators = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);

static final int TRANSACTION_registerParticipateCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4);

static final int TRANSACTION_unregisterParticipateCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5);

}

public int add(int a, int b) throws android.os.RemoteException;

public void join(android.os.IBinder token, java.lang.String userName) throws android.os.RemoteException;

public void leave(android.os.IBinder token) throws android.os.RemoteException;

public java.util.List getParticipators() throws android.os.RemoteException;

public void registerParticipateCallback(com.example.chenpeng.julyapplication.IParticipateCallback cb) throws android.os.RemoteException;

public void unregisterParticipateCallback(com.example.chenpeng.julyapplication.IParticipateCallback cb) throws android.os.RemoteException;

}

创建在服务端的Service代码

public class RemoteService extends Service {

private static final String TAG = "RemoteService";

private List mClient = new ArrayList<>();

private List mList = new ArrayList<>();

//RemoteCallbackList，帮我自动处理了Link-To-Death的问题

private RemoteCallbackList mRemoteCallbackList = new RemoteCallbackList<>();

private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {

@Override

public int add(int a, int b) throws RemoteException {

return a+b;

}

@Override

public void join(IBinder token, String userName) throws RemoteException {

if(findClient(token) < 0){

Client client = new Client(token,userName);

//注册客户端死掉的通知

mClient.add(client);

client.mToken.linkToDeath( client,0);

Log.i(TAG, "join: client token = " + token + " 加入client队列");

notifyParticipate(client.mName,true);

}else{

Log.i(TAG, "join: client成员已存在");

}

}

@Override

public void leave(IBinder token) throws RemoteException {

int index = findClient(token);

if(index >= 0 ){

Client client = mClient.get(index);

//取消注册

client.mToken.unlinkToDeath( client,0);

mClient.remove(client);

Log.i(TAG, "leave: 删除token = " + token);

notifyParticipate(client.mName,false);

}

}

@Override

public List getParticipators() throws RemoteException {

int size = mClient.size();

for(int i = 0 ; i < size ; i++){

mList.add(mClient.get(i).mName);

}

return mList;

}

@Override

public void registerParticipateCallback(IParticipateCallback cb) throws RemoteException {

mRemoteCallbackList.register(cb);

}

@Override

public void unregisterParticipateCallback(IParticipateCallback cb) throws RemoteException {

mRemoteCallbackList.unregister(cb);

}

};

//更新通知

private void notifyParticipate(String mName, boolean joinOrLeave) {

int length = mRemoteCallbackList.beginBroadcast();

for(int i = 0 ; i < length ; i++){

try {

//通知回调

mRemoteCallbackList.getBroadcastItem(i).onParticipate(mName,joinOrLeave);

} catch (RemoteException e) {

e.printStackTrace();

}

}

mRemoteCallbackList.finishBroadcast();

}

private int findClient(IBinder token){

int index = -1;

int size = mClient.size();

for(int i = 0 ; i < size ; i++){

if(mClient.get(i).mToken == token){

index = i;

}

}

return index;

}

@Nullable

@Override

public IBinder onBind(Intent intent) {

Log.i(TAG, "onBind: 绑定服务" );

return mBinder;

}

@Override

public void onDestroy() {

super.onDestroy();

mRemoteCallbackList.kill();

}

private class Client implements Binder.DeathRecipient{

IBinder mToken;

String mName;

public Client(IBinder token , String name){

mToken = token;

mName = name;

}

@Override

public void binderDied() {

//客户端的异常退出

int index = mClient.indexOf(this);

if(index < 0){

return;

}

Log.i(TAG, "binderDied: 异常退出的客户端名字 = " + mName);

mClient.remove(index);

}

}

}

在服务端的AndroidMinfest.xml中做一下配置

android:name=".service.RemoteService"

android:process=":remote"

android:exported="true"

>

//此处Intent的action最好写成“服务器端包名.aidl文件名”的形式

创建客户端，一个不同的应用，首先将aidl文件复制到工程中，位置内容必须原封不动，下面就是client的代码

public class MainActivity extends AppCompatActivity {

private Button mBindServiceBtn,mMethodBtn;

private IRemoteService mRemoteService;

private ServiceConnection mServiceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName componentName, IBinder iBinder) {

mRemoteService = IRemoteService.Stub.asInterface(iBinder);

}

@Override

public void onServiceDisconnected(ComponentName componentName) {

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

mBindServiceBtn = findViewById(R.id.bindServiceBtn);

mMethodBtn = findViewById(R.id.methodBtn);

mBindServiceBtn.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//通过Intent指定服务端的服务名称和所在包，与远程Service进行绑定

//参数与服务器端的action要一致,即"服务器包名.aidl接口文件名"

Intent intent = new Intent("com.example.chenpeng.julyapplication.service.IRemoteService");

//Android5.0后无法只通过隐式Intent绑定远程Service

//需要通过setPackage()方法指定包名，否则启动失败

intent.setPackage("com.example.chenpeng.julyapplication");

bindService(intent,mServiceConnection,BIND_AUTO_CREATE);

}

});

mMethodBtn.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

if(mRemoteService != null){

try {

int sum = mRemoteService.add(2,4);

Toast.makeText(getApplicationContext(),String.valueOf(sum),Toast.LENGTH_SHORT).show();

} catch (RemoteException e) {

e.printStackTrace();

}

}

}

});

}

}

四.IntentService原理