第三天.公共类搭建

嘿,今天的你过的还好吗

很气.写完代码运行的时候一直提示我库重复
最后在gradle.properties里面加了一行这个就好了.浪费时间

android.enableJetifier=true

第三天其实就没啥好搞的了.但是一想 我没有网络层啊.网络层我想放到基类里了.但是我小想了一下.放到公共类就行了.毕竟每个项目网络层都是有区别的
到了公共类就需要各种搭建了.什么retorfit啊什么rxjava啊.都需要

image.png

先贴图

引包这一大堆

 //retorfit2 + rxjava
    api("com.squareup.retrofit2:retrofit:2.9.0")
    // 基本属性数据转换器
    api("com.squareup.retrofit2:converter-scalars:2.9.0")
    //  Gson 数据转换器
    api("com.squareup.retrofit2:converter-gson:2.9.0")
    // Rxjava 适配器（可选）
    api("com.squareup.retrofit2:adapter-rxjava2:2.9.0")
    // OkHttp
    api("com.squareup.okhttp3:okhttp:5.0.0-alpha.8")
    api("com.squareup.okhttp3:logging-interceptor:5.0.0-alpha.8")
    // RxJava RxAndroid RxKotlin（可选）
    api("io.reactivex.rxjava2:rxjava:2.2.18")
    api("io.reactivex.rxjava2:rxandroid:2.1.1")
    api("io.reactivex.rxjava2:rxkotlin:2.2.0")
    api("io.reactivex.rxjava3:rxjava:3.0.4")
    // Kotlin 协程（可选）
    api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
    api("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4")

核心就是RetrofitManager.话不多说 直接上代码

package com.example.common.network

import android.util.Log
import com.example.basic.application.BaseApplication
import com.example.common.constant.Config.sBaseUrl
import com.example.common.network.TokenInterceptor
import okhttp3.Cache
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.converter.scalars.ScalarsConverterFactory
import java.util.concurrent.TimeUnit

object RetrofitManager {
    // 设置拦截器
    val httpLoggingInterceptor = HttpLoggingInterceptor() {
//        LogUtil.e("okhttp.OkHttpClient",it)
        Log.e("RetrofitManager", it)
    }.apply {
        level = HttpLoggingInterceptor.Level.BODY
    }
    val cacheDir = BaseApplication.sInstance.externalCacheDir ?: BaseApplication.sInstance.cacheDir
    val okHttpClient = OkHttpClient().newBuilder()
        // 设置连接超时为 10 秒
        .connectTimeout(10L, TimeUnit.SECONDS)
        // 设置文件读取超时为 60 秒
        .readTimeout(60L, TimeUnit.SECONDS)
        // 设置用于读取和写入缓存响应的响应缓存为 10M
        .cache(Cache(cacheDir, 10240 * 1024))
        // 设置 http 日志拦截器
        // 使用 addInterceptor() 也可以，即为第一层自定义拦截器
//        .addInterceptor(Interceptor { chain -> /*获取token */
//            val token = UserUtil.getUserToken()
//            if ("false" == chain.request().header("isToken")) {
//                val request = chain.request().newBuilder().removeHeader("Authorization")
//                    .removeHeader("isToken").build()
//                chain.proceed(request)
//            } else {
//                val request =
//                    chain.request().newBuilder().addHeader("Authorization", ("$token") ?: "")
//                        .removeHeader("isToken").build()
//                chain.proceed(request)
//            }
//        })
        // 使用 addNetworkInterceptor() 也可，即为第六层非网页网络拦截拦截器
        .addInterceptor(httpLoggingInterceptor)
        .addInterceptor(TokenInterceptor()) //添加判断token是否过期的拦截器
        .build()

    // 3.构建 Retrofit 对象
    val retrofit: Retrofit = Retrofit.Builder().baseUrl(sBaseUrl).client(okHttpClient)
        .addConverterFactory(ScalarsConverterFactory.create())// 基本属性转换器
        .addConverterFactory(GsonConverterFactory.create())// Gson 数据转换器
        .addCallAdapterFactory(RxJava2CallAdapterFactory.createAsync())// RxJava 适配器
        .build()
}

关于那个拦截器TokenInterceptor.我写了个token的 当然了这个跟个人业务有关

package com.example.common.network;

import org.greenrobot.eventbus.EventBus;

import java.io.IOException;

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;

/**
 * Okhttp接口请求拦截器，判断token是否过期，若token过期则跳转至登录页面
 */
public class TokenInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) throws IOException {

        Request request = chain.request();
        Response response = chain.proceed(request);
        //根据和服务端的约定判断token过期
        if (isTokenExpired(response)) {
//            EventBus.getDefault().post(new LogoutEvent(-1, "请重新登录"));
            return response.newBuilder().code(200).build();
        }
        return response;
    }

    /**
     * 根据Response，判断Token是否失效
     */
    private boolean isTokenExpired(Response response) {
        if (response.code() == 401) {
            return true;
        }
        return false;
    }
}

然后解析的时候BaseResponse这个就根据自己业务实际了

package com.example.common.network

import com.example.basic.util.ToastUtilsExt

open class BaseResponse<T>(
    var code: Int,
    var `data`: T? = null,
    var msg: String? = null,
    var time_stamp: String? = null,
    var success: Boolean? = null
) {
    fun isSuccess(): Boolean {
        if (code == 1) {
            return true
        } else {
            if (!msg.isNullOrEmpty()) {
                ToastUtilsExt.info(msg)
            }
        }
        return false
    }


}

上面的APiServer代码就是通用了

package com.example.kotlinbasemodel.api

import com.example.common.network.BaseResponse
import com.example.common.network.RetrofitManager
import okhttp3.MultipartBody
import retrofit2.http.*

// 1.定义请求接口
interface ApiService {
    @Multipart
    @POST("/api/APP/upload_photo")
    suspend fun uploadList(
        @Part parts: List<MultipartBody.Part>
    ): BaseResponse<Map<String, String>?>
//登录
//    @Headers("isToken: false")
//    @POST("/api/APP/pda_login")
//    suspend fun login(@Body request: LoginRequest): BaseResponse<LoginResponse>

    companion object {
        // 4.通过动态代理获取到所定义的接口
        val apiService = RetrofitManager.retrofit.create(ApiService::class.java)
    }
}

好了完事了拜拜

没更新或者频繁更新的时候都是在认真生活