Android中使用Kotlin协程(Coroutines)和Retrofit进行网络请求(三)之异常处理与封装

• 写在前面
  前面文章介绍了一些kotlin协程和retorfit结合进行网络请求的基础,但是如果在前面的demo执行的过程中,我们断开手机网络,会发生什么?没错,APP会因为IO异常而崩溃!为什么呢,这是因为retrofit在执行excute()方法时会throws IOException,而enqueue()方法则不会,因为它会把IOException处理放在callback的onFailure方法里.所以如果我们需要使用excute()方法就需要手动处理异常.

• 异常的分类
  当一个网络请求得到的结果并非是你的期望值,我们就可以看作是请求异常,那么请求异常有哪些原因呢,我把请求异常分为三类:
  第一类,网络问题,可能是设备网络未连接,连接信号弱,网络拥堵,等等原因,这就是IOException;
  第二类,连接服务器问题,我们都知道正常的网络访问结果返回的code是200,如果返回502,404等,那就是服务器,可能是请求地址有问题可能是请求方式有问题或者服务器原因,这种在retrofit中也有表达;
  第三类,返回值异常,就是服务器能正常返回给你数据,但是数据不是你想要的,这就是逻辑问题,可能你的参数不对,可能后端处理不对,也可能根据你的请求本身逻辑就应该显示这种异常.这种需要根据你项目具体的接口文档进行决定,需要自行对结果进行判断
  好,类型定了,那就先用代码表现出来,先写一个枚举类

  enum class ErrorType {
      NETWORK_ERROR,//网络出错
      SERVICE_ERROR,//服务器访问异常
      RESPONSE_ERROR//请求返回值异常
  }
  

  再来一个错误类用于封装错误信息

   /**
   * 网络请求出错的响应
   */
  data class ErrorResponse(
      val errorType:ErrorType,//错误类型
      val errorTag:String,//错误tag,用于区别哪个请求出错
      val errorCode: String?,//错误代码
      val message: String?//错误信息
  )
  

• 创建ApiSerevice
  retrofit需要创建一个接口类,不过我们在kotlin中可以对这个类直接进行初始化,上一篇文章中已经演示了如何通过伴生对象直接获取retrofit单例实例(实际上接口没办法做到真正的单例,因为无法私有构造函数)这次我们通过invoke()函数的方式来实例化retrofit,至于单例,实际项目中可以通过依赖注入框架来实现,话不多说先上代码

  interface ApiService {
  
      @POST("versionupdate/getCurrentAppVersion")
      fun getCurrentAppVersion(@Query("json") json:String) :Call<UpdateResult>
  
      @POST("userinfo/signin")
      fun userLogin(@Query("json") json:String):Call<LoginResult>
  
      companion object {
  		//operator 是构造函数操作符, operator fun invoke()相当于是实现java的构造函数
          operator fun invoke(): ApiService {
              //自定义一个拦截器,打印请求地址和请求结果
              val paramInterceptor = Interceptor{ chain ->
                  val url = chain.request().url().url().toString()
  
                  LogUtil.d("发送请求:${URLDecoder.decode(url,"utf-8")}")
                  val response = chain.proceed(chain.request())
                  //注意这里不能直接使用response.body.string(),否则流会关闭,会报异常
                  val responseBody = response.peekBody(1024*1024)
                  LogUtil.d("请求结果:${responseBody.string()}")
                  return@Interceptor response
              }
  
              val okHttpClient = OkHttpClient.Builder()
                  .addInterceptor(paramInterceptor)
                  .build()
  
              return Retrofit.Builder()
                   .baseUrl("http://*****/") //代码节选自我个人真实项目,为安全起见,隐藏baseUrl
                   .addConverterFactory(GsonConverterFactory.create())
                   .client(okHttpClient)
                   .build()
                   .create(ApiService::class.java)
          }
      }
  }	
  

