会用Retrofit了？你也能自己动手写一个！

想封装一套网络请求，不想直接上来就用别人写好的，或者说对项目可以更好的掌控，所以自己模仿着Retrofit来写一套。

想要有如下实现：

1. 快捷的网络请求调用

2. 声明式的定义网络请求函数

3. 可以很灵活的变更网络请求的方式(http,https,socket等)

4. 可以使用自己的线程池或者协程进行线程调度

定义网络请求函数(如果不使用key来判断，甚至不需要定义companion object中的LOGIN)，示例：

调用网络请求和接收返回数据，示例：

this回调

或者匿名内部类回调

准备和前提

需要读者有如下技能，否则阅读会比较吃力。

1. java编程基础

2. kotlin编程基础(java经验好可能也无所谓) (kotlin下面简称kt)

3. 网络请求常识

阅读完本篇文章可以看到(或学到)的知识点：

1. 动态代理的使用和工作原理

2. java和kotlin的部分反射的使用和区别

3. 声明和使用运行时注解

4. dsl的创建,使用和原理

5. 封装的思想(我遇到某些代码时是怎么想的)

正式开始

（从空项目开始，所以每一步都会提及,使用kt写)

测试网络和url是否通(不然后面没法验证到底是哪的问题)

这里测试的url使用玩安卓的开放api

清单文件加入权限

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

封装ROOT_URL

object HttpConfig {
    const val ROOT_URL = "https://www.wanandroid.com/"
} 

测试如下url是否可用(使用了kt系统库的扩展函数,和自己定义了一个打印log的函数)

import java.net.URL
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        thread {
            URL(HttpConfig.ROOT_URL + "article/list/0/json?cid=1").readText().print()
        }//这里,如果没问题的话就会在logcat中打印出本次网络请求返回的数据
    }

}

fun Any?.print() = Log.w("lllttt", this.toString()) 

开始仿照Retrofit的声明式接口，自己定义一个接口

网络回调的接口

interface ObserverCallBack {
    /**
     * @param data     返回的数据 json
     * @param encoding 网络请求的状态(成功,失败,网络失败等)
     * @param method   判断是哪个接口返回的数据
     */
    fun handleResult(data: String?, encoding: Int, method: Int)
}

声明的网络接口

interface HttpFunctions {

    /**

     * 获取玩安卓的json数据

     * @param cid 这个接口的参数(虽然不知道有什么用emmm)

     */

    fun getJson(_callback: ObserverCallBack?,
              cid: String
    )

}

显然上面所声明的网络接口是没法直接调用的，想要调用一个接口的方法，必须有其实现类，而实现该接口对于便捷的网络封装是不现实的，而使用动态代理，就可以在运行时动态生成一个实现类，并且还可以使用代码动态的控制其函数的逻辑。

使用动态代理获取获取运行时的接口实现类，并获取运行时数据

动态代理平时说的挺玄乎，其实使用和理解起来还是很简单的。大体原理可以这么理解：动态的实现一个类，继承Proxy，并实现所有传入的接口，然后通过反射创建出来这个类，方法都是默认空实现，并且每次调用方法都会经过InvocationHandler的invoke方法，invoke方法里有调用方法的Method对象，可以反射Method对象来实现代理。

主要api

Proxy.newProxyInstance() 

该方法一共三个参数，第一个是类加载器，第二个就是被代理的接口class集合，第三个是处理方法的InvocationHandler。我们可以这样生成动态代理：

interface HttpFunctions {

    companion object {
        /**

         * 动态代理单例对象

         */
        val instance: HttpFunctions = getHttpFunctions()

        //获取动态代理实例对象

        private fun getHttpFunctions(): HttpFunctions {
            val clazz = HttpFunctions::class.java//拿到我们被代理接口的class对象
            return Proxy.newProxyInstance(//调用动态代理生成的方法来生成动态代理
                    clazz.classLoader,//类加载器对象
                    arrayOf(clazz),//因为我们的接口不需要继承别的接口,所以直接传入接口的class就行
                    HttpFunctionsHandler()//InvocationHandler接口的实现类,用来处理代理对象的方法调用
            ) as HttpFunctions
        }

    }

}

接下来我们实现InvocationHandler接口，可以发现只有一个方法，重写后打印动态代理对象调用的方法名称和方法参数(由于使用kt的接口做为被代理，所以可以返回Unit对象)。

/**

 * 动态代理类方法处理对象

 */

class HttpFunctionsHandler : InvocationHandler {

    override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
        method?.name.print()//打印方法名
        args?.forEach { it.print() }//打印参数值
        return Unit
    }

} 

接下来我们调用动态代理，测试一下。

