Android 深入剖析 Service 服务机制

╰半夏微凉° 2022-01-23 04:11 345阅读 0赞

# Service #

> Service 是一个可以在后台执行长时间运行操作而不提供用户界面的应用组件。服务可由其他应用组件启动，而且即使用户切换到其他应用，服务仍将在后台继续运行。 此外，组件可以绑定到服务，以与之进行交互，甚至是执行进程间通信 (IPC)。 例如，服务可以处理网络事务、播放音乐，执行文件 I/O 或与内容提供程序交互，而所有这一切均可在后台进行。

# 转自大佬的博客--》[点击跳转 https://blog.csdn.net/qq\_43377749/article/details/90727638][https_blog.csdn.net_qq_43377749_article_details_90727638] #

![“Android”的图片搜索结果][Android]

--------------------

### 本地服务（LocalService） ###

> 为什么要使用 Service ？
> 
> 首先我们要看下 Service 和 Thread 的区别，Thread 是在活动中创建，但是其他活动却不能访问这个活动中的 Thread ，还有个问题，Thread 被创建后，如果没有在活动中被关闭， 那么即使活动 stop 了，该 Thread 的 run 仍会在运行。
> 
> 但是如果是 Service 则不同， Service 是伴随进程进行的，所以不管某个活动咋样咋样， 他都一直存在，而你可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService，Context.unbindService，来控制它，你也可以在 Service 里注册 BroadcastReceiver，在其他地方通过发送 broadcast 来控制它。

### LocalService 有两种开启方式： ###

--------------------

### 第一种启动方式： ###

使用 Service 的基本步骤：

1.  自定义一个 Service 类
2.  在 Mainfest.xml 中申明它
3.  调用 StartService 开启活动
4.  调用 StopService 借宿运行

startService(new Intent(this, MyService.class));
    stopService(new Intent(this, MyService.class));

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzc3NzQ5_size_16_color_FFFFFF_t_70][]

但是：

一旦前台的活动退出了，结束了，后台 sewrvice 仍一直在运行，在上一个活动调用中，所生成的数据无法释放。

--------------------

### 第二种启动方式-采用bind的方式开启服务 ###

步骤：

1.  自定义一个 Service 类
2.  在 Mainfest.xml 中申明它
3.  在活动中使用 bindService(Intent,ServiceConnection,int) 启动 Service
4.  调用 unbindService(ServiceConnection) 方法停止

> 生命周期：onCreate() -> onBind() -> onUnbind() -> onDestory()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzc3NzQ5_size_16_color_FFFFFF_t_70 1][]

--------------------

### 实例： ###

MyService

public class MyService extends Service {
     
        @Override
        public void onCreate() {
            super.onCreate();
            LogUtils.d("MyService-onCreate");
        }
     
        @Override
        public void onStart(Intent intent, int startId) {
            super.onStart(intent, startId);
            LogUtils.d("MyService-onStart");
        }
     
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            LogUtils.d("MyService-onStartCommand");
            return super.onStartCommand(intent, flags, startId);
        }
     
        //绑定服务时调用这个方法，返回一个IBinder对象
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            LogUtils.d("MyService-onBind");
            return new MyBinder();
        }
     
        @Override
        public boolean onUnbind(Intent intent) {
            LogUtils.d("MyService-onUnbind");
            return super.onUnbind(intent);
        }
     
        //服务挂了
        @Override
        public void onDestroy() {
            super.onDestroy();
            LogUtils.d("MyService-onDestroy");
        }
     
        public interface MyIBinder{
            void invokeMethodInMyService();
        }
     
        public class MyBinder extends Binder implements MyIBinder{
     
            public void stopService(ServiceConnection serviceConnection){
                unbindService(serviceConnection);
            }
     
            @Override
            public void invokeMethodInMyService() {
                for(int i =0; i < 20; i ++){
                    LogUtils.d("MyService-service is opening");
                }
            }
        }
    }

MainActivity

public class MainActivity extends BaseActivity implements View.OnClickListener {
     
        private long firstClicked = 0;
        private final int ANIMATE_TIME = 750;
        private String a = "";
        private MyService.MyBinder myBinder;
        private ServiceConnection serviceConnection;
     
        private Toolbar toolbar;
        private FloatingActionButton floatingActionButton;
    //    private CollapsingToolbarLayout toolbarLayout;
        private EditText editText;
        private Button bind, unbind;
     
