Android课程——四大组件之一Service

最新推荐文章于 2021-05-27 03:22:41 发布

小二君

最新推荐文章于 2021-05-27 03:22:41 发布

阅读量240

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/huihuidiling/article/details/79668968

版权

Android 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Android四大组件：activity、service、contentprovider、broadcast receiver。

一、Service简介

什么是service：

service是Android四大组件之一，和Activity的级别相当；
service是可以长时间运行在后台的不可见的、没有组件的组件；
service是运行在主线程中的；
service是可以跨进程调用。

使用service的好处：
service放在独立的线程中，相对来说比较安全。
service生命周期：
这里写图片描述

Service启动方式

Service有两种启动方式：startService和bindService。

startService的启动方式

使用startService方式启动Service的步骤

新建类继承Service：
重写Oncreate；（只会执行一次）
实现onbind方法；
重写onStartCommand；（调用多少次执行多少次）
重写onDestory方法；
在有Context环境中通过StartService启动service。

startService总结：

OnCreate只会执行一次，只要调用startService，OnStartCommand一定会执行；
Service运行在main线程中，做耗时操作需要另开一个子线程；
通过Intent进行传参，在OnStartCommand中接收参数；
无法获得service对象，直接操作service中的属性和方法；
调用stopService方法后，service执行Ondestoy方法后停止。

代码演示
Myservise：


public class MyService extends Service {
    private Context context;
    public MyService(Context context) {
        this.context=context;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    //创建时执行一次，只执行一次
    public void onCreate() {
        super.onCreate();
        Log.e("service","Oncreate");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e("service","onStartCommand");
        //一个子线程一旦启动了就不能停止
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    Log.e("Service"+Thread.currentThread().getName(),i+"****");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e("service","onDestroy");
    }
}

在这里做一个耗时操作，是另开一个子线程中的。

MainActivity：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private Button openbtn;
    private Button closebtn;
    private Intent intent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        openbtn = findViewById(R.id.open);
        closebtn = findViewById(R.id.close);
        openbtn.setOnClickListener(this);
        closebtn.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.open:
                Log.e("jj", "onClick:sss1 " );
                intent = new Intent(this, MyService.class);
                startService(intent);
                break;
            case R.id.close:
                Log.e("jj", "onClick:sss2 " );
                stopService(intent);
                break;
        }
    }
}

优点：使用简单，和Activity一样，只需几行代码即可启动service
缺点：无法获得service对象，直接操作service中的属性和方法

bindService启动方式

使用bindService方式启动Service的步骤

新建类继承Service：
重写Oncreate；（只会执行一次）
实现onbind方法；（绑定服务）
重写onUnbind；（解除绑定）
重写onDestory方法；
在有Context环境中实现ServiceConnection接口；
在有Context环境中通过bindService绑定Service；
在有Context环境中通过 onUnbindService解除service。

bindService方法：
在Context上下文中调用此方法即可触发绑定Service，此方法需要三个参数：

Intent对象，用于传参；
ServiceConnection接口对象；
flag标识，代表如何绑定Service，常用的flag是Context.BIND_AUTO_CREAT，代表service不存在时创建。

代码演示
Textservice ：

public class Textservice extends Service {
    private String TAG="test";

    private Guanjia guanjia=new Guanjia();
    class Guanjia extends Binder{
      //得到当前service的对象
        public Textservice getServiceObject(){
            return  Textservice.this;
        }
    }

public void fly(){

        Log.e(TAG,"开飞机");
}

    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG,"onBind...");
        return guanjia;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.e(TAG,"onUnbind");
        return super.onUnbind(intent);


    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(TAG,"onCreate");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

Activity：

public class ZhangsanActivity extends AppCompatActivity implements View.OnClickListener{
    private Button bangding;
    private Button jiechu;
    private ServiceConnection serviceConnection=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //通过管家中介作用，拿到Textservice服务
            Textservice textservice =((Textservice.Guanjia)service).getServiceObject();
            textservice.fly();
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_zhangsan);
        bangding=findViewById(R.id.bangding);
        jiechu=findViewById(R.id.jiechu);
        bangding.setOnClickListener(this);
        jiechu.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.bangding:
                Intent intent=new Intent(this,Textservice.class);
                bindService(intent,serviceConnection,BIND_AUTO_CREATE);
                break;
            case R.id.jiechu:
                unbindService(serviceConnection);
                break;
        }

    }
}

优点：可以得到Service对象，灵活控制Service内部的属性和方法
缺点：使用较为复杂

二、IntentService简介

什么是IntentService

IntentService是继承Service并处理异步任务的一个类；
在IntentService内有一个工作线程来处理耗时操作；
此线程无需我们控制和维护；
当多次启动时，会以队列形式逐一执行；
当执行完耗时操作后，此Service会自动停止。

使用IntentService步骤
新建一个类继承IntentService；
实现父类的构造方法；
重写onHandleIntent方法；
重写OnCreate方法；
重写ondestory方法；
在有Context环境中通过StartService启动Service。

onHandleIntent方法

需要执行耗时操作放在此方法中执行；
此方法会新开线程，不会在main线程中执行。

代码演示：

Service：

public class MyIntentservice extends IntentService {
        /**
         * Creates an IntentService.  Invoked by your subclass's constructor.
         *
         * @param name Used to name the worker thread, important only for debugging.
         */
        public MyIntentservice(String name) {
            super(name);
        }

        public MyIntentservice(){
            super("");//当前线程的名字
        }
        @Override
        protected void onHandleIntent(@Nullable Intent intent) {
            for(int i=0;i<10;i++){
                try {
                    Log.e("hhhh","eeeee");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

Activity：

public class LisiActivity extends AppCompatActivity implements View.OnClickListener{
    private Button lisijiechu;
    private Button lisitiaozhuan;
    private String TAG="LisiActivity";
    private ServiceConnection connection=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //通过管家中介作用，拿到Textservice服务
            Textservice textservice =((Textservice.Guanjia)service).getServiceObject();
            Log.e(TAG,"onServiceConnected");
            textservice.fly();

        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e(TAG,"onServiceDisconnected");

        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lisi);

        lisijiechu=findViewById(R.id.lisi_jiechu);
        lisitiaozhuan=findViewById(R.id.lisi_tiaozhuan);
        lisitiaozhuan.setOnClickListener(this);
        lisijiechu.setOnClickListener(this);

    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){

            case R.id.lisi_bangding:
                Intent intent=new Intent(this,MyIntentservice.class);
                startService(intent);
                break;
            case  R.id.lisi_jiechu:
                unbindService(connection);
                break;

        }
    }
}

######IntentService方法总结

会创建独立的工作线程来处理所有的intent请求；
会创建独立的工作线程来处理OnhandleIntent方法实现的代码，无需处理多线程问题；
多次调用时，按队列顺序逐一执行，每次执行都是从创建到销毁的全部过程。

优点：无需处理线程的创建与线程同步问题
缺点：无法精确控制线程执行过程，一旦线程启动后，只能等待线程执行完毕

三、IntentService和Service区别

Service是用于后台服务的，不是独立的进程，也不是独立的线程，它是依赖于应用程序的主线程的。
那么进行耗时操作时，就需要引入IntentService，IntentService是继承Service的，包含了Service的全部特性，当然也包含service的生命周期，那么与service不同的是，IntentService在执行onCreate操作的时候，内部开了一个线程，去你执行你的耗时操作。
在线程耗时操作时是串行的，线程排队机制。