Retrofit

Retrofit 不算是一个网络库，它应该算是封装了 okhttp ，retrofit的最大特点就是解耦，要解耦就需要大量的设计模式，然后为我们提供了一个友好的接口的一个工具库吧。

 1、创建Retrofit对象：

builder 模式，外观模式（门面模式）

外观模式具有高内聚、低耦合的特性，对外提供简单统一的接口，隐蔽了子系统具体的实现、隔离变化。

在封装某些特定功能时，比如下载module，外观模式是一种很好的设计规范。即下载module与其他module通信时通过DownloadManager对象进行。Retrofit是整个库的一个入口类，Retrofit库的使用基本都是围绕着这个类。

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

2、定义api

public interface StudentApi {

    /**
     * 学生列表 for age
     */
    @POST("/student/studentList")
    Observable<List<Student>> selectStudentListForAge(@Field("age") int age);

}

获取 API 实例：通过动态代理模式：使用动态代理，因为对接口的所有方法的调用都会集中转发到 InvocationHandler#invoke 函数中，我们可以集中进行处理，更方便了。

// 在请求，初始化StudentApi 
StudentApi  mStudentApi = retrofit.create(StudentApi.class);

调用create()方法，通过 Proxy 类静态函数生成代理对象StudentApi并返回:

  Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h);  

loader表示类加载器
interfaces表示委托类的接口，生成代理类时需要实现这些接口
h是InvocationHandler实现类对象，负责连接代理类和委托类的中间类

关于动态代理的详细介绍，可以查看 codeKK 公共技术点之 Java 动态代理、动态代理以及利用动态代理实现servicehook。

// 调用其方法时，调用了Retrofit的动态代理的InvocationHandler对象MethodHandler对象
 mStudentApi.selectStudentListForAge(18)....;

执行该方法后，调用了InvocationHandler对象的invoke方法。

在invoke方法上，处理并返回一个http请求对象，在此，还可以做些有用的操作，例如统计执行时间、进行初始化和清理、对接口调用进行检查等。

// 调用代理对象的每个函数实际最终都是调用了InvocationHandler的invoke函数
@Override
public Object invoke(Object proxy, Method method, Object[] args)

proxy 通过 Proxy.newProxyInstance() 生成的代理类对象。
method 表示代理对象被调用的函数。
args 表示代理对象被调用的函数的参数。

1、当执行subscribe的时候，整个http请求执行。

2、调用

mStudentApi.selectStudentListForAge(18)

返回对象的execute()或enqueue(Callback<T> callback)方法，就能发送一个Http请求了：

mStudentApi.selectStudentListForAge(18)
.observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<List<Student>>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        
                    }

                    @Override
                    public void onNext(List<Student> studentList) {
                         
                    }
                }));

 熟练使用annotation、reflect，造一个retrofit雏形。

定义post、get、field等：

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Documented
@Target(METHOD)
@Retention(RUNTIME)
public @interface POST {
    String value() default "";

    boolean requestSync() default false;
}

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Documented
@Target(METHOD)
@Retention(RUNTIME)
public @interface GET {
    String value() default "";
}

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Documented
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Field {
    String value();

    boolean encoded() default false;
}

创建BaseRetrofit对象，作为基类，其子类继承并重写createApi方法，在方法中，创建并配置retrofit对象。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public abstract class BaseRetrofit {

        // http请求
    SimpleRepository repository;

    public <T> T create(Class<T> clazz) {
               // 可做缓存对象操作
        T t = createApi(clazz);
        return t;
    }

    protected abstract <T> T createApi(Class<T> clazz);

    protected RepositoryProxy.Builder getProxyBuilder(){
        return new RepositoryProxy.Builder(){
            @Override
            public RepositoryProxy build() {
                RepositoryProxy proxy = super.build();

                setRepository(proxy.getRepository());

                return proxy;
            }
        };
    }

        protected void setRepository(SimpleRepository repository) {
        this.repository = repository;
    }

    public SimpleRepository getRepository() {
        return repository;
    }

｝

创建子类：使用时，new StudentRetrofit().create(StudentApi.class)；生成动态代理类，通过RepositoryProxy 代理操作。

public class StudentRetrofit extends BaseRetrofit {

    @Override
    protected  <T> T createApi(Class<T> clazz) {
        RepositoryProxy retrofit = getProxyBuilder().baseurl("http://www.baidu.com")
                                                    .build();

        return retrofit.create(clazz);
    }
}

RepositoryProxy 代理操作：

public class RepositoryProxy {

    public <T> T create(Class<T> clazz) {
        if (!clazz.isInterface()) {
            throw new RuntimeException("retrofit Service not interface");
        }

        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new ApiProxy(this));
    }

｝

InvocationHandler对象：

public class ApiProxy implements InvocationHandler {

@Override
    public Object invoke(Object proxy, Method method, Object... args) throws Throwable {

        // If the method is a method from Object then defer to normal invocation.
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(this, args);
        }
        
        // 返回http请求对象
        return post(method, args);
    }

｝

附录

retrofit官方文档
用 Retrofit 2 简化 HTTP 请求
使用Retrofit请求API数据
Retrofit2 更新指南
RESTful API 设计指南

Android Retrofit 2.0使用

Android Retrofit 2.0 使用-补充篇

Retrofit源码设计模式解析上

Retrofit源码设计模式解析下

使用Retrofit请求API数据－codepath教程

Retrofit源码解析

Retrofit 源码的一个分析与导读