Retrofit 的基本用法

一、添加依赖和网络权限

添加依赖

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

// 可选
implementation 'com.squareup.okhttp3:logging-interceptor:4.9.3'

• 第一条依赖是下载Retrofit、OkHttp和Okio这几个库，我们就不需要手动引入OkHttp库了；
• 第二条依赖是一个Retrofit的转换库，它是借助GSON来解析JSON数据的，所以也会将GSON库一起下载；
• 第三条是 okHttp 的日志拦截器相关，可选。

添加网络权限

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET"/>

二、Retrofit data api 部分封装

2.1 创建接收服务器返回数据类、异常类、异常码

通用返回数据类

import com.google.gson.annotations.SerializedName

data class CommonResponse<T>(
    @SerializedName("code") val code: Int = -1,

    @SerializedName("data") val data: T,

    @SerializedName("msg") val msg: String
) {
    fun isSuccess(): Boolean {
        return code == 0
    }
}

异常类

data class ResponseException(
    var code: Int, override var message: String?
) : RuntimeException(message)

异常码定义

import androidx.annotation.IntDef

@IntDef(
    ErrorCode.SUCCESS, // 成功
    ErrorCode.FAIL, // 失败
    ErrorCode.NETWORK_EXCEPTION,//无网络，网络连接异常
    ErrorCode.HOST_ERROR,//host异常
    ErrorCode.TIMEOUT,//超时
    ErrorCode.CANCEL,//取消
    ErrorCode.JSON_SYNTAX_EXCEPTION,//数据解析异常
    ErrorCode.OK,//请求正常
    ErrorCode.CREATED,
    ErrorCode.FORBIDDEN,
    ErrorCode.UNAUTHORIZED,//无授权
    ErrorCode.NOT_FOUND,
    ErrorCode.OTHER,//其他错误，目前还未关注和处理的
    ErrorCode.CUSTOM_FIRST,//自定义，可自行修改
    ErrorCode.VALUE_IS_NULL//空值
)
@Retention(AnnotationRetention.SOURCE)
annotation class ErrorCode {
    companion object {
        const val SUCCESS = 0
        const val FAIL = 1
        const val NETWORK_EXCEPTION = 2
        const val HOST_ERROR = 3
        const val TIMEOUT = 4
        const val CANCEL = 5
        const val JSON_SYNTAX_EXCEPTION = 6
        const val OK = 200
        const val CREATED = 201
        const val FORBIDDEN = 401
        const val UNAUTHORIZED = 402
        const val NOT_FOUND = 404
        const val OTHER = 509
        const val CUSTOM_FIRST = 600
        const val VALUE_IS_NULL = CUSTOM_FIRST + 1
    }
}

2.2 封装异常处理

import com.google.gson.JsonSyntaxException
import retrofit2.HttpException
import java.net.ConnectException
import java.net.SocketException
import java.net.SocketTimeoutException
import java.net.UnknownHostException

private const val TAG = "getResultOrNull"

suspend fun <T> getResultOrNull(block: suspend () -> CommonResponse<T>): T? {
    runCatching {
        block()
    }.onSuccess {
        return it.data
    }.onFailure {
        when (it) {
            is ResponseException -> {
                logW(TAG, "getResult exception, code: ${it.code} message: ${it.message}")
            }
            is UnknownHostException,
            is HttpException,
            is ConnectException,
            is SocketTimeoutException,
            is SocketException,
            is NumberFormatException,
            is IllegalArgumentException,
            is IllegalStateException,
            is JsonSyntaxException -> {
                logW(TAG, "getResult exception: ${it.message}")
            }
            else -> {
                logW(TAG, "getResult other exception: ${it.message}")
            }
        }
        return null
    }
    return null
}

2.3 定义 SSLSocketClient

import java.security.KeyManagementException
import java.security.KeyStore
import java.security.NoSuchAlgorithmException
import java.security.SecureRandom
import java.security.cert.CertificateException
import java.security.cert.X509Certificate
import javax.net.ssl.*

object SSLSocketClient {

    @Throws(NoSuchAlgorithmException::class, KeyManagementException::class)
    fun getSSLSocketFactory(): SSLSocketFactory {
        val sslContext = SSLContext.getInstance("TLS")
        sslContext.init(null, getTrustManager(), SecureRandom())
        return sslContext.socketFactory
    }

    private fun getTrustManager(): Array<TrustManager> {
        val trustManager: X509TrustManager = object : X509TrustManager {
            @Throws(CertificateException::class)
            override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) {
            }

            @Throws(CertificateException::class)
            override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
            }

            override fun getAcceptedIssuers(): Array<X509Certificate> {
                return arrayOf()
            }
        }
        return arrayOf(trustManager)
    }

    fun getHostnameVerifier(): HostnameVerifier {
        return HostnameVerifier { _, _ -> true }
    }

    @Throws(Exception::class)
    fun getX509TrustManager(): X509TrustManager {
        var trustManager: TrustManager? = null
        val trustManagerFactory =
            TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
        trustManagerFactory.init(null as? KeyStore)
        val trustManagers = trustManagerFactory.trustManagers
        if (trustManagers.size != 1 || trustManagers[0] !is X509TrustManager) {
            throw IllegalStateException("Unexpected default trust managers: $trustManagers")
        }
        return trustManagers[0] as X509TrustManager
    }
}

2.4 自定义 CustomGsonConverterFactory

import com.google.gson.Gson
import com.google.gson.JsonIOException
import com.google.gson.TypeAdapter
import com.google.gson.reflect.TypeToken
import com.google.gson.stream.JsonToken
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.RequestBody
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.ResponseBody
import okio.Buffer
import retrofit2.Converter
import retrofit2.Retrofit
import java.io.ByteArrayInputStream
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.lang.reflect.Type
import java.nio.charset.Charset
import kotlin.text.Charsets.UTF_8

