Android学习记录——10.服务

我就是我 2023-06-12 11:04 3阅读 0赞

### 文章目录 ###

*  1.服务是什么
 *  2.Android多线程编译
 *   *  2.1 线程的基本用法
     *  2.2 在子线程中更新UI
     *  2.3 解析异步消息处理机制
     *  2.4 使用AsyncTask
 *  3.服务的基本用法
 *   *  3.1 定义一个服务
     *  3.2 启动和停止服务
     *  3.3 活动和服务进行通信
 *  4.服务的生命周期
 *  5.服务的更多技巧
 *   *  5.1 使用前台服务
     *  5.2 使用IntentService
 *  6.服务的最佳实践

# 1.服务是什么 #

服务（Service）是Android中实现程序后台运行的解决方案，它非常适合去执行那些不需要和用户交互而且还要求长期运行的任务。服务的运行不依赖于任何用户界面，即使程序被切换到后台，或者用户打开了另外一个应用程序，服务仍然能够保持正常运行。  
不过需要注意的是，服务并不是运行在一个独立的进程当中的，而是依赖于创建服务时所在的应用程序进程。当某个应用程序进程被杀掉时，所有依赖于该进程的服务也会停止运行。  
另外，也不要被服务的后台概念所迷惑，实际上服务并不会自动开启线程，所有的代码都是默认运行在主线程当中的。也就是说，我们需要在服务的内部手动创建子线程，并在这里执行具体的任务，否则就有可能出现主线程被阻塞住的情况。那么本篇博客的第一堂课，我们就先来学习一下关于Android多线程编程的知识。

# 2.Android多线程编译 #

熟悉Java的你，对多线程编程一定不会陌生吧。当我们需要执行一些耗时操作，比如说发起一条网络请求时，考虑到网速等其他原因，服务器未必会立刻响应我们的请求，如果不将这类操作放在子线程里去运行，就会导致主线程被阻塞住，从而影响用户对软件的正常使用。那么就让我们从线程的基本用法开始学习吧。

## 2.1 线程的基本用法 ##

Android多线程编程其实并不比Java多线程编程特珠，基本都是使用相同的语法。比如说， 定义一个线程只需要新建一个类继承自Thread，然后重写父类的run()方法，并在里面编写耗时逻辑即可，如下所示：

class MyThread extends Thread (
    @Override
    public void run() { 
    //处理具体的逻辑
        }
    }

那么该如何启动这个线程呢？其实也很简单，只需要new出MyThread的实例，然后调用它的start()方法，这样run()方法中的代码就会在子线程当中运行了，如下所示：

new MyThread().start();

当然，使用继承的方式耦合性有点高，更多的时候我们都会选择使用实现Runnable接口的 方式来定义一个线程，如下所示：

class MyThread implements Runnable { 
    @Override
    public void run() { 
    //处理具体的逻辑
    }
    }

如果使用了这种写法，启动线程的方法也需要进行相应的改变，如下所示：

MyThread myThread = new MyThread();
    new Thread(myThread).start();

可以看到，Thread的构造函数接收一个Runnable参数，而我们new出的MyThread正是一个实现了 Runnable接口的对象，所以可以直接将它传入到Thread的构造函数里。接着调用 Thread的start()方法，run()方法中的代码就会在子线程当中运行了。  
当然，如果你不想专门再定义一个类去实现Runnable接口，也可以使用匿名类的方式，这种写法更为常见，如下所示：

new Thread(new Runnable() { 
    @Override
    public void run() { 
    //处理具体的逻辑
    }
    }).start();

以上几种线程的使用方式相信你都不会感到陌生，因为在Java中创建和启动线程也是使用同样的方式。了解了线程的基本用法后，下面我们来看一下Android多线程编程与Java多线程编程不同的地方。

## 2.2 在子线程中更新UI ##

和许多其他的GUI库一样，Android的UI也是线程不安全的。也就是说，如果想要更新应 用程序里的UI元素，则必须在主线程中进行，否则就会出现异常。  
眼见为实，让我们通过一个具体的例子来验证一下吧。新建一个项目， 然后修改activity\_main.xml中的代码，如下所示：

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <Button
            android:id="@+id/change_text"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="改变文本"/>
    
        <TextView
            android:id="@+id/text"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:text="Hello world"
            android:textSize="20sp"/>
    </RelativeLayout>

布局文件中定义了两个控件，TextView用于在屏幕的正中央显示一个Hello world字符串， Button用于改变TextView中显示的内容，我们希望在点击Button后可以把TextView中显示的字 符串改成 Nice to meet you。  
接下来修改MainActivity中的代码，如下所示：

package com.example.administrator.androidthreadtest;
    
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{ 
    
        private TextView text;
    
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            text = (TextView)findViewById(R.id.text);
            Button changeText = (Button)findViewById(R.id.change_text);
            changeText.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v){ 
            switch (v.getId()){ 
                case R.id.change_text:
                    new Thread(new Runnable() { 
                        @Override
                        public void run() { 
                            text.setText("Nice to meet you");
                        }
                    }).start();
                    break;
                default:
                    break;
            }
        }
    }

可以看到，我们在按钮的点击事件里面开启了一个子线程，然后在子线程中调 用TextView的setText()方法将显示的字符串改成Nice to meet you。代码的逻辑非常简单，只不过我们是在子线程中更新UI的。现在运行一下程序，并点击按钮，你会发现程序果然崩溃了，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]  
然后观察logcat中的错误日志，可以看出是由于在子线程中更新UI所导致的，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]  
由此证实了 Android确实是不允许在子线程中进行UI操作的。但是有些时候，我们必须在子线程里去执行一些耗时任务，然后根据任务的执行结果来更新相应的UI控件，这该如何是好呢？  
对于这种情况，Android提供了一套异步消息处理机制，完美地解决了在子线程中进行UI操作的问题。本小节中我们先来学习一下异步消息处理的使用方法，下一小节中再去分析它的原理。  
修改MainActivity中的代码，如下所示：

package com.example.administrator.androidthreadtest;
    
    import android.os.Handler;
    import android.os.Message;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{ 
    
        public static final int UPDATE_TEXT = 1;
    
        private TextView text;
    
        public Handler handler = new Handler(){ 
    
            public void handleMessage(Message msg){ 
                switch (msg.what){ 
                    case UPDATE_TEXT:
                        text.setText("Nice to meet you");
                        break;
                    default:
                        break;
                }
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            text = (TextView)findViewById(R.id.text);
            Button changeText = (Button)findViewById(R.id.change_text);
            changeText.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v){ 
            switch (v.getId()){ 
                case R.id.change_text:
                    new Thread(new Runnable() { 
                        @Override
                        public void run() { 
                            Message message = new Message();
                            message.what = UPDATE_TEXT;
                            handler.sendMessage(message);
                        }
                    }).start();
                    break;
                default:
                    break;
            }
        }
    }

这里我们先是定义了一个整型常量UPDATE\_TEXT，用于表示更新TextView这个动作。然后新增一个Handler对象，并重写父类的handleMessage()方法，在这里对具体的Message进行处理。如果发现Message的what字段的值等于UPDATE\_TEXT，就将TextView显示的内容改成 Nice to meet you。  
下面再来看一下按钮的点击事件中的代码。可以看到，这次我们并没有在子线程里直接进行UI操作，而是创建了一个Message(android.os .Message)对象，并将它的what 字段的值指定为UPDATE\_TEXT，然后调用Handler的sendMessage()方法将这条Message发送出去。很快，Handler就会收到这条Message,并在handleMessage()方法中对它进行处理。注意此时handleMessage()方法中的代码就是在主线程当中运行的了，所以我们可以放心地在这里进行UI操作。接下来对Message携带的what字段的值进行判断，如果等于UPDATE\_TEXT,，就将TextView显示的内容改成Nice to meet you。  
现在重新运行程序，可以看到屏幕的正中央显示着Hello worldo然后点击一下按钮，显示的内容就被替换成Nice to meet you，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]  
这样你就已经掌握了 Android异步消息处理的基本用法，使用这种机制就可以出色地解决掉在子线程中更新UI的问题。不过恐怕你对它的工作原理还不是很清楚，下面我们就来分析一下Android异步消息处理机制到底是如何工作的。