HttpFunctions.instance.getJson(null, "1")

打印如下:

W/lllttt: getJson
W/lllttt: null
W/lllttt: 1 

可以看到我们确实拿到了方法名称和参数的值。

动态代理结合反射实现网络请求

现在我们修改HttpFunctionsHandler的代码来通过反射拿到参数名。

override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
      method?.name.print()//打印方法名
      args?.forEach { it.print() }//打印参数值
      method?.parameters?.forEach { it.name.print() }//打印参数名
      return Unit
}

但是发现打印如下:
W/lllttt: getJson
W/lllttt: null
W/lllttt: 1
W/lllttt: arg0
W/lllttt: arg1 

参数名变成了argx(而且在安卓项目上需要api26以上才能使用)，这是为什么呢？

原来java8之前的版本因为某些原因没有支持保留方法参数名的功能，直到java8才支持，且需要手动设置编译参数，所以此种方案无法实现。

ps:安卓项目使用如下方式只能开启java8的部分能力(如lambda和stream)，不能开启全部。

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
} 

那Retrofit是怎么绕开这个限制的呢？使用参数注解，如下：

//发表评论
@FormUrlEncoded
@POST("v1/comment/create")
Observable<NetBean<Boolean>> commentCreate(
        @Field("scene") String scene,
        @Field("scene_id") Long scene_id,
        @Field("reply_id") Long reply_id,
        @Field("content") String content
); 

这也太麻烦了，每一个参数都得对应一个注解，而方法上还需要加两个注解。所以我们使用一种更便捷的方式：kt反射。

首先引入kt的反射库(大小几百k)

implementation 'org.jetbrains.kotlin:kotlin-reflect:1.3.71' 

然后改造HttpFunctionsHandler

override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
//        method?.name.print()//打印方法名
//        args?.forEach { it.print() }//打印参数值
    method?.kotlinFunction?.parameters?.forEach {
        "${it.type} - ${it.name}".print()//打印参数类型和参数名
    }
    return Unit
}
打印结果如下:
W/lllttt: com.lt.retrofitdemo.http.HttpFunctions - null
W/lllttt: com.lt.retrofitdemo.http.ObserverCallBack? - _callback
W/lllttt: kotlin.String - cid 

我们成功的获取到了参数名，现在可以再次改造HttpFunctionsHandler，使调用HttpFunctions的方法就相当于调用网络请求。改造HttpFunctionsHandler (为了方便演示,只适配get请求,且网络请求方式比较简单)。

/**
 * 动态代理类方法处理对象
 */
class HttpFunctionsHandler : InvocationHandler {
    val handler = Handler(Looper.getMainLooper())

    override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
        thread {
            val kotlinFunction = method?.kotlinFunction//获取到KFunction对象
            val url = StringBuilder(HttpConfig.ROOT_URL)
                .append("article/list/0/json?")
            var callback: ObserverCallBack? = null
            kotlinFunction?.parameters?.forEachIndexed { index, kParameter ->
                when (kParameter.name) {
                    null -> {//HttpFunctions对象,我们不需要
                    }
                    "_callback" -> {//回调对象,ps:index-1是因为parameters的第0位置是代理类对象
                        callback = args?.get(index - 1) as? ObserverCallBack
                    }
                    else -> {//其他的就是参数了
                        //进行拼接url
                        url.append(kParameter.name)
                            .append('=')
                            .append(args?.get(index - 1))
                            .append('&')
                    }
                }
            }
            if (url.endsWith('&'))
                url.deleteCharAt(url.length - 1)//清除最后一个&
            url.print()
            val data = URL(url.toString()).readText()//请求网络
            handler.post {
                callback?.handleResult(data, 0, 0)//在主线程回调
            }
        }
        return Unit
    }
} 

然后调用封装后的方法。

HttpFunctions.instance.getJson(object : ObserverCallBack {
    override fun handleResult(data: String?, encoding: Int, method: Int) {
        data.print()
    }
}, "1")

 打印如下:
W/lllttt: https://www.wanandroid.com/article/list/0/json?cid=1
W/lllttt: {"data":{"curPage":1,"datas":[],"offset":0,"over":true,"pageCount":0,"size":20,"total":0},"errorCode":0,"errorMsg":""} 

可以看到网络请求调用很方便,不用使用参数注解就可以，那kt反射是怎么实现的呢？我们来看一下kt文件反编译后的字节码。

使用kt后会出现上面这个选项，使用该选项可以看到kt文件生成的字节码，然后点击Decompile按钮可以生成反编译后的java文件，这样就能看到我们HttpFunctions.kt类到底有什么。

