Android——Service服务介绍

来源：互联网发布：上知教育一个月多少钱编辑：程序博客网时间：2024/06/06 13:28

这一篇介绍一下Android的是四大组件中服务Service

Service组件也是可以执行程序的，它也是有自己的生命周期，创建，清单文件的配置，和Activity相似。可以理解成没有界面的Activity。

做背后工作的组件

Service 基本的。如下

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;
/**
 * Created by YacaToy on 2017/6/24.
 */
public class MyService extends Service {
    private String TAG = "MyService";
    //必须实现的方法
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.w(TAG, "onBind: ");
        return null;
    }
    //被创建时回调的方法
    @Override
    public void onCreate() {
        Log.w(TAG, "onCreate: ");
        super.onCreate();
    }
    //被启动时回调的方法
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.w(TAG, "onStartCommand: ");
        return super.onStartCommand(intent, flags, startId);
    }
    //被关闭之前回调的方法
    @Override
    public void onDestroy() {
        Log.w(TAG, "onDestroy: ");
        super.onDestroy();
    }
}

一个Service创建必须要有onBind()方法。没有的话就会报错。这个看报错提示就应该知道，所以不要担心。

然后就是Service三个基本回调方法。创建，启动还有就是销毁的时候的回调。

开启一个Service和开启一个Activity差不多，只是多了一个关闭。开启staticService(intent)，关闭stopService(intent)

//开启  
Button bt_static = (Button)findViewById(R.id.bt_static);
        bt_static.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startService(new Intent(MainActivity.this,MyService.class));
            }
        });
//关闭
        Button bt_stop = (Button)findViewById(R.id.bt_stop);
        bt_stop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                stopService(new Intent(MainActivity.this,MyService.class));
            }
        });

下面是点击效果

点击第一次开启

06-25 04:46:07.969 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MyService: onCreate: 
06-25 04:46:07.969 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MyService: onStartCommand: 

点击第二次开启

06-25 04:48:44.939 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MyService: onStartCommand: 

点击第三次开启

06-25 04:49:20.639 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MyService: onStartCommand: 

这里就可以看出。开启Service服务，onCreate之后调用一次。接下来来的开启都是onStartCommand。这样理解，已经创建了就只要启动了

点击关闭之后然后在开启，onCreate 又再次调用

06-25 04:52:24.339 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MyService: onDestroy: 
06-25 04:52:25.399 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MyService: onCreate: 
06-25 04:52:25.409 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MyService: onStartCommand: 

然后再来介绍绑定服务。绑定服务

当程序通过staticaService()和stopService()启动，关闭Service时，Serivce与访问者之间基本上不存在太多的关联，因此Series和访问者之间也无法进行通信

如果Service 和访问者之间需要进行方法调用或者交换，则应该使用bindService()和unbindService开启和绑定

下面就是代码

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;
/**
 * Created by YacaToy on 2017/6/24.
 */
public class MybindService extends Service {
   
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;
/**
 * Created by YacaToy on 2017/6/24.
 */
public class MybindService extends Service {
     private String TAG = "MybindService";
    private int count;  //这个是用来获取的时数据，等下Activity去出这个数
    private boolean quit = false;
//定义onBinder方法返回的对象
    private MyBinder binder = new MyBinder();
//通过继承Binder来实现IBinder类
    public class MyBinder extends Binder{
        public int getCount(){
            return count;
        }
    }
    //必须实现的方法，绑定该Service时回调该方法
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        //返回的是  binder对象
        return binder;
    }
    //
    @Override
    public void onCreate() {
        Log.w(TAG,"创建");
        super.onCreate();
        new Thread(){
            @Override
            public void run() {
                while (!quit){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        }.start();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.w(TAG,"创建");
        return super.onStartCommand(intent, flags, startId);
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        this.quit = true;
        Log.w(TAG,"销毁");
    }
}
}

下面是实现

 //绑定服务
 private ServiceConnection conn = new ServiceConnection() {
        //当该Activity成功和Service连接的时候调用该方法
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.w(TAG ,"onServiceConnected");
            binder = (MybindService.MyBinder) service;
        }
        //当该Activity成功和Service断开的时候调用该方法
        //类ServiceConnection中的onServiceDisconnected()方法在正常情况下是不被调用的，它的调用时机是当Service服务被异外销毁时，例如内存的资源不足时.
        @Override
        public void onServiceDisconnected(ComponentName name) {
            Toast.makeText(getApplicationContext(),"onServiceDisconnected",Toast.LENGTH_SHORT).show();
            System.out.println("ServiceDisconnected");
            Log.w(TAG ,"onServiceDisconnected");
        }
    };
        //绑定
        Button Bstatic = (Button) findViewById(R.id.bt_Bstatic);
        Bstatic.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bindService(new Intent(MainActivity.this,MybindService.class),conn, Service.BIND_AUTO_CREATE);
            }
        });
        //解除
        Button Bstop = (Button) findViewById(R.id.bt_Bstop);
        Bstop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                unbindService(conn);
            }
        });
        //获取数据
        Button bt_gethhhh = (Button) findViewById(R.id.bt_gethhhh);
        bt_gethhhh.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.w(TAG ,binder.getCount()+"");
            }
        });

