android Server及IntentServer

一.Android Service服务:

Android中的服务是运行在后台的服务，他是不可见的没有界面的东西。你可以启动一个服务Service来播放音乐，或者记录你地理信息位置的改变，或者启动一个服务来运行并一直监听某种动作。Service和其他组件一样，都是运行在主线程中，因此不能用它来做耗时的请求或者动作。你可以在服务中开一一个线程，在线程中做耗时动作。

服务的生命周期图：

1.如何创建和开启一个服务：

第一步：创建一个类 ExampleService.java 继承android.app.Service

第二步：覆盖其中继承的方法如下：

public class ExampleService extends Service{    private static final String TAG = "Example";    @Override    public IBinder onBind(Intent intent)    {        return null;    }    @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");        return super.onStartCommand(intent, flags, startId);    }    @Override    public void onDestroy()    {        Log.i(TAG, "ExampleService===>>onDestroy");        super.onDestroy();    }}

第三步：启动服务：

    Intent intent = new Intent(MainActivity.this, ExampleService.class);    startService(intent);

第四步：关闭服务:

stopService(intent);//关闭服务

服务运行的生命周期顺序：

[onCreate()-->onStartCommand()--->onStart()-->运行服务--->调用stopService()--->onDestory()]

在Activity中通过startService()开启的服务，开启之后及时现在我们关闭Activity服务还一直在后台运行，只有调用stopService()才能关闭服务。

关闭Activity之后我们在此点击按钮重新开启服务。

注意：服务在后台运行我们再次点击startService()开启服务。将不会在调用 onCreate()服务。一个服务只会创建一次，销毁一次，但可以开始多次，因此，onCreate和onDestroy方法只会被调用一次，而onStart（或onStartCommand）方法会被调用多次。

如下图：

点击stopService()方法将关闭服务：

注意：onStart方法是在Android2.0之前的平台使用的.在2.0及其之后，则需重写onStartCommand方法，同时，旧的onStart方法则不会再被调用.

二.bindService()

Bound service 允许其它的组件（比如Activities）绑定到这个Service上，可以发送请求，也可以接受请求，甚至进行进程间的通话。Bound service 仅仅在服务于其它组件时存在，不能独自无限期的在后台运行。

调用者和服务绑在一起，调用者一旦退出服务也就终止[onCreate()-->onBind()-->onUnbind()-->onDestory()]

1.创建Bound Services

当创建一个能提供绑定功能的服务时，我们必须提供一个IBinder对象，客户端能使用这个对象与服务进行交互。在Android中有三种方式定义方式：

1.扩展Binder类

2.使用Messenger

3.使用AIDL (Android Interface Definition Language)

创建步骤：

第一步：.创建一个类BinderService.java 继承 android.app.Service

public class BinderService extends Service{    public class MyBinder extends Binder    {        public BinderService getBinderService()        {            return BinderService.this;        }    }    private MyBinder binder=new MyBinder();    private static final String TAg = "BinderService";    @Override    public IBinder onBind(Intent intent)    {        Log.i(TAg, "BinderService===>onBind()");        return binder;    }    public void UpFile()    {        Log.i(TAg, "BinderService===>UpFile()");    }    @Override    public void onCreate()    {        Log.i(TAg, "BinderService===>onCreate()");        super.onCreate();    }    @Override    public void onDestroy()    {        Log.i(TAg, "BinderService===>onDestroy()");        super.onDestroy();    }    @Override    public boolean onUnbind(Intent intent)    {        Log.i(TAg, "BinderService===>onUnbind()");        return super.onUnbind(intent);    }    }

第二步：在Service类中，创建一个Binder实例包含客户端能调用的公共方法返回当前服务对象

public class MyBinder extends Binder    {        public BinderService getBinderService()        {            return BinderService.this;        }    }

第三步：在onBind()方法中返回Binder实例