## 2.3 解析异步消息处理机制 ##

Android中的异步消息处理主要由4个部分组：Message、Handler、MessageQueue和Looper。其中Message和Handler在上一小节中我们已经接触过了，而MessageQueue和Looper对于你来说还是全新的概念，下面我就对这4个部分进行一下简要的介绍。

1.  Message  
    Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间交换数据。上一小节中我们使用到了 Message的what字段，除此之外还可以使用argl和arg2字段来携带一些整型数据，使用obj字段携带一个Object对象。
2.  Handler  
    Handler顾名思义也就是处理者的意思，它主要是用于发送和处理消息的。发送消息一般是使用Handler的sendMessage()方法，而发岀的消息经过一系列地辗转处理后，最终会传递到 Handler的 handleMessage()方法中。
3.  MessageQueue  
    MessageQueue是消息队列的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程中只会有一个MessageQueue对象。
4.  Looper  
    Looper是每个线程中的MessageQueue的管家，调用Looper的loop()方法后，就会进入到一个无限循环当中，然后每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handleMessage()方法中。每个线程中也只会有一个Looper对象。

了解了 Message. Handler. MessageQueue以及Looper的基本概念后，我们再来把异步消息处理的整个流程梳理一遍。首先需要在主线程当中创建一个Handler对象，并重写 handleMessage()方法。然后当子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler将这条消息发送出去。之后这条消息会被添加到MessageQueue的队列中等待被处理, 而Looper则会一直尝试从MessageQueue中取岀待处理消息，最后分发回Handler的 handleMessage()方法中。由于Handler是在主线程中创建的，所以此时handleMessage()方法中的代码也会在主线程中运行，于是我们在这里就可以安心地进行UI操作了。整个异步消息处理机制的流程示意图如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 3]  
一条Message经过这样一个流程的辗转调用后，也就从子线程进入到了主线程，从不能更新UI变成了可以更新UI，整个异步消息处理的核心思想也就是如此。  
而我们在之前使用到的runOnUiThread()方法其实就是一个异步消息处理机制的接口封装，它虽然表面上看起来用法更为简单，但其实背后的实现原理和这里的描述是一样的。

## 2.4 使用AsyncTask ##

不过为了更加方便我们在子线程中对UI进行操作，Android还提供了另外一些好用的工具，比如AsyncTask。借助AsyncTask，即使你对异步消息处理机制完全不了解，也可以十分简单地 从子线程切换到主线程。当然，AsyncTask背后的实现原理也是基于异步消息处理机制的，只是 Android帮我们做了很好的封装而已。  
首先来看一下AsyncTask的基本用法，由于AsyncTask是一个抽象类，所以如果我们想使用它，就必须要创建一个子类去继承它。在继承时我们可以为AsyncTask类指定3个泛型参数，这 3个参数的用途如下。

1.  Params。在执行AsyncTask时需要传入的参数，可用于在后台任务中使用。
2.  Progress。后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。
3.  Result。当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返 回值类型。

因此，一个最简单的自定义AsyncTask就可以写成如下方式：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> { 
    }

这里我们把AsyncTask的第一个泛型参数指定为Void，表示在执行AsyncTask的时候不需要传入参数给后台任务。第二个泛型参数指定为Integer，表示使用整型数据来作为进度显示单位。第三个泛型参数指定为Boolean，则表示使用布尔型数据来反馈执行结果。  
当然，目前我们自定义的DownloadTask还是一个空任务，并不能进行任何实际的操作，我 们还需要去重写AsyncTask中的几个方法才能完成对任务的定制。经常需要去重写的方法有以下 4个。

1.  onPreExecute()  
    这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等。
2.  doInBackground(Params…)  
    这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。任务一旦完成就可以通过return语句来将任务的执行结果返回，如果AsyncTask的第三个泛型参数指定的是Void，就可以不返回任务执行结果。注意，在这个方法中是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress…)方法来完成。
3.  onProgressUpdate(Progress…)  
    当在后台任务中调用了 publishProgress(Progress…)方法后，onProgressUpdate (Progress…)方法就会很快被调用，该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。
4.  onPostExecute(Result)  
    当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进度条对话框等。  
    因此，一个比较完整的自定义AsyncTask就可以写成如下方式：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> { 
    @Override
    protected void onPreExecute() ( progressDialog. show(); // 显示进度对话框
    }
    @Override protected Boolean doInBackground(Void... params) {  try { 
    while (true) { 
    int downloadPercent = doDownload(); // 这是一个虚构的方法 publishProgress(downloadPercent);
    if (downloadPercent >= 100) {  break;
    }
    }
    } catch (Exception e) { 
    return false;
    }
    return true;
    }
    @Override protected void onProgressllpdate(Integer.. . values) { 
    //在这里更新下载进度 progressDialog.setMessage("Downloaded " + values[0] + ;
    }
    @Override protected void onPostExecute(Boolean result) {  progressDialog.dismiss(); // 关闭进度对话框 //在这里提示下载结果 if (result) { 
    Toast.makeText (context, "Download succeeded1*, Toast. LENGTH SHORT). show(); } else (
    Toast.makeText(context, " Download failed", Toast.LENGTHSHORT).show(); }

在这个DownloadTask中，我们在doInBackground()方法里去执行具体的下载任务。这个方法里的代码都是在子线程中运行的，因而不会影响到主线程的运行。注意这里虚构了一个 doDownload()方法，这个方法用于计算当前的下载进度并返回，我们假设这个方法已经存在了。在得到了当前的下载进度后，下面就该考虑如何把它显示到界面上了，由于doInBackground() 方法是在子线程中运行的,在这里肯定不能进行UI操作，所以我们可以调用publishProgress()方法并将当前的下载进度传进来，这样onProgressUpdate()方法就会很快被调用，在这里就可以进行UI操作了。  
当下载完成后，doInBackground()方法会返回一个布尔型变量，这样onPostExecute()方法就会很快被调用，这个方法也是在主线程中运行的。然后在这里我们会根据下载的结果来弹出相应的Toast提示，从而完成整个DownloadTask任务。  
简单来说，使用AsyncTask的诀窍就是，在doInBackground()方法中执行具体的耗时任务, 在onProgressUpdate()方法中进行UI操作，在onPostExecute()方法中执行一些任务的收尾 工作。  
如果想要启动这个任务，只需编写以下代码即可：

new DownloadTask().execute();

以上就是AsyncTask的基本用法，怎么样，是不是感觉简单方便了许多？我们并不需要去考虑什么异步消息处理机制，也不需要专门使用一个Handler来发送和接收消息，只需要调用一下 publishProgress()方法，就可以轻松地从子线程切换到UI线程了。  
在本篇博客的最佳实践环节，我们会对下载这个功能进行完整的实现。

# 3.服务的基本用法 #

了解了 Android多线程编程的技术之后，下面就让我们进入到本章的正题，开始对服务的相关内容进行学习。作为Android四大组件之一，服务也少不了有很多非常重要的知识点，那我们自然要从最基本的用法开始学习了。

## 3.1 定义一个服务 ##

首先看一下如何在项目中定义一个服务。新建一个项目，然后右击《项目名》—>New—>Service—>Service,会弹出如图所示的窗口：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 4]  
可以看到，这里我们将服务命名为MyService，Exported属性表示是否允许除了当前程序之外的其他程序访问这个服务，Enabled属性表示是否启用这个服务。将两个属性都勾中，点击 Finish完成创建。  
现在观察MyService中的代码，如下所示：

public class MyService extends Service { 
    
        public MyService() { 
        }
    
        @Override
        public IBinder onBind(Intent intent) { 
            // TODO: Return the communication channel to the service.
        }
    }

可以看到，MyService是继承自Service类的，说明这是一个服务。目前MyService中可以算是空空如也，但有一个onBind()方法特别醒目。这个方法是Service中唯一的一个抽象方法, 所以必须要在子类里实现。我们会在后面的小节中使用到onBind()方法，目前可以暂时将它忽略掉。  
既然是定义一个服务，自然应该在服务中去处理一些事情了，那处理事情的逻辑应该写在哪里呢？这时就可以重写Service中的另外一些方法了，如下所示：

public class MyService extends Service { 
    
        public MyService() { 
        }
    
        @Override
        public IBinder onBind(Intent intent) { 
            // TODO: Return the communication channel to the service.
        }
        
        @Override
        public void onCreate(){ 
            super.onCreate();
    
        }
    
        @Override
        public int onStartCommand(Intent intent,int flags,int startId){ 
            return super.onStartommand(intent,flags,startId));
        }
    
        @Override
        public void onDestroy(){ 
            super.onDestroy();
        }
    }
    }