class CustomGsonConverterFactory private constructor(val gson: Gson): Converter.Factory() {
    companion object {
        fun create(): CustomGsonConverterFactory {
            return create(Gson())
        }

        private fun create(gson: Gson?): CustomGsonConverterFactory {
            if (gson == null) throw NullPointerException("gson == null")
            return CustomGsonConverterFactory(gson)
        }
    }

    override fun responseBodyConverter(
        type: Type,
        annotations: Array<out Annotation>,
        retrofit: Retrofit
    ): Converter<ResponseBody, *> {
        return CustomGsonResponseBodyConverter(gson, gson.getAdapter(TypeToken.get(type)))
    }

    override fun requestBodyConverter(
        type: Type,
        parameterAnnotations: Array<out Annotation>,
        methodAnnotations: Array<out Annotation>,
        retrofit: Retrofit
    ): Converter<*, RequestBody> {
        return CustomGsonRequestBodyConverter(gson, gson.getAdapter(TypeToken.get(type)))
    }
}

private class CustomGsonRequestBodyConverter<T>(private val gson: Gson, private val adapter: TypeAdapter<T>) : Converter<T, RequestBody> {
    private val MEDIA_TYPE = "application/json; charset=UTF-8".toMediaTypeOrNull()
    private val UTF_8 = Charset.forName("UTF-8")

    override fun convert(value: T): RequestBody {
        val buffer = Buffer()
        val writer = OutputStreamWriter(buffer.outputStream(), UTF_8)
        val jsonWriter = gson.newJsonWriter(writer)
        adapter.write(jsonWriter, value)
        jsonWriter.close()
        return buffer.readByteString().toRequestBody(MEDIA_TYPE)
    }
}

private class CustomGsonResponseBodyConverter<T>(private val gson: Gson, private val adapter: TypeAdapter<T>) : Converter<ResponseBody, T> {
    override fun convert(value: ResponseBody): T {
        val response = value.string()
        val commonResponse = gson.fromJson(response, CommonResponse::class.java)
        /** 先将code与msg解析出来，code非0的情况下直接抛ApiException异常，这样我们就将这种异常交给onFailure()处理了**/
        if (!commonResponse.isSuccess()) {
            value.close()
            throw ResponseException(commonResponse.code, commonResponse.msg)
        }
        val contentType = value.contentType()
        val charset = contentType?.charset(UTF_8) ?: UTF_8
        val inputStream = ByteArrayInputStream(response.toByteArray())
        val reader = InputStreamReader(inputStream, charset)
        val jsonReader = gson.newJsonReader(reader)

        value.use { _ ->
            val result = adapter.read(jsonReader)
            if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
                throw JsonIOException("JSON document was not fully consumed.")
            }
            return result
        }
    }
}

2.5 创建 RetrofitClient 以及业务接口

object RetrofitClient {
    private val instance: Retrofit by lazy {
        val logger = HttpLoggingInterceptor().apply { level = HttpLoggingInterceptor.Level.BASIC }

        val client = OkHttpClient.Builder()
            .addInterceptor(logger)
            .addInterceptor(Interceptor { chain ->
                val originalRequest: Request = chain.request()
                val request = originalRequest.newBuilder()
                    .header("content-type", "application/json;charset:utf-8")
                    .build()
                chain.proceed(request)
            })
            .sslSocketFactory(SSLSocketClient.getSSLSocketFactory(), SSLSocketClient.getX509TrustManager())
            .connectTimeout(20, TimeUnit.SECONDS)
            .writeTimeout(20, TimeUnit.SECONDS)
            .readTimeout(20, TimeUnit.SECONDS)
            .retryOnConnectionFailure(true)
            .build()

        Retrofit.Builder().baseUrl(HttpUrls.getBaseUrl())
            .client(client)
            .addConverterFactory(CustomGsonConverterFactory.create())
            .build()
    }


    // TestService 见下
    fun getTestService(): TestService {
        return instance.create(TestService::class.java)
    }
}

三、具体业务接口封装

3.1 data 部分定义

IDataSource

interface IDataSource {
    suspend fun getPrivacyList(): List<PrivacyInfo>
}

TestService

interface TestService {
    @POST("privacy/getPrivacyList")
    suspend fun getPrivacyList(@Body req: GetPrivacyReq): CommonResponse<List<PrivacyInfo>>
}

RemoteDataSource

class RemoteDataSource private constructor() : IDataSource {

    private lateinit var testService: TestService

    companion object {
        @Volatile
        private var instance: RemoteDataSource? = null

        fun getInstance(context: Context): RemoteDataSource {
            return instance ?: synchronized(this) {
                instance ?: RemoteDataSource().also {
                    it.testService = RetrofitClient.getTestService()
                    instance = it
                }
            }
        }
    }


    override suspend fun getPrivacyList(): List<PrivacyInfo> = withContext(Dispatchers.IO) {
        val req = buildGetPrivacyReq() // 创建入参
        val result = getResultOrNull {
            testService.getPrivacyList(req)
        }
        result?: mutableListOf()
    }

}

TestRepository

object TestRepository {
    private val localDataSource: LocalDataSource by lazy {
        LocalDataSource.getInstance(App.appContext)
    }

    private val remoteDataSource: RemoteDataSource by lazy {
        RemoteDataSource.getInstance(App.appContext)
    }


    suspend fun getPrivacyList(): List<PrivacyInfo> {
        return remoteDataSource.getPrivacyList()
    }
}