@Metadata(
   mv = {1, 1, 16},
   bv = {1, 0, 3},
   k = 1,
   d1 = {"\u0000\u001e\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0000\n\u0002\u0010\u0002\n\u0000\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\u000e\n\u0002\b\u0002\bf\u0018\u0000 \b2\u00020\u0001:\u0001\bJ\u001a\u0010\u0002\u001a\u00020\u00032\b\u0010\u0004\u001a\u0004\u0018\u00010\u00052\u0006\u0010\u0006\u001a\u00020\u0007H&¨\u0006\t"},
   d2 = {"Lcom/lt/retrofitdemo/http/HttpFunctions;", "", "getJson", "", "_callback", "Lcom/lt/retrofitdemo/http/ObserverCallBack;", "cid", "", "Companion", "app_debug"}
)
public interface HttpFunctions {
   HttpFunctions.Companion Companion = HttpFunctions.Companion.$INSTANCE;
   void getJson(@Nullable ObserverCallBack var1, @NotNull String var2);
//只展示我们需要的 

可以看到，kt自动为我们的.kt类生成了@Metadata注解(元数据注解)，其中d2的元数据中把我们的类签名，方法名和参数名等都列了出来，所以kt反射取到的参数名就是从这里面取出来的。

使用注解来增强功能

现在我们的HttpFunctions只支持get请求，url也没地方设置，并且自定义化还没法做，所以我们使用注解，并搭配运行时反射来增强功能。

创建GET和POST两个注解。

/**
 * creator: lt  2020/3/26  lt.dygzs@qq.com
 *
 * get请求
 * @param url               请求链接
 * @param isEncryption      是否加密,一般网络请求都是需要加密的,所以设置了默认参数为true
 * @param callbackName      回调的参数名
 */

@Target(AnnotationTarget.FUNCTION)//表示该注解作用于方法上
@Retention(AnnotationRetention.RUNTIME)//表示该注解保留到运行时
annotation class GET(//在kt中 annotation class 表示注解类,而在java中使用 @interface
    val url: String,
    val isEncryption: Boolean = true,
    val callbackName: String = "_callback"
)
/**
 * creator: lt  2020/3/26  lt.dygzs@qq.com
 * post请求
 * @param url               请求链接
 * @param isEncryption      是否加密
 * @param callbackName      回调的参数名
 */
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class POST(
    val url: String,
    val isEncryption: Boolean = true,
    val callbackName: String = "_callback"
) 

接下来我们改造HttpFunctionsHandler的invoke方法，加入注解的判断。

/**
 * 动态代理类方法处理对象
 */
class HttpFunctionsHandler : InvocationHandler {

    val handler = Handler(Looper.getMainLooper())

    override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
        //ps:这里为了方便就直接new Thread了,如果是使用的话可以使用线程池或者kt协程,消耗会低很多,一般项目中是不允许直接new Thread的
        thread {
            //获取方法的注解,先获取get注解,如果为空就获取post注解; ps:自己用的时候可以先获取常用的注解,这样就不用判断两次了,比如项目里大部分都是post请求,那就先获取POST
            val annotation =
                method?.getAnnotation(GET::class.java)
                    ?: method?.getAnnotation(POST::class.java)
            //代码不要都堆到一块,而是应该拆成方法或者类,这样调用的时候只调用一个方法,逻辑会清晰很多; ps:这里其实也可以先判断常用的,因为kt的when函数的字节码其实也是if else
            when (annotation) {
                is GET -> startGet(proxy, method, args, annotation)
                is POST -> startPost(proxy, method, args, annotation)
                else -> throw RuntimeException("亲,${method?.name}方法是不是忘加注解了?")//如果出现异常情况,最好不要藏着,及时告诉开发人员,不然出了问题也不知道是怎么回事,得找好长时间
            }
        }
        return Unit
    }

    //post请求
    private fun startPost(proxy: Any?, method: Method?, args: Array<out Any>?, post: POST) {
        //post就不写了,大家可以在这里二次封装网络请求,比如使用okhttp,或者使用Socket,甚至可以用别人二次或者三次封装好的网络请求
    }