可以看到，这里我们又重写了 onCreate()、onStartCommand()和onDestroy()这3个方法，它们是每个服务中最常用到的3个方法了。其中onCreate()方法会在服务创建的时候调用, onStartCommand()方法会在每次服务启动的时候调用，onDestroy()方法会在服务销毁的时候 调用。  
通常情况下，如果我们希望服务一旦启动就立刻去执行某个动作，就可以将逻辑写在onStartCommand()方法里。而当服务销毁时，我们又应该在onDestroy()方法中去回收那些不再使用的资源。  
另外需要注意，每一个服务都需要在AndroidManifest.xml文件中进行注册才能生效，不知道你有没有发现，这是Android四大组件共有的特点。不过相信你已经猜到了，智能的Android Studio 早已自动帮我们将这一步完成了。打开AndroidManifest.xml文件瞧一瞧，代码如下所示：

这样的话，就已经将一个服务完全定义好了。

## 3.2 启动和停止服务 ##

定义好了服务之后，接下来就应该考虑如何去启动以及停止这个服务。启动和停止的方法当然你也不会陌生，主要是借助Intent来实现的，下面就让我们在项目中尝试去启动以及停止MyService这个服务。  
首先修改activity\_main.xml中的代码，如下所示：

这里我们在布局文件中加入了两个按钮，分别是用于启动服务和停止服务的。  
然后修改MainActivity中的代码，如下所示：

public class MainActivity extends AppCompatActivity implements View.OnClickListener{ 
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Button startService = (Button)findViewById(R.id.start_service);
            Button stopService = (Button)findViewById(R.id.stop_service);
            startService.setOnClickListener(this);
            stopService.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v){ 
            switch (v.getId()){ 
                case R.id.start_service:
                    Intent startIntent = new Intent(this,MyService.class);
                    startService(startIntent);
                    break;
                case R.id.stop_service:
                    Intent stopIntent = new Intent(this,MyService.class);
                    stopService(stopIntent);
                    break;
                default:
                    break;
            }
        }
    }

可以看到，这里在onCreate()方法中分别获取到了 Start Service按钮和Stop Service按钮的实例，并给它们注册了点击事件。然后在Start Service按钮的点击事件里，我们构建出了一个Intent对象，并调用startService()方法来启动MyService这个服务。在Stop Serivce按钮的点击事件里，我们同样构建出了一个Intent对象,并调用stopService()方法来停止MyService 这个服务。startService()和stopService()方法都是定义在Context类中的，所以我们在活动里可以直接调用这两个方法。注意，这里完全是由活动来决定服务何时停止的，如果没有点击Stop Service按钮，服务就会一直处于运行状态。那服务有没有什么办法让自已停止下来呢？ 当然可以，只需要在MyService的任何一个位置调用stopSelf()方法就能让这个服务停止下来了。  
那么接下来又有一个问题需要思考了，我们如何才能证实服务已经成功启动或者停止了呢？ 最简单的方法就是在MyService的几个方法中加入打印日志，如下所示：

public class MyService extends Service { 
    
        public MyService() { 
        }
    
        @Override
        public IBinder onBind(Intent intent) { 
            // TODO: Return the communication channel to the service.
        }
        
        @Override
        public void onCreate(){ 
            super.onCreate();
            Log.d("MyService","onCreate executed");
    
        }
    
        @Override
        public int onStartCommand(Intent intent,int flags,int startId){ 
            return super.onStartommand(intent,flags,startId));
            Log.d("MyService","onStartCommand executed");
        }
    
        @Override
        public void onDestroy(){ 
            super.onDestroy();
            Log.d("MyService","onDestroy executed");
        }
    }
    }

现在可以运行一下程序来进行测试了，程序的主界面如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 5]  
点击一下Start Service按钮，观察logcat中的打印日志，如图所示：  
![在这里插入图片描述][20191112170727368.png]  
然后再点击一下Stop Service按钮，观察logcat中的打印日志，如图所示：  
![在这里插入图片描述][20191112170733961.png]  
由此证明，MyService确实已经成功停止下来了。  
话说回来，虽然我们已经学会了启动服务以及停止服务的方法，不知道你心里现在有没有一 个疑惑，那就是onCreate()方法和onStartCommand()方法到底有什么区别呢？因为刚刚点击 Start Service按钮后两个方法都执行了。  
其实onCreate()方法是在服务第一次创建的时候调用的，而onStartCommand()方法则在每次启动服务的时候都会调用，由于刚才我们是第一次点击Start Service按钮，服务此时还未创 建过，所以两个方法都会执行，之后如果你再连续多点击几次Start Service按钮，你就会发现只有onStartCommand()方法可以得到执行了。

## 3.3 活动和服务进行通信 ##

上一小节中我们学习了启动和停止服务的方法，不知道你有没有发现，虽然服务是在活动里启动的，但在启动了服务之后，活动与服务基本就没有什么关系了。确实如此，我们在活动里调用了startService()方法来启动 MyService 这个服务，然后 MyService的onCreate()和 onStartCommand()方法就会得到执行。之后服务会一直处于运行状态，但具体运行的是什么逻 辑，活动就控制不了了。这就类似于活动通知了服务一下：“你可以启动了！”然后服务就去忙自 己的事情了，但活动并不知道服务到底去做了什么事情，以及完成得如何。  
那么有没有什么办法能让活动和服务的关系更紧密一些呢？例如在活动中指挥服务去干什 么，服务就去干什么。当然可以，这就需要借助我们刚刚忽略的onBind()方法了。  
比如说，目前我们希望在MyService里提供一个下载功能，然后在活动中可以决定何时开始下载，以及随时查看下载进度。实现这个功能的思路是创建一个专门的Binder对象来对下载功能进行管理，修改MyService中的代码，如下所示：

public class MyService extends Service { 
    
        private DownloadBinder mBinder = new DownloadBinder();
    