        private Handler handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                floatingActionButton.animate().rotation(180).setDuration(ANIMATE_TIME);
            }
        };
     
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            LogUtils.d("onCreate");
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
     
            iniViews();
            editText.setText(a);
            iniToolBar(toolbar, getResources().getString(R.string.main_toolbar_title));
            replaceFragment();
        }
     
        private void iniViews(){
            toolbar = findViewById(R.id.toolbar);
    //        toolbarLayout = findViewById(R.id.collapsing_toolbar_layout);
            floatingActionButton = findViewById(R.id.to_dialog_activity);
            editText = findViewById(R.id.hello_edit);
            bind = findViewById(R.id.service_bind);
            unbind = findViewById(R.id.service_unbind);
     
            toolbar.setOnClickListener(this);
            floatingActionButton.setOnClickListener(this);
            bind.setOnClickListener(this);
            unbind.setOnClickListener(this);
        }
     
        private void replaceFragment(){
            FragmentManager manager = getSupportFragmentManager();
            FragmentTransaction transition = manager.beginTransaction();
            transition.replace(R.id.fragment, new TextFragment()).commit();
        }
     
        @Override
        protected void onStart() {
            LogUtils.d("onStart");
            super.onStart();
        }
     
        @Override
        protected void onResume() {
            LogUtils.d("onResume");
            super.onResume();
        }
     
        @Override
        protected void onStop() {
            LogUtils.d("onStop");
            super.onStop();
        }
     
        @Override
        protected void onPause() {
            LogUtils.d("onPause");
            super.onPause();
        }
     
        @Override
        protected void onDestroy() {
            LogUtils.d("onDestroy");
            super.onDestroy();
        }
     
        @Override
        protected void onRestart() {
            LogUtils.d("onRestart");
            super.onRestart();
        }
     
        @Override
        public void onClick(View v) {
            switch (v.getId()){
                case R.id.to_dialog_activity:
                    new Thread(){
                        @Override
                        public void run() {
                            handler.sendMessage(new Message());
                            try {
                                sleep(ANIMATE_TIME);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            MainActivity.anctionStart(MainActivity.this);
    //                        DialogActivity.anctionStart(MainActivity.this);
                            a = editText.getText().toString();
                        }
                    }.start();
                    break;
     
                case R.id.toolbar:
                    // ...
                    break;
     
                case R.id.service_bind:
    //                startService(new Intent(this, MyService.class));
                    serviceConnection = new MyServiceConnection();
                    bindService(new Intent(MainActivity.this, MyService.class), serviceConnection,
                            getApplicationContext().BIND_AUTO_CREATE);
                    break;
     
                case R.id.service_unbind:
    //                stopService(new Intent(this, MyService.class));
                    unbindService(serviceConnection);
                    break;
            }
        }
     
        @Override
        protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            floatingActionButton.animate().rotation(0).setDuration(ANIMATE_TIME);
        }
     
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            LogUtils.d("onCreateOptionsMenu");
            getMenuInflater().inflate(R.menu.options_menu, menu);
            return true;
        }
     
        class MyServiceConnection implements ServiceConnection {
     
            //这里的第二个参数IBinder就是Service中的onBind方法返回的
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                LogUtils.d("onServiceConnected");
                myBinder = (MyService.MyBinder) service;
            }
     
            @Override
            public void onServiceDisconnected(ComponentName name) {
                LogUtils.d("onServiceDisconnected");
            }
        }
     
        public static void anctionStart(AppCompatActivity activity){
            Intent intent = new Intent(activity, MainActivity.class);
            activity.startActivity(intent);
        }
     
    }

Mainfest 注册

--------------------

![“Android”的图片搜索结果][Android 1]

# RemoteService 远程服务 #

请看这篇：[看这位大佬 https://www.jianshu.com/p/43f36e5ba122][https_www.jianshu.com_p_43f36e5ba122]

--------------------

# IntentService #

> IntentService 继承自 Service 它相比 activity 有一些新的方法，一下我们来看看二者的不同：

1.  首先，Service 是单独的一条进程，所以不应该在其中再去 new 新的 Thread
2.  其次，Service 可被多个活动访问，所以其中不应该有 sleep 这样的耗时操作

**再来看看 IntentService 做对比：**

1.  IntentService 是继承自 Service 并处理异步请求的一个类，
2.  在 IntentService 内有一个工作线程来处理耗时操作，
3.  当任务执行完后，IntentService 会自动停止，不需要我们去手动结束。
4.  如果启动 IntentService 多次，那么每一个耗时操作会以工作队列的方式在 IntentService 的 onHandleIntent 回调方法中执行，依次去执行，执行完自动结束。

具体大家可以常考这篇：**[点击 https://www.jianshu.com/p/332b6daf91f0][https_www.jianshu.com_p_332b6daf91f0]**

--------------------

项目中测试代码地址：[https://github.com/FishInWater-1999/android\_four\_major\_components][https_github.com_FishInWater-1999_android_four_major_components]

# 本文转自大佬的博客--》[点击跳转 https://blog.csdn.net/qq\_43377749/article/details/90727638][https_blog.csdn.net_qq_43377749_article_details_90727638] #

[https_blog.csdn.net_qq_43377749_article_details_90727638]: https://blog.csdn.net/qq_43377749/article/details/90727638
[Android]: https://9to5google.com/wp-content/uploads/sites/4/2015/10/android-versions.jpg?quality=82&strip=all&w=1024
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzc3NzQ5_size_16_color_FFFFFF_t_70]: /images/20220123/02678af04684408dae82b965308dc5f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzc3NzQ5_size_16_color_FFFFFF_t_70 1]: /images/20220123/2f7b4cf50c6b4089b52a62076b5191e2.png
[Android 1]: https://tproger.ru/wp-content/uploads/2018/07/flying_android.jpg
[https_www.jianshu.com_p_43f36e5ba122]: https://www.jianshu.com/p/43f36e5ba122
[https_www.jianshu.com_p_332b6daf91f0]: https://www.jianshu.com/p/332b6daf91f0
[https_github.com_FishInWater-1999_android_four_major_components]: https://github.com/FishInWater-1999/android_four_major_components