    private MyBinder binder=new MyBinder();    private static final String TAg = "BinderService";    @Override    public IBinder onBind(Intent intent)    {        return binder;    }

第四步：在客户端，从onServiceConnected()方法中获得Binder实例。

private void bindService()    {        Intent intent=new Intent(MainActivity.this,BinderService.class);        bindService(intent,conn,Context.BIND_AUTO_CREATE);    }    private void unBind()   {       if(isConnected)       {           unbindService(conn);       }   }    private ServiceConnection conn=new ServiceConnection()    {        @Override        public void onServiceDisconnected(ComponentName name)        {           isConnected=false;                    }        @Override//在onServiceConnected 中获取Binder的实例        public void onServiceConnected(ComponentName name, IBinder binder)        {            MyBinder myBinder=(MyBinder)binder;            BinderService service=myBinder.getBinderService();            service.UpFile();            isConnected=true;        }    };

通过调用 bindService()开启服务。

调用unBind()关闭服务，或者我们关闭Activity也会关闭服务

三.Android中Service运行在主线程中。

Android 中的服务是运行在主线程上的，通过下面的例子来说明Android服务运行的线程。如果是运行在主线程的，

那在服务中步要运行太耗时的操作。如果运行态耗时的操作将会是整个Activity处于假死状态，无在进行别的操作。如何要运行耗时操作

要用到多线程Thread 或者异步操作 InentService.

创建一个 MyServiceThread.java 继承 Service的服务:

public class MyServiceThread extends Service{    private static final String TAG = "MyServiceThread";    @Override    public IBinder onBind(Intent intent)    {        return null;    }    @Override    public void onCreate()    {        Log.i(TAG, "MyServiceThread===>>onCreatre===>>线程ID:"+Thread.currentThread().getId());        super.onCreate();    }    @Override    public int onStartCommand(Intent intent, int flags, int startId)    {            try        {
            //这里进行耗时的操作            Log.i(TAG, "MyServiceThread===>>onStartCommand===>>线程ID:"+Thread.currentThread().getId());            Log.i(TAG, "文件下载。。。。。");            Thread.sleep(5000);            Log.i(TAG, "文件下载完成。");        } catch (InterruptedException e)        {                    e.printStackTrace();        }        return super.onStartCommand(intent, flags, startId);    }    @Override    public void onDestroy()    {        Log.i(TAG, "MyServiceThread===>>onDestroy===>>线程ID:"+Thread.currentThread().getId());        super.onDestroy();    }    }

程序为开启耗时服务时：

开启耗时服务时：

运行截图：下图可看出Android 中的Service确实是运行在主线程中。从运行前和运行后，当我们点击开启服务，按钮在服务没有运行

结束时，背景处于黄色，此时不能进行其他的操作。如果要运行耗时的操作需要应用多线程操作。

三.Android中Service多线程操作运行耗时操作。

一下演示Android服务如何在多线程下进行耗时操作。

1.创建ManyThreadService.java 服务

public class ManyThreadService extends Service{    private static final String TAG = "ManyThreadService";    @Override    public IBinder onBind(Intent intent)    {        // TODO Auto-generated method stub        return null;    }    @Override    public void onCreate()    {            Log.i(TAG, "ManyThreadService==>>onCreate==>线程ID:"+Thread.currentThread().getId());        }    private class MyThread extends Thread    {        @Override        public void run()        {                        try            {                Log.i(TAG, "ManyThreadService==>>文件下载线程ID:"+Thread.currentThread().getId());                Log.i(TAG, "文件下载中。。。。。>>文件现在线程ID:"+Thread.currentThread().getId());                Thread.sleep(5000);                Log.i(TAG, "文件现在完成。 >>文件下线线程ID:"+Thread.currentThread().getId());            } catch (InterruptedException e)            {                // TODO Auto-generated catch block                e.printStackTrace();            }                    }            }    @Override    public int onStartCommand(Intent intent, int flags, int startId)    {                Log.i(TAG, "ManyThreadService==>>onStartCommand中开启线程==>线程ID"+Thread.currentThread().getId());        new MyThread().start();        return START_STICKY;    }    @Override    public void onDestroy()    {        Log.i(TAG, "ManyThreadService==>>onDestory==>线程ID"+Thread.currentThread().getId());        super.onDestroy();    }    }

2.创建新线程进行耗时操作:

private class MyThread extends Thread    {        @Override        public void run()        {                        try            {                Log.i(TAG, "ManyThreadService==>>文件下载线程ID:"+Thread.currentThread().getId());                Log.i(TAG, "文件下载中。。。。。>>文件现在线程ID:"+Thread.currentThread().getId());                Thread.sleep(5000);                Log.i(TAG, "文件现在完成。 >>文件下线线程ID:"+Thread.currentThread().getId());            } catch (InterruptedException e)            {                // TODO Auto-generated catch block                e.printStackTrace();            }                    }            }

3.开启新线程：

public int onStartCommand(Intent intent, int flags, int startId)    {                Log.i(TAG, "ManyThreadService==>>onStartCommand中开启线程==>线程ID"+Thread.currentThread().getId());        new MyThread().start();        return START_STICKY;    }

运行效果：从下图看出出，多线程并行操作，提高执行的效率。如果要在Android服务中执行耗时的并行操作服务，适应多线程操作时不错的选择。

如果只是运行异步请求操作 IntentService是不错的选择。

三.Android中IntentSevice操作。

IntentService是Service类的子类，用来处理异步请求。客户端通过startService(Intent)方法传递请求给IntentService，

IntentService通过worker thread处理每个Intent对象，执行完所有工作后自动停止Service。

写构造方法复写onHandleIntent()方法

IntentService执行如下操作

1.创建一个与应用程序主线程分开worker thread用来处理所有通过传递过来的Intent请求

2.创建一个work queue，一次只传递一个intent到onHandleIntent()方法中，从而不用担心多线程带来的问题

3.当处理完所有请求后自动停止服务，而不需要我们自己调用stopSelf()方法

4.默认实现了onBind()方法，返回值为null

5. 默认实现了onStartCommand()方法，这个方法将会把我们的intent放到work queue中，然后在onHandleIntent()中执行。

创建 MyIntentService.java 继承：android.app.IntentService

public class MyIntentService extends IntentService{    private static final String TAG = "MyIntentService";    public MyIntentService()    {        super("MyIntentService");    }    @Override    public IBinder onBind(Intent intent)    {        return null;    }    @Override    public void onCreate()    {         Log.i(TAG, "MyIntentService==>>onCreate==>>线程ID："+Thread.currentThread().getId());        super.onCreate();    }        @Override    public int onStartCommand(Intent intent, int flags, int startId)    {         Log.i(TAG, "MyIntentService==>>onStartCommand==>>线程ID："+Thread.currentThread().getId());        return super.onStartCommand(intent, flags, startId);    }    @Override    protected void onHandleIntent(Intent intent)    {                try        {            Log.i(TAG, "MyIntentService==>>onHandleIntent==>>线程ID："+Thread.currentThread().getId());            Log.i(TAG, "文件下载中。。。。。>>文件下载线程ID:"+Thread.currentThread().getId());            Thread.sleep(5000);            Log.i(TAG, "文件现在完成>>文件下载线程ID:"+Thread.currentThread().getId());        } catch (InterruptedException e)        {            // TODO Auto-generated catch block            e.printStackTrace();        }            }    @Override    public void onDestroy()    {         Log.i(TAG, "MyIntentService==>>onDestory==>>线程ID："+Thread.currentThread().getId());        super.onDestroy();    }}

运行效果：从下图可以看出，在每次开启服务时传过去的inent，耗时操作都是有一个线程来执行处理。而所有操作排列成一个线程队列，先执行完个操作，紧接着

执行下一个操作。执行完所以操作后服务会自动onDestory操作进行销毁。

更多相关文章

随机推荐