        class DownloadBinder extends Binder{ 
    
            public void startDownload(){ 
                Log.d("MyService","startDownload executed");
            }
    
            public int getProgress(){ 
                Log.d("MyService","getProgress executed");
                return 0;
            }
        }
    
        public MyService() { 
        }
    
        @Override
        public IBinder onBind(Intent intent) { 
            // TODO: Return the communication channel to the service.
            return mBinder;
        }
        
         @Override
        public void onCreate(){ 
            super.onCreate();
            Log.d("MyService","onCreate executed");
    
        }
    
        @Override
        public int onStartCommand(Intent intent,int flags,int startId){ 
            return super.onStartommand(intent,flags,startId));
            Log.d("MyService","onStartCommand executed");
        }
    
        @Override
        public void onDestroy(){ 
            super.onDestroy();
            Log.d("MyService","onDestroy executed");
        }
    }

可以看到，这里我们新建了一个DownloadBinder类，并让它继承自Binder，然后在它的内部提供了开始下载以及查看下载进度的方法。当然这只是两个模拟方法，并没有实现真正的功能，我们在这两个方法中分别打印了一行日志。  
接着，在MyService中创建了DownloadBinder的实例，然后在onBind()方法里返回了这个实例，这样MyService中的工作就全部完成了。  
下面就要看一看，在活动中如何去调用服务里的这些方法了。首先需要在布局文件里新增两个按钮，修改activity\_main.xml中的代码，如下所示：

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <Button
            android:id="@+id/start_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="启动服务"/>
    
        <Button
            android:id="@+id/stop_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="停止服务"/>
    
        <Button
            android:id="@+id/bind_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="绑定服务" />
    
        <Button
            android:id="@+id/unbind_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="解绑服务" />
    </LinearLayout>

这两个按钮分别是用于绑定服务和取消绑定服务的，那到底谁需要去和服务绑定呢？当然就是活动了。当一个活动和服务绑定了之后，就可以调用该服务里的Binder提供的方法了。修改MainActivity中的代码，如下所示：

package com.example.administrator.servicetest;
    
    import android.content.ComponentName;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{ 
    
        private MyService.DownloadBinder downloadBinder;
    
        private ServiceConnection connection = new ServiceConnection() { 
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) { 
                downloadBinder = (MyService.DownloadBinder)service;
                downloadBinder.startDownload();
                downloadBinder.getProgress();
            }
    
            @Override
            public void onServiceDisconnected(ComponentName name) { 
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Button startService = (Button)findViewById(R.id.start_service);
            Button stopService = (Button)findViewById(R.id.stop_service);
            startService.setOnClickListener(this);
            stopService.setOnClickListener(this);
            Button bindService = (Button)findViewById(R.id.bind_service);
            Button unbindService = (Button)findViewById(R.id.unbind_service);
            bindService.setOnClickListener(this);
            unbindService.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v){ 
            switch (v.getId()){ 
                case R.id.start_service:
                    Intent startIntent = new Intent(this,MyService.class);
                    startService(startIntent);
                    break;
                case R.id.stop_service:
                    Intent stopIntent = new Intent(this,MyService.class);
                    stopService(stopIntent);
                    break;
                case R.id.bind_service:
                    Intent bindIntent = new Intent(this,MyService.class);
                    bindService(bindIntent,connection,BIND_AUTO_CREATE);
                    break;
                case R.id.unbind_service:
                    unbindService(connection);
                    break;
                default:
                    break;
            }
        }
    }

可以看到，这里我们首先创建了一个Serviceconnection的匿名类，在里面重写了onServiceConnected ()方法和onServiceDisconnected()方法，这两个方法分别会在活动与服务成功绑定以及解除绑定的时候调用。在onServiceConnected()方法中，我们又通过向下转型得到了 DownloadBinder的实例，有了这个实例，活动和服务之间的关系就变得非常紧密了。现在我们可以在活动中根据具体的场景来调用DownloadBinder中的任何public()方法，即实现了指挥服务干什么服务就去干什么的功能。这里仍然只是做了个简单的测试，在onServiceConnected()方法中调用了DownloadBinder 的 startDownload()和 getProgress()方法。  
当然，现在活动和服务其实还没进行绑定呢，这个功能是在Bind Service按钮的点击事件里完成的。可以看到，这里我们仍然是构建出了一个Intent对象，然后调用bindService()法 将MainActivity和MyService进行绑定。bindService()方法接收3个参数，第一个参数就是刚刚构建岀的Intent对象，第二个参数是前面创建出的ServiceConnection的实例，第三个参数则是一个标志位，这里传入BIND\_AUTO\_CREATE表示在活动和服务进行绑定后自动创建服务。这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。  
然后如果我们想解除活动和服务之间的绑定该怎么办呢？调用一下unbindService()方法 就可以了，这也是Unbind Service按钮的点击事件里实现的功能。  
现在让我们重新运行一下程序吧，界面如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 6]  
点击—下Bind Service按钮，然后观察logcat中的打印日志，如图所示：  
![在这里插入图片描述][20191112171527343.png]  
可以看到，首先是MyService的onCreate()方法得到了执行，然后startDownload()和getProgress()方法都得到了执行，说明我们确实已经在活动里成功调用了服务里提供的方法了。  
另外需要注意，任何一个服务在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity绑定，还可以和任何一个其他的活动进行绑定，而且在绑定完成后它们都可以获取到相同的DownloadBinder实例。

# 4.服务的生命周期 #

之前我们学习过了活动以及碎片的生命周期。类似地，服务也有自己的生命周期，前面我们使用到的 onCreate()、onStartCommand()、onBind()和 onDestroy()等方法都是在服务的生命周期内可能回调的方法。  
一旦在项目的任何位置调用了Context的startService()方法，相应的服务就会启动起来， 并回调onStartCommand()方法。如果这个服务之前还没有创建过，onCreate()方法会先于onStartCommand()方法执行。服务启动了之后会一直保持运行状态，直到stopService()或 stopSelf()方法被调用。注意，虽然每调用一次startService()方法，onStartCommand()就会执行一次，但实际上每个服务都只会存在一个实例。所以不管你调用了多少次startService()方法，只需调用一次stopService()或stopSelf ()方法，服务就会停止下来了。  
另外，还可以调用Context的bindService()来获取一个服务的持久连接，这时就会回调服务中的onBind()方法。类似地，如果这个服务之前还没有创建过，onCreate()方法会先于 onBind()方法执行。之后，调用方可以获取到onBind()方法里返回的IBinder对象的实例， 这样就能自由地和服务进行通信了。只要调用方和服务之间的连接没有断开，服务就会一直保持运行状态。  
当调用了 startService()方法后，又去调用stopService()方法，这时服务中的 onDestroy()方法就会执行，表示服务已经销毁了。类似地，当调用了 bindService()方法后， 又去调用unbindService()方法，onDestroy()方法也会执行，这两种情况都很好理解。但是需要注意，我们是完全有可能对一个服务既调用了 startService()方法，又调用了 bindService()方法的，这种情况下该如何才能让服务销毁掉呢？根据Android系统的机制，一 个服务只要被启动或者被绑定了之后，就会一直处于运行状态，必须要让以上两种条件同时不满足，服务才能被销毁。所以，这种情况下要同时调用stopService()和unbindService()方法， onDestroy()方法才会执行。  
这样你就已经把服务的生命周期完整地走了一遍。

# 5.服务的更多技巧 #

## 5.1 使用前台服务 ##