    //get请求
    private fun startGet(proxy: Any?, method: Method?, args: Array<out Any>?, get: GET) {
        //获取url并拼接
        val url = StringBuilder(HttpConfig.ROOT_URL).append(get.url)
        val callbackName = get.callbackName
        var callback: ObserverCallBack? = null
        var isAddQuestionMark = false//是否追加了'?'
        method?.kotlinFunction?.parameters?.forEachIndexed { index, kParameter ->
            when (kParameter.name) {
                null -> {//HttpFunctions对象,我们不需要
                }
                callbackName -> {//回调对象,ps:index-1是因为parameters的第0位置是代理类对象
                    callback = args?.get(index - 1) as? ObserverCallBack
                }
                else -> {//其他的就是参数了
                    if (get.isEncryption) {
                        //加密操作
                    } else {
                        //进行拼接url
                        if (!isAddQuestionMark) {
                            url.append('?')
                            isAddQuestionMark = true
                        }
                        url.append(kParameter.name)
                            .append('=')
                            .append(args?.get(index - 1))
                            .append('&')
                    }
                }

            }
        if (url.endsWith('&'))
            url.deleteCharAt(url.length - 1)//清除最后一个&
        url.print()
        val data = URL(url.toString()).readText()//请求网络
        handler.post {
            callback?.handleResult(data, 0, 0)//在主线程回调
        }
    }

} 

然后改变网络请求方法，再调用测试成功。

//修改网络请求
@GET("article/list/0/json", isEncryption = false)
fun getJson(
    _callback: ObserverCallBack?,
    cid: String
)

使用dsl封装回调，使其更方便的处理

写一个简单的dsl，里面参数比较少，可以根据业务需求自行添加参数。

import com.alibaba.fastjson.JSONObject
import com.lt.retrofitdemo.print
/**
 * creator: lt  2020/3/26  lt.dygzs@qq.com
 * effect : 网络请求回调的sdl封装
 * warning:
 */

/**
 * 使用dsl的callback
 * ps: CallBackDsl.()这种语法相当于CallBackDsl的一个扩展函数,把CallBackDsl当做这个函数的this,所以该函数中可以不用this.就可以调用CallBackDsl的参数和方法
 */

inline fun <reified T> callbackOf(initDsl: CallBackDsl<T>.() -> Unit): ObserverCallBack {
    val dsl = CallBackDsl<T>()
    dsl.initDsl()//初始化dsl
    if (dsl.isAutoShowLoading)
        "Show loading dialog".print()
    return object : ObserverCallBack {
        override fun handleResult(data: String?, encoding: Int, method: Int) {
            if (dsl.isAutoShowLoading)
                "Dismiss loading dialog".print()
            //可以在这里根据业务判断是否请求成功
            //引入fastjson来解析json    implementation 'com.alibaba:fastjson:1.2.67'
            val bean = JSONObject.parseObject(data, T::class.java)
            if (bean != null) {
                dsl.mSuccess?.invoke(bean)
            } else {
                dsl.mFailed?.invoke(data)
            }
        }
    }
}

class CallBackDsl<T> {
    /**
     * 网络请求成功的回调
     */
    var mSuccess: ((bean: T) -> Unit)? = null

    fun success(listener: (bean: T) -> Unit) {
        mSuccess = listener
    }

    /**
     * 网络请求失败的回调
     */
    var mFailed: ((data: String?) -> Unit)? = null

    fun failed(listener: (data: String?) -> Unit) {
        mFailed = listener
    }

    /**
     * 是否自动弹出和关闭loading
     */
    var isAutoShowLoading = true

} 

改造后的回调

扩展

其实还有一个Retrofit很常用的功能我没有实现出来，那就是方法的返回值，其实我们实现起来也很简单(当然实现Retrofit那么强很难....)

我们可以使用反射来创建返回值，如下所示。

改造HttpFunctionsHandler.invoke

val returnType = method?.returnType
val newInstance = returnType?.newInstance()
returnType?.fields?.forEach {
      it.set(newInstance, "根据业务逻辑来判断设置什么内容")
}
return newInstance!! 

混淆

如果打开了混淆的话，不配置以下内容会导致运行时报错；如果不开启混淆则可以忽略。

-keepclassmembers public interface com.lt.retrofitdemo.http.HttpFunctions {*;}#防止自定的接口方法名被混淆

-keepclasseswithmembernames public interface com.lt.retrofitdemo.http.ObserverCallBack {*;}#因为使用到了反射,所以回调的类名称也不能被混淆

-keep class kotlin.reflect.jvm.internal.impl.load.java.**{*; }#防止kt反射被混淆

-keep class kotlin.Metadata{*; }#防止kt元注解被混淆 

结语

这样一个网络请求的封装基本就搞定了，声明和调用都很方便。中间由于演示，有很多功能都没有实现或者实现的不完全，大家可以在实现自己的框架的时候可以自行完善，并且可以添加更多的功能。而且这样封装比较灵活,因为具体的逻辑都在HttpFunctionsHandler的startGet和startPost中，所以要更改网络请求的框架或者切换http和Socket很简单。

demo链接如下:

https://github.com/ltttttttttttt/RetrofitDemo