• 网络请求类
  我在前面的文章里说过了,在实际项目不应该在activity或者fragment中直接调用网络请求API,需要在一个专门的网络请求类中进行.为什么呢?这是因为如果在activity或者fragment中直接操作网络请求,由于是异步操作,有内存泄漏的风险,另外也会不符合解耦的原则,如果网络请求遍布project各个地方,还会对接口测试造成困难.所以我们需要创建网络请求类,基于解耦原则,我们先创建一个接口

  /**
   * 用于网络请求获取数据的接口,两个方法对应上面两个网络请求
   */
  interface EduNetworkDataSource {
  	//用于封装请求错误的LiveData,UI通过监听这个值来判断网络是否发生异常
      val errorResult:LiveData<ErrorResponse>
  
      suspend fun fetchCurrentAppVersion(param: GetVersionParam):LiveData<UpdateResult>
  
      suspend fun userLogin(param:LoginParam):LiveData<LoginResult>
  }
  

  请注意,我上面所有的网络请求结果都用LiveData封装,它是一个可观察数据改变的对象,具体关于LiveData和ViewModel,我在前面MVVM架构的文章中略作过讲解,如果你想详细了解,请参看google的官方文档.简单点说就是当它的值发生改变时,它会通知它的观察者,并且它会监听UI的生命周期.之所以使用suspend关键字,是因为网络请求是一个阻塞操作,而我们网络请求都会放在协程中进行.
  好,下面我们看看具体请求实现类

  /**
   * 网络接口请求实现类
   */
  class EduNetworkDataSourceImpl(
      private val apiService: ApiService,
      private val context: Context
  ) : EduNetworkDataSource {
  
      //请求错误结果,这里的SingleLiveData是继承自LiveData,当读取error信息之后自动清空其中的信息,防止下一个观察者读取到之前的错误信息
      private val _errorResult = SingleLiveData<ErrorResponse>()
      /*这个用于给外界使用,LiveData值无法在修改,MutableLiveData才可以修改,防止其他类修改值*/
      override val errorResult: LiveData<ErrorResponse>
          get() = _errorResult
  
      private val gson = Gson()
  
      //从服务器获取最新版本
      override suspend fun fetchCurrentAppVersion(param: GetVersionParam) =
          handleRequest("获取最新版本") {
              apiService.getCurrentAppVersion(gson.toJson(param)).execute()
          }
  
      //用户登陆
      override suspend fun userLogin(param: LoginParam) =
          handleRequest("用户登陆") {
              apiService.userLogin(gson.toJson(param)).execute()
          }
  
  
      /**
       * 统一处理请求错误以及向LiveData发送数据
       * 这是一个高阶函数,第一个参数用于标识是哪个网络请求
       * 第二个参数就是一个方法(这和javaScript中把方法当作参数传递类似)
       * 这个BaseResult是用来判断业务逻辑失败的,根据项目实际情况自行定义,下面"description"和"code"来自于BaseResult
       */
      private suspend fun <T : BaseResult> handleRequest(
          tag: String,
          action: () -> Response<T>
      ): LiveData<T> {
          val liveData = MutableLiveData<T>()
          withContext(Dispatchers.IO) {
              try {
                  val response = action()
                  if (response.isSuccessful) {
                      val body = response.body()
                      //这个根据具体前后端接口协议来定
                      if (body != null && "0" == body.code) {
                          liveData.postValue(body)
                      } else {
                      	//逻辑异常通过实际项目中具体制定的前后端接口文档来决定,我们将异常结果发送出去
                          context.showToast("$tag 失败:${body?.description}")
                          _errorResult.postValue(
                              ErrorResponse(
                                  ErrorType.RESPONSE_ERROR,
                                  tag,
                                  body?.code,
                                  body?.description
                              )
                          )
                      }
  
                  } else {
  					//这表示请求结果非200,服务器异常,将错误信息和响应码发送出去
                      context.showToast("$tag 失败:${response.code()} - ${response.message()}")
                      _errorResult.postValue(
                          ErrorResponse(
                              ErrorType.SERVICE_ERROR,
                              tag,
                              response.code().toString(),
                              response.message()
                          )
                      )
                  }
  
              } catch (e: IOException) {
              	//如果有IO异常,那说明是网络有问题,直接将错误信息的值发送出去
                  e.printStackTrace()
                  LogUtil.e(e.toString())
                  context.showToast("$tag 失败:$e")
                  _errorResult.postValue(
                      ErrorResponse(
                          ErrorType.NETWORK_ERROR,
                          tag,
                          null,
                          e.toString()
                      )
                  )
              }
          }
          return liveData
      }
  }
  

  上面用到了SingleLiveData,代码如下

  class SingleLiveData<T> : MutableLiveData<T>() {
      override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
          super.observe(owner, Observer {
              if(it != null){
                  observer.onChanged(it)
                  postValue(null)
              }
          })
      }
  }
  