服务几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。但是服务的系统优先级还是比较低的，当系统出现内存不足的情况时，就有可能会回收掉正在后台运行的服务。如果你希望服务可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台服务。前台服务和普通服务最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止服务被回收掉才使用前台服务的，有些项目由于特殊的需求会要求必须使用前台服务，比如说彩云天气这款天气预报应用，它的服务在后台更新天气数据的同时，还会在系统状态栏一直显示当前的天气信息。  
那么我们就来看一下如何才能创建一个前台服务吧，其实并不复杂，修改MyService中的代码，如下所示：

package com.example.administrator.servicetest;
    
    import android.app.Notification;
    import android.app.PendingIntent;
    import android.app.Service;
    import android.content.Intent;
    import android.graphics.BitmapFactory;
    import android.os.Binder;
    import android.os.IBinder;
    import android.support.v4.app.NotificationCompat;
    import android.util.Log;
    
    public class MyService extends Service { 
    
        private DownloadBinder mBinder = new DownloadBinder();
    
        class DownloadBinder extends Binder{ 
    
            public void startDownload(){ 
                Log.d("MyService","startDownload executed");
            }
    
            public int getProgress(){ 
                Log.d("MyService","getProgress executed");
                return 0;
            }
        }
    
        public MyService() { 
        }
    
        @Override
        public IBinder onBind(Intent intent) { 
            // TODO: Return the communication channel to the service.
            return mBinder;
        }
    
        @Override
        public void onCreate(){ 
            super.onCreate();
            Log.d("MyService","onCreate executed");
            Intent intent = new Intent(this,MainActivity.class);
            PendingIntent pi = PendingIntent.getActivity(this,0,intent,0);
            Notification notification = new NotificationCompat.Builder(this)
                    .setContentTitle("这是一个标题")
                    .setContentText("这是内容")
                    .setWhen(System.currentTimeMillis())
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher))
                    .setContentIntent(pi)
                    .build();
            startForeground(1,notification);
        }
    
        @Override
        public int onStartCommand(Intent intent,int flags,int startId){ 
            Log.d("MyService","onStartCommand executed");
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    stopSelf();
                }
            }).start();
            return super.onStartCommand(intent,flags,startId);
        }
    
        @Override
        public void onDestroy(){ 
            super.onDestroy();
            Log.d("MyService","onDestroy executed");
        }
    }

可以看到，这里只是修改了 onCreateO方法中的代码，相信这部分代码你会非常眼熟。没错！这就是我们在之前学习的创建通知的方法。只不过这次在构建出Notification对象后并没有使用NotificationManager来将通知显示出来，而是调用了 startForeground()方法。这 个方法接收两个参数，第一个参数是通知的id，类似于notify()方法的第一个参数，第二个参数则是构建出的Notification对象。调用startForeground()方法后就会让MyService变成一个前台服务，并在系统状态栏显示出来。  
现在重新运行一下程序，并点击Start Service或Bind Service按钮，MyService就会以前台服务的模式启动了，并且在系统状态栏会显示一个通知图标，下拉状态栏后可以看到该通知的详细内容，如图所示：  
![在这里插入图片描述][20191112171622952.png]  
前台服务的用法就这么简单，只要你在之前将通知的用法掌握好了，学习本节的知识一定会特别轻松。

## 5.2 使用IntentService ##

话说回来，在本章一开始的时候我们就已经知道，服务中的代码都是默认运行在主线程当中的，如果直接在服务里去处理一些耗时的逻辑，就很容易出现ANR ( Application Not Responding ) 的情况。  
所以这个时候就需要用到Android多线程编程的技术了，我们应该在服务的每个具体的方法里开启一个子线程，然后在这里去处理那些耗时的逻辑。因此，一个比较标准的服务就可以写成如下形式：

@Override
    public int onStartCommand(Intent intent,int flags,int startId){ 
        Log.d("MyService","onStartCommand executed");
        new Thread(new Runnable() { 
            @Override
            public void run() { 
                //相应的逻辑
            }
        }).start();
        return super.onStartCommand(intent,flags,startId);
    }

但是，这种服务一旦启动之后，就会一直处于运行状态，必须调用stopService()或者 stopSelf()方法才能让服务停止下来。所以，如果想要实现让一个服务在执行完毕后自动停止的功能，就可以这样写：

@Override
    public int onStartCommand(Intent intent,int flags,int startId){ 
        Log.d("MyService","onStartCommand executed");
        new Thread(new Runnable() { 
            @Override
            public void run() { 
                stopSelf();
            }
        }).start();
        return super.onStartCommand(intent,flags,startId);
    }

虽说这种写法并不复杂，但是总会有一些程序员忘记开启线程，或者忘记调用stopSelf () 方法。为了可以简单地创建一个异步的、会自动停止的服务，Android专门提供了一个Intentservice类，这个类就很好地解决了前面所提到的两种尴尬，下面我们就来看一下它的用法。  
新建一个MylntentService类继承自Intentservice，代码如下所示：

package com.example.administrator.servicetest;
    
    import android.app.IntentService;
    import android.content.Intent;
    import android.util.Log;
    
    /** * Created by Administrator on 2018-10-14. */
    
    public class MyIntentService extends IntentService{ 
    
        public MyIntentService(){ 
            super("MyIntentService");
        }
    
        @Override
        protected void onHandleIntent(Intent intent){ 
            Log.d("MyIntentService","线程的id是" + Thread.currentThread().getId());
        }
    
        @Override
        public void onDestroy(){ 
            super.onDestroy();
            Log.d("MyIntentService","onDestroy executed");
        }
    }

这里首先要提供一个无参的构造函数，并且必须在其内部调用父类的有参构造函数。然后要在子类中去实现onHandlelntent()这个抽象方法，在这个方法中可以去处理一些具体的逻辑， 而且不用担心ANR的问题，因为这个方法已经是在子线程中运行的了。这里为了证实一下，我们在onHandleIntent()方法中打印了当前线程的id。另外根据Intentservice的特性，这个服务在运行结束后应该是会自动停止的，所以我们又重写了onDestroy。方法，在这里也打印 了一行日志，以证实服务是不是停止掉了。  
接下来修改activity\_main.xml中的代码，加入一个用于启动MylntentService这个服务的按钮，如下所示：

然后修改MainActivity中的代码，如下所示：

package com.example.administrator.servicetest;
    
    import android.content.ComponentName;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{ 
    
        private MyService.DownloadBinder downloadBinder;
    
        private ServiceConnection connection = new ServiceConnection() { 
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) { 
                downloadBinder = (MyService.DownloadBinder)service;
                downloadBinder.startDownload();
                downloadBinder.getProgress();
            }
    
            @Override
            public void onServiceDisconnected(ComponentName name) { 
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Button startService = (Button)findViewById(R.id.start_service);
            Button stopService = (Button)findViewById(R.id.stop_service);
            startService.setOnClickListener(this);
            stopService.setOnClickListener(this);
            Button bindService = (Button)findViewById(R.id.bind_service);
            Button unbindService = (Button)findViewById(R.id.unbind_service);
            bindService.setOnClickListener(this);
            unbindService.setOnClickListener(this);
            Button startIntentService = (Button)findViewById(R.id.start_intent_service);
            startIntentService.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v){ 
            switch (v.getId()){ 
                case R.id.start_service:
                    Intent startIntent = new Intent(this,MyService.class);
                    startService(startIntent);
                    break;
                case R.id.stop_service:
                    Intent stopIntent = new Intent(this,MyService.class);
                    stopService(stopIntent);
                    break;
                case R.id.bind_service:
                    Intent bindIntent = new Intent(this,MyService.class);
                    bindService(bindIntent,connection,BIND_AUTO_CREATE);
                    break;
                case R.id.unbind_service:
                    unbindService(connection);
                    break;
                case R.id.start_intent_service:
                    Log.d("MainActivity","线程的id是" + Thread.currentThread().getId());
                    Intent intentService = new Intent(this,MyIntentService.class);
                    startService(intentService);
                    break;
                default:
                    break;
            }
        }
    }