下面看点击效果

06-25 05:41:46.349 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MybindService: 创建      //第一次点击    开启 
06-25 05:41:46.359 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MainActivity: onServiceConnected
06-25 05:41:48.759 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MainActivity: 2         //第一次点击获取  
06-25 05:41:49.979 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MainActivity: 3         //第二次点击获取  
06-25 05:41:52.039 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MainActivity: 5         //第三次点击获取  
06-25 05:41:56.359 11691-11691/mycervicedata.example.yacatoy.myservicedata W/MybindService: 销毁     //第一次点击销毁

创建，链接之后就不会再创建，再链接。。服务没二分之一秒的时候就会+1.所以去的数据都是不一样的。然后点击消毁。会返现

onServiceDisconnected并没有响应。这是因为

类ServiceConnection中的onServiceDisconnected()方法在正常情况下是不被调用的，它的调用时机是当Service服务被异外销毁时，例如内存的资源不足时.

然后如果服务以及销毁的时候还去点击销毁的话，会出现异常，这里要做个容错处理。下面我添个工具类。判断服务是是否存在。

import java.util.List;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningServiceInfo;
import android.content.Context;
public class ServiceUtil {
    /**
     * 
     * @param context 上下文
     * @param serviceName  需要判断的服务进程
     * @return  true 正在运行  否则 没有运行
     */
    public static boolean isRunning(Context context,String serviceName){
        //获取ActivityManager管理这对象，可以获取当前手机正在运行的所有服务
        ActivityManager mAM = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        //获取手机中正在运行的服务集合（多个服务）
        List<RunningServiceInfo> runningServices = mAM.getRunningServices(100);
        for(RunningServiceInfo runingService : runningServices){
            if(serviceName.equals(runingService.service.getClassName())){
                return true;
            }
        }
        
        return false;
        
    }
}

下面介绍一下IntentService

IntentService是Service的子类，因此它不是普通的Service，它比普通的Service增加了一些功能

首先看Service本省存在的问题

Service不会专门启动一个单独的线程，Service与它所在应用位于同一个进程中

Service不是一条新的线程，因此不应该在Service中直接处理耗时操作

而IntentService就解决了这个问题

IntentService会创建单独的worker线程来处理所所有的Intent请求

IntentService会创建单独的worker线程来处理onHandleIntent()方法实现的代码。因此开发者无须处理线程问题

当所有请求处理完成之后，IntentService会自动停止。因此开发者无须调用stopSelf()方法停止Service

为Service的onBind()方法提供默认实现，默认实现的onBind()方法返回null

为Service的onStartCommand()方法提供了默认实现，该实现会将Intent添加到对列当中

下面就是IntentService代码

import android.app.IntentService;
import android.content.Intent;
import android.support.annotation.Nullable;
import android.util.Log;
/**
 * Created by YacaToy on 2017/6/25.
 */
public class MyIntentSeriver extends IntentService {
    private final String Tag = "MyIntentSeriver";
//    @Override
//    public void onCreate() {
//        super.onCreate();
//        Log.w(Tag,"onHandleIntent");
//    }
//这个不带参数的构造方法一定要实现
    public MyIntentSeriver(){
        super("MyIntentSeriver");
    }
    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public MyIntentSeriver(String name) {
        super(name);
        Log.w(Tag,"onHandleIntent");
    }
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        Log.w(Tag,"onHandleIntent");
    }
}

点击事件

Button intentsService = (Button) findViewById(R.id.bt_IntentService);
        intentsService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.w(TAG ,"intentsService");
                startService(new Intent(MainActivity.this,MyIntentSeriver.class));
            }
        });

也就是这么简单，在onHandleIntent()中实现耗时操作

这里就简单做个Service做一个介绍。慢慢来，基础一定要牢固

有问题一起讨论。新手之间多交流

关于服务的生命周期：http://blog.csdn.net/iispring/article/details/48169339

去他的博客看一下。详细

阅读全文

0 0