• 使用网络请求
  首先说明一点,在实际项目开发中,你不应该在UI类(我所说的UI类就是指Activity或者Fragment)直接使用NetworkDataSource 类进行网络请求,因为你请求到的数据可能需要进行逻辑处理,一系列的数据转换,以及存储到数据库等等操作,在UI类中操作会让UI类变得庞大繁复难以维护和测试,如果你项目采用MVP架构,你应该在Presenter中进行,如果使用MVVM架构,你应该在Repository中进行,这里我简单演示一下,在Repository中进行网络请求,以及它如何传递给UI,实际数据传递过程类似于我前面的文章中讲到的架构
  首先是Repository类

  class EduRepositoryImpl(
      private val eduNetworkDataSource: EduNetworkDataSource
  ) : EduRepository {
  
      private val userinfo = MutableLiveData<Userinfo>()
  
      //获取用户信息
      fun getUserInfo() = userinfo as LiveData<Userinfo>
  
      //用户登陆,登陆之后更新用户信息
      override suspend fun userLogin(param: LoginParam): LiveData<LoginResult> {
          return eduNetworkDataSource.userLogin(param).also { loginResultLiveData ->
              loginResultLiveData.value?.let {loginResult ->
                  userinfo.postValue(loginResult.userinfo)
              }
          }
      }
  
      //获取最新版本
      override suspend fun getCurrentAppVersion(param: GetVersionParam): LiveData<UpdateResult> {
          return eduNetworkDataSource.fetchCurrentAppVersion(param)
      }
  
      //错误信息
      override suspend fun getError(): LiveData<ErrorResponse> {
          return eduNetworkDataSource.errorResult
      }
  
  }
  

  然后是ViewModel类,这里只展示一个接口的使用

  class SplashViewModel(private val eduRepository: EduRepository): ViewModel() {
  
      suspend fun getCurrentAppVersion(param: GetVersionParam) = eduRepository.getCurrentAppVersion(param)
  
      suspend fun getError() = eduRepository.getError()
  }
  

  然后是ViewModelFactory类

  class SplashViewModelFactory(private val eduRepository: EduRepository): ViewModelProvider.NewInstanceFactory() {
  
      override fun <T : ViewModel?> create(modelClass: Class<T>): T {
          @Suppress("UNCHECKED_CAST")
          return SplashViewModel(eduRepository) as T
      }
  }
  

  最后是在UI类中的相关代码,注意,UI类还是需要继承CoroutineScope ,并且初始化job和coroutineContext,这个和前面的代码一样,我就不贴出来了,具体请参见前面的文章讲解

  launch {
          viewModel.getCurrentAppVersion(GetVersionParam("1")).observe(this@SplashActivity, Observer {
          //网络访问成功,这里会接收到livedata的数据更新通知
              if (it.versionupdate.versioncode > BuildConfig.VERSION_CODE) {
                  showToast("有新版本${it.versionupdate.versionname}可用")
              } else {
                  delayToHome()
              }
          })
          viewModel.getError().observe(this@SplashActivity, Observer {
          //网络访问失败,livedata会通知这里
              delayToHome()
          })
  }
  

  如此,在UI类中,只需要极少量的代码就可以实现网络访问以及异常监听,并且即使你不监听错误,程序也不会崩溃或者运行异常,因为在DataSource类有try/catch.
  最后,这一切,无论是网络请求还是数据监听,都是在UI生命周期安全范围内进行的,因为Livedata监听了UI生命周期,我们的协程launch也同样在UI生命周期内才会执行,并且我们的observer监听,在主线程,又在协程中,所以你既可以操作UI,又可以放心大胆的进行耗时操作而无需担心会阻塞线程(当然是不建议在UI类中执行耗时操作的,因为UI类由系统监管,随时可能因为UI类的回收导致你的耗时操作被中断).

原创文章,转载请注明出处,谢谢