可以看到，我们在Start IntentService按钮的点击事件里面去启动MylntentService这个服务， 并在这里打印了一下主线程的id，稍后用于和IntentService进行比对。你会发现，其实IntentService的用法和普通的服务没什么两样。  
最后不要忘记，服务都是需要在AndroidManifest.xml里注册的，如下所示：

当然你也可以使用Android Studio提供的快捷方式来创建IntentService，不过由于这样会自动生成一些我们用不到的代码，因此这里我采用了手动创建的方式。  
现在重新运行一下程序，界面如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 7]  
点击Start IntentService按钮后，观察logcat中的打印日志，如图所示：  
![在这里插入图片描述][20191112171652276.png]  
可以看到，不仅MylntentService和MainActivity所在的线程id不一样，而且onDestroy()方法也得到了执行，说明MylntentService在运行完毕后确实自动停止了。集开启线程和自动停止于一身，IntentService还是博得了不少程序员的喜爱。

# 6.服务的最佳实践 #

本篇博客中你已经掌握了很多关于服务的使用技巧，但是当在真正的项目里需要用到服务的时候，可能还会有一些棘手的问题让你不知所措。因此，下面我们就来综合运用一下，尝试实现一个在服务中经常会使用到的功能一一下载。  
本节中我们将要编写一个完整版的下载示例，其中会涉及第之前的部分内容，算是目前为止综合程度最高的一个例子了。准备好了吗？创建一个 项目,然后开始本节的学习之旅吧。  
首先我们需要将项目中会使用到的依赖库添加好，编辑app/build.gradle文件，在dependencies 闭包中添加如下内容：

compile 'com.squareup.okhttp3:okhttp:3.4.1'

这里只需添加一个OkHttp的依赖就行了，待会儿在编写网络相关的功能时，我们将使用OkHttp来进行实现。  
接下来需要定义一个回调接口，用于对下载过程中的各种状态进行监听和回调。新建一个 DownloadListener接口，代码如下所示：

package com.example.administrator.servicebestpractice;
    
    /** * Created by Administrator on 2018-10-14. */
    
    public interface DownloadListener { 
    
        void onProgress(int progress);
    
        void onSuccess();
    
        void onFailed();
    
        void onPaused();
    
        void onCanceled();
    
    }

可以看到，这里我们一共定义了 5个回调方法，onProgress()方法用于通知当前的下载进度，onSuccess()方法用于通知下载成功事件，onFailed()方法用于通知下载失败事件， onPaused()方法用于通知下载暂时事件，onCanceled()方法用于通知下载取消事件。  
回调接口定义好了之后，下面我们就可以开始编写下载功能了。这里我准备使用本篇博客中刚学的AsyncTask来进行实现，新建一个DownloadTask继承自AsyncTask，代码如下所示：

package com.example.administrator.servicebestpractice;
    
    import android.os.AsyncTask;
    import android.os.Environment;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.RandomAccessFile;
    
    import okhttp3.OkHttpClient;
    import okhttp3.Request;
    import okhttp3.Response;
    
    /** * Created by Administrator on 2018-10-14. */
    
    public class DownloadTask extends AsyncTask<String, Integer, Integer> { 
    
        public static final int TYPE_SUCCESS = 0;
        public static final int TYPE_FAILED = 1;
        public static final int TYPE_PAUSED = 2;
        public static final int TYPE_CANCELED = 3;
    
    
        private DownloadListener listener;
    
        private boolean isCanceled = false;
    
        private boolean isPaused = false;
    
        private int lastProgress;
    
        public DownloadTask(DownloadListener listener) { 
            this.listener = listener;
        }
    
        @Override
        protected Integer doInBackground(String... params) { 
            InputStream is = null;
            RandomAccessFile savedFile = null;
            File file = null;
            try { 
                long downloadedLength = 0; // 记录已下载的文件长度
                String downloadUrl = params[0];
                String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
                String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getPath();
                file = new File(directory + fileName);
                if (file.exists()) { 
                    downloadedLength = file.length();
                }
                long contentLength = getContentLength(downloadUrl);
                if (contentLength == 0) { 
                    return TYPE_FAILED;
                } else if (contentLength == downloadedLength) { 
                    // 已下载字节和文件总字节相等，说明已经下载完成了
                    return TYPE_SUCCESS;
                }
                OkHttpClient client = new OkHttpClient();
                Request request = new Request.Builder()
                        // 断点下载，指定从哪个字节开始下载
                        .addHeader("RANGE", "bytes=" + downloadedLength + "-")
                        .url(downloadUrl)
                        .build();
                Response response = client.newCall(request).execute();
                if (response != null) { 
                    is = response.body().byteStream();
                    savedFile = new RandomAccessFile(file, "rw");
                    savedFile.seek(downloadedLength); // 跳过已下载的字节
                    byte[] b = new byte[1024];
                    int total = 0;
                    int len;
                    while ((len = is.read(b)) != -1) { 
                        if (isCanceled) { 
                            return TYPE_CANCELED;
                        } else if(isPaused) { 
                            return TYPE_PAUSED;
                        } else { 
                            total += len;
                            savedFile.write(b, 0, len);
                            // 计算已下载的百分比
                            int progress = (int) ((total + downloadedLength) * 100 / contentLength);
                            publishProgress(progress);
                        }
                    }
                    response.body().close();
                    return TYPE_SUCCESS;
                }
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                try { 
                    if (is != null) { 
                        is.close();
                    }
                    if (savedFile != null) { 
                        savedFile.close();
                    }
                    if (isCanceled && file != null) { 
                        file.delete();
                    }
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
            return TYPE_FAILED;
        }
    
        @Override
        protected void onProgressUpdate(Integer... values) { 
            int progress = values[0];
            if (progress > lastProgress) { 
                listener.onProgress(progress);
                lastProgress = progress;
            }
        }
    
        @Override
        protected void onPostExecute(Integer status) { 
            switch (status) { 
                case TYPE_SUCCESS:
                    listener.onSuccess();
                    break;
                case TYPE_FAILED:
                    listener.onFailed();
                    break;
                case TYPE_PAUSED:
                    listener.onPaused();
                    break;
                case TYPE_CANCELED:
                    listener.onCanceled();
                default:
                    break;
            }
        }
    
        public void pauseDownload() { 
            isPaused = true;
        }
    
    
        public void cancelDownload() { 
            isCanceled = true;
        }
    
        private long getContentLength(String downloadUrl) throws IOException { 
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder()
                    .url(downloadUrl)
                    .build();
            Response response = client.newCall(request).execute();
            if (response != null && response.isSuccessful()) { 
                long contentLength = response.body().contentLength();
                response.close();
                return contentLength;
            }
            return 0;
        }
    
    }

这段代码就比较长了，我们需要一步步地进行分析。首先看一下AsyncTask中的3个泛型参数：第一个泛型参数指定为String,表示在执行AsyncTask的时候需要传入一个字符串参数给后台任务；第二个泛型参数指定为Integer，表示使用整型数据来作为进度显示单位；第三个泛型参数指定为Integer，则表示使用整型数据来反馈执行结果。  
接下来我们定义了4个整型常量用于表示下载的状态，TYPE\_SUCCESS表示下载成功， TYPE\_FAILED表示下载失败，TYPE\_PAUSED表示暂停下载，TYPE\_CANCELED表示取消下载。然后在DownloadTask的构造函数中要求传入一个刚刚定义的DownloadListener参数，我们待会就会将下载的状态通过这个参数进行回调。  
接着就是要重写 doInBackground()，onProgressUpdate()和 onPostExecute()这 3 个方 法了，我们之前已经学习过这3个方法各自的作用，因此在这里它们各自所负责的任务也是明确的：doInBackground()方法用于在后台执行具体的下载逻辑，onProgressUpdate()方法用于在界面上更新当前的下载进度，onPostExecute()用于通知最终的下载结果。  
那么先来看一下doInBackground()方法，首先我们从参数中获取到了下载的URL地址， 并根据URL地址解析出了下载的文件名，然后指定将文件下载到Environment.DIRECTORY\_ DOWNLOADS目录下，也就是SD卡的Download 目录。我们还要判断一下Download目录中是不是已经存在要下载的文件了，如果已经存在的话则读取已下载的字节数，这样就可以在后面启用断点续传的功能。接下来先是调用了 getContentLength()方法来获取待下载文件的总长度， 如果文件长度等于0则说明文件有问题，直接返回TYPE\_FAILED，如果文件长度等于已下载文件长度，那么就说明文件已经下载完了，直接返回TYPE\_SUCCESS即可。紧接着使用OkHttp来发送一条网络请求，需要注意的是，这里在请求中添加了一个header，用于告诉服务器我们想要从哪个字节开始下载，因为已下载过的部分就不需要再重新下载了。接下来读取服务器响应的数据,，并使用Java的文件流方式，不断从网络上读取数据，不断写入到本地，一直到文件全部下载完成为止。在这个过程中，我们还要判断用户有没有触发暂停或者取消的操作，如果有的话则返回 TYPE\_PAUSED或TYPE\_CANCELED来中断下载，如果没有的话则实时计算当前的下载进度，然后调用publishProgress()方法进行通知。暂停和取消操作都是使用一个布尔型的变量来进行控制的，调用pauseDownload()或cancelDownload()方法即可更改变量的值。  
接下来看一下onProgressUpdate()方法，这个方法就简单得多了，它首先从参数中获取到当前的下载进度，然后和上一次的下载进度进行对比，如果有变化的话则调用DownloadListener 的onProgress()方法来通知下载进度更新。  
最后是onPostExecute()方法，也非常简单，就是根据参数中传入的下载状态来进行回调。 下载成功就调用DownloadListener的onSuccess()方法，下载失败就调用onFailed()方法，暂 停下载就调用onPaused()方法，取消下载就调用onCanceled()方法。  
这样我们就把具体的下载功能完成了，下面为了保证DownloadTask可以一直在后台运行， 我们还需要创建一个下载的服务。右击 《项目名》——>New——>Service——>Service,，新建DownloadService,然后修改其中的代码，如下所示：

package com.example.administrator.servicebestpractice;
    
    import android.app.Notification;
    import android.app.NotificationManager;
    import android.app.PendingIntent;
    import android.app.Service;
    import android.content.Intent;
    import android.graphics.BitmapFactory;
    import android.os.Binder;
    import android.os.Environment;
    import android.os.IBinder;
    import android.support.v4.app.NotificationCompat;
    import android.widget.Toast;
    
    import java.io.File;
    
    public class DownloadService extends Service { 
    
        private DownloadTask downloadTask;
    
        private String downloadUrl;
    
        private DownloadListener listener = new DownloadListener() { 
            @Override
            public void onProgress(int progress) { 
                getNotificationManager().notify(1, getNotification("Downloading...", progress));
            }
    
            @Override
            public void onSuccess() { 
                downloadTask = null;
                // 下载成功时将前台服务通知关闭，并创建一个下载成功的通知
                stopForeground(true);
                getNotificationManager().notify(1, getNotification("Download Success", -1));
                Toast.makeText(DownloadService.this, "Download Success", Toast.LENGTH_SHORT).show();
            }
    
            @Override
            public void onFailed() { 
                downloadTask = null;
                // 下载失败时将前台服务通知关闭，并创建一个下载失败的通知
                stopForeground(true);
                getNotificationManager().notify(1, getNotification("Download Failed", -1));
                Toast.makeText(DownloadService.this, "Download Failed", Toast.LENGTH_SHORT).show();
            }
    
            @Override
            public void onPaused() { 
                downloadTask = null;
                Toast.makeText(DownloadService.this, "Paused", Toast.LENGTH_SHORT).show();
            }
    
            @Override
            public void onCanceled() { 
                downloadTask = null;
                stopForeground(true);
                Toast.makeText(DownloadService.this, "Canceled", Toast.LENGTH_SHORT).show();
            }
    
        };
    
        private DownloadBinder mBinder = new DownloadBinder();
    
        @Override
        public IBinder onBind(Intent intent) { 
            return mBinder;
        }
    
        class DownloadBinder extends Binder { 
    
            public void startDownload(String url) { 
                if (downloadTask == null) { 
                    downloadUrl = url;
                    downloadTask = new DownloadTask(listener);
                    downloadTask.execute(downloadUrl);
                    startForeground(1, getNotification("Downloading...", 0));
                    Toast.makeText(DownloadService.this, "Downloading...", Toast.LENGTH_SHORT).show();
                }
            }
    
            public void pauseDownload() { 
                if (downloadTask != null) { 
                    downloadTask.pauseDownload();
                }
            }
    
            public void cancelDownload() { 
                if (downloadTask != null) { 
                    downloadTask.cancelDownload();
                } else { 
                    if (downloadUrl != null) { 
                        // 取消下载时需将文件删除，并将通知关闭
                        String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
                        String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getPath();
                        File file = new File(directory + fileName);
                        if (file.exists()) { 
                            file.delete();
                        }
                        getNotificationManager().cancel(1);
                        stopForeground(true);
                        Toast.makeText(DownloadService.this, "Canceled", Toast.LENGTH_SHORT).show();
                    }
                }
            }
    
        }
    
        private NotificationManager getNotificationManager() { 
            return (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        }
    
        private Notification getNotification(String title, int progress) { 
            Intent intent = new Intent(this, MainActivity.class);
            PendingIntent pi = PendingIntent.getActivity(this, 0, intent, 0);
            NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
            builder.setSmallIcon(R.mipmap.ic_launcher);
            builder.setLargeIcon(BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher));
            builder.setContentIntent(pi);
            builder.setContentTitle(title);
            if (progress >= 0) { 
                // 当progress大于或等于0时才需显示下载进度
                builder.setContentText(progress + "%");
                builder.setProgress(100, progress, false);
            }
            return builder.build();
        }
    
    }

这段代码同样也比较长，我们还是得耐心慢慢看。首先这里创建了一个DownloadListener的匿名类实例，并在匿名类中实现了 onProgress()、onSuccess()、onFailed()、onPaused() 和onCanceled()这5个方法。在onProgress()方法中，我们调用getNotification()方法构建了一个用于显示下载进度的通知，然后调用NotificationManager的notify()方法去触发这个通知，这样就可以在下拉状态栏中实时看到当前下载的进度了。在onSuccess()方法中，我们首先是将正在下载的前台通知关闭，然后了创建一个新的通知用于告诉用户下载成功了。其他几 个方法也都是类似的，分别用于告诉用户下载失败、暂停和取消这几个事件。  
接下来为了要让DownloadService可以和活动进行通信，我们又创建了一个DownloadBinder。DownloadBinder 中提供了startDownload()、 pauseDownload()和 cancelDownload()这 3 个 方法，那么顾名思义，它们分别是用于开始下载、暂停下载和取消下载的。在startDownload()方法中，我们创建了一个DownloadTask的实例，把刚才的DownloadListener作为参数传入，然 后调用execute()方法开启下载，并将下载文件的URL地址传入到execute()方法中。同时， 为了让这个下载服务成为一个前台服务，我们还调用了 startForeground()方法，这样就会在系统状态栏中创建一个持续运行的通知了。接着往下看，pauseDownload()方法中的代码就非常简单了，就是简单地调用了一下 DownloadTask 中的 pauseDownload ()方法。cancelDownload() 方法中的逻辑也基本类似，但是要注意，取消下载的时候我们需要将正在下载的文件删除掉，这 一点和暂停下载是不同的。  
另外，DownloadService类中所有使用到的通知都是调用getNotification()方法进行构建的，这个方法中的代码我们之前基本都是学过的，只有一个setProgress()方法没有见过。 setProgress ()方法接收3个参数，第一个参数传入通知的最大进度，第二个参数传入通知的当前进度，第三个参数表示是否使用模糊进度条，这里传入false。设置完setProgress()方法, 通知上就会有进度条显示出来了。  
现在下载的服务也已经成功实现，后端的工作基本都完成了，那么接下来我们开始编写前端的部分。修改activity\_main.xml中的代码，如下所示：

布局文件还是非常简单的，这里在LinearLayout中放置了3个按钮，分别用于开始下载、暂停下载和取消下载。  
然后修改MainActivity中的代码，如下所示：

package com.example.administrator.servicebestpractice;
    
    import android.Manifest;
    import android.content.ComponentName;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.content.pm.PackageManager;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.support.v4.app.ActivityCompat;
    import android.support.v4.content.ContextCompat;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    import android.widget.Toast;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{ 
    
        private DownloadService.DownloadBinder downloadBinder;
    
        private ServiceConnection connection = new ServiceConnection() { 
    
            @Override
            public void onServiceDisconnected(ComponentName name) { 
            }
    
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) { 
                downloadBinder = (DownloadService.DownloadBinder) service;
            }
    
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Button startDownload = (Button) findViewById(R.id.start_download);
            Button pauseDownload = (Button) findViewById(R.id.pause_download);
            Button cancelDownload = (Button) findViewById(R.id.cancel_download);
            startDownload.setOnClickListener(this);
            pauseDownload.setOnClickListener(this);
            cancelDownload.setOnClickListener(this);
            Intent intent = new Intent(this, DownloadService.class);
            startService(intent); // 启动服务
            bindService(intent, connection, BIND_AUTO_CREATE); // 绑定服务
            if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { 
                ActivityCompat.requestPermissions(MainActivity.this, new String[]{  Manifest.permission. WRITE_EXTERNAL_STORAGE }, 1);
            }
        }
    
        @Override
        public void onClick(View v) { 
            if (downloadBinder == null) { 
                return;
            }
            switch (v.getId()) { 
                case R.id.start_download:
                    String url = "https://raw.githubusercontent.com/guolindev/eclipse/master/eclipse-inst-win64.exe";
                    downloadBinder.startDownload(url);
                    break;
                case R.id.pause_download:
                    downloadBinder.pauseDownload();
                    break;
                case R.id.cancel_download:
                    downloadBinder.cancelDownload();
                    break;
                default:
                    break;
            }
        }
    
        @Override
        public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
            switch (requestCode) { 
                case 1:
                    if (grantResults.length > 0 && grantResults[0] != PackageManager.PERMISSION_GRANTED) { 
                        Toast.makeText(this, "拒绝权限将无法使用程序", Toast.LENGTH_SHORT).show();
                        finish();
                    }
                    break;
                default:
            }
        }
    
        @Override
        protected void onDestroy() { 
            super.onDestroy();
            unbindService(connection);
        }
    
    }

可以看到，这里我们首先创建了一个Serviceconnection的匿名类，然后在onServiceConnected()方法中获取到DownloadBinder的实例，有了这个实例，我们就可以在活动中调用 服务提供的各种方法了。  
接下来看一下onCreate()方法，在这里我们对各个按钮都进行了初始化操作并设置了点击事件，然后分别调用了 startService()和bindService()方法来启动和绑定服务。这一点至关重要，因为启动服务可以保证DownloadService—直在后台运行，绑定服务则可以让MainActivity 和DownloadService进行通信，因此两个方法调用都必不可少。在onCreate()方法的最后，我们还进行了 WRITE\_EXTERNAL\_STORAGE的运行时权限申请，因为下载文件是要下载到SD卡的 Download目录下的，如果没有这个权限的话，我们整个程序都无法正常工作。  
接下来的代码就非常简单了，在onClick()方法中我们对点击事件进行判断，如果点击了开始按钮就调用DownloadBinder的startDownload()方法，如果点击了暂停按钮就调用 pauseDownload()方法,如果点击了取消按钮就调用 cancelDownload()方法。startDownload()方法中你可以传入任意的下载地址，这里我使用了一个Eclipse的下载地址，以此向这个Android平台上曾经最出色的开发工具致敬。  
另外还有一点需要注意，如果活动被销毁了，那么一定要记得对服务进行解绑，不然就有可能会造成内存泄漏。这里我们在onDestroy()方法中完成了解绑操作。  
现在只差最后一步了，我们还需要在AndroidManifest.xml文件中声明使用到的权限。当然除 了权限之外，MainActivity和DownloadService也是需要声明的，不过Android Studio应该早就帮我们将这两个组件声明好了，如下所示：

<?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.administrator.servicebestpractice">
    
        <uses-permission android:name="android.permission.INTERNET"/>
        <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    
        <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">
            <activity android:name=".MainActivity">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
    
            <service
                android:name=".DownloadService"
                android:enabled="true"
                android:exported="true"></service>
        </application>
    
    </manifest>

其中，由于我们的程序使用到了网络和访问SD卡的功能，因此需要声明INTERNET和WRITE\_EXTERNAL\_STORAGE 这两个权限。  
这样所有代码就都编写完了，现在终于可以运行一下程序了，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 8]  
程序一启动立刻就会申请访问SD卡的权限,这里我们点击ALLOW，然后点击Start Download 按钮就可以开始下载了。下载过程中可以下拉系统状态栏查看实时的下载进度，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 9]

同时，我们还可以点击Pause Download或Cancel Download，甚至于断网操作来测试这个下 载程序的健壮性。最终下载完成后会弹出一个Download Success的通知，然后我们可以通过任意 一个文件浏览器来查看一下SD卡的Download目录，就可以看到，文件已经成功下载下来了。  
当然，我们还可以做一些更加丰富的操作，比如说再次点击Start Download按钮，你会发现程序会立刻弹出一个Download Success的提示，因为它检测到文件已经下载完成了，因而不会再重新去下载一遍。如果我们点击Cancel Download按钮先将下载文件删除掉，然后再点击Start Download按钮，你就会发现程序又会开始重新下载了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191112164321846.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/201911121643359.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191112164424212.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191112164513515.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191112170608414.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191112170718524.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[20191112170727368.png]: https://img-blog.csdnimg.cn/20191112170727368.png
[20191112170733961.png]: https://img-blog.csdnimg.cn/20191112170733961.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191112171519213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[20191112171527343.png]: https://img-blog.csdnimg.cn/20191112171527343.png
[20191112171622952.png]: https://img-blog.csdnimg.cn/20191112171622952.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191112171645196.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[20191112171652276.png]: https://img-blog.csdnimg.cn/20191112171652276.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20191112171845973.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191112171855247.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70