Retrofit的简单封装--更方便的配置okhttp

前言：

Retrofit作为简化HTTP请求的库，已经运行多年，2.0版本依然不辱使命的在做这些事情。不过2.0版本修复了一些长期影响开发者的设计，还加入了前所未有的强大特性。在NYC2015的这一个分享中，Jake Wharton的演讲涵盖了所有Retrofit2.0的新特性，全面介绍了Retrofit2.0工作原理。看我

首先给出官网源码（点我）和基础使用方法（点我）

初始配置就看官网了，废话不多说，开始封装：

一、Api请求网络配置

（1）添加所需要的配置：

public class NetConfig {
    File RESPONSE_CACHE;//缓存文件
    int RESPONSE_CACHE_SIZE;//缓存文件大小
    int CONNET_TIMEOUT;//连接超时
    int READ_TIMEOUT;//读取新链接超时
    int MAX_CACHE_AGE;//从文档被访问后的存活时间
    Context context;

    public NetConfig(File RESPONSE_CACHE,int RESPONSE_CACHE_SIZE,int CONNET_TIMEOUT,int READ_TIMEOUT,int MAX_CACHE_AGE,Context context){
        this.RESPONSE_CACHE = RESPONSE_CACHE;
        this.RESPONSE_CACHE_SIZE = RESPONSE_CACHE_SIZE;
        this.CONNET_TIMEOUT = CONNET_TIMEOUT;
        this.READ_TIMEOUT = READ_TIMEOUT;
        this.MAX_CACHE_AGE = MAX_CACHE_AGE;
        this.context = context;
    }
}

（2）通过构建者模式设置默认初始网络配置

public class NetConfigBuilder {

    private File response_cache;
    private int response_cache_size = 5 * 1024 * 1024;
    private int connect_timeout = 8 * 1000;
    private int read_timeout = 5 * 1000;
    private Context appContext;
    private int maxCacheAge = 0;

    /**
     * request cache-control
     */
    public NetConfigBuilder maxCacheAge(int maxCacheAge) {
        this.maxCacheAge = maxCacheAge;
        return this;
    }

    /**
     * local cache dir
     */
    public NetConfigBuilder responseCacheDir(File response_cache) {
        this.response_cache = response_cache;
        return this;
    }

    /**
     * local cache size
     */
    public NetConfigBuilder responseCacheSize(int response_cache_size) {
        this.response_cache_size = response_cache_size;
        return this;
    }

    /**
     * readTime
     *
     * @param connect_timeout millisecond
     */
    public NetConfigBuilder connectionTimeout(int connect_timeout) {
        this.connect_timeout = connect_timeout;
        return this;
    }

    /**
     * timeout
     *
     * @param read_timeout millisecond
     */
    public NetConfigBuilder readTimeout(int read_timeout) {
        this.read_timeout = read_timeout;
        return this;
    }

    /**
     * must set Context
     */
    public NetConfigBuilder context(Context app) {
        this.appContext = app.getApplicationContext();
        return this;
    }

    public NetConfig createNetConfig() {
        return new NetConfig(response_cache, response_cache_size, connect_timeout, read_timeout, maxCacheAge, appContext);
    }
}

（3）在全局Application中初始化自己配置：

public abstract class NetUtils {
    public static NetConfig netConfig;

    public static void setNetConfig(NetConfig netConfig){
        NetUtils.netConfig = netConfig;
    }

    public static <T> T createApi(Class<T> clazz, String host){
        if(netConfig.context == null)
            throw new IllegalArgumentException("must be set Context,use NetUtils.setNetConfig() at once");
        return RetrofitUtils.createApi(netConfig.context,clazz,host);
    }
}

public class App extends Application{
    private static Context context;

    //获取全局context
    public static Context getContext(){
        return context;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        context = getApplicationContext();

        /**
         * net config
         */
        final NetConfig netConfig = new NetConfigBuilder()
                .context(this)
                .responseCacheDir(new File(context.getCacheDir(),"mycache"))
                .responseCacheSize(1024 * 1024 * 100)
                .readTimeout(2000)
                .createNetConfig();
        NetUtils.setNetConfig(netConfig);
    }
}

二、配置Retrofit和OkHttp

（1）OkHttpUtils可通过设置拦截器等okhttp的初始配置：

public class OkHttpUtils {

    private final static File RESPONSE_CACHE = NetUtils.netConfig.RESPONSE_CACHE;
    private final static int RESPONSE_CACHE_SIZE = NetUtils.netConfig.RESPONSE_CACHE_SIZE;
    private final static int CONNECT_TIMEOUT = NetUtils.netConfig.CONNET_TIMEOUT;
    private final static int READ_TIMEOUT = NetUtils.netConfig.READ_TIMEOUT;
    private static OkHttpClient singleton;

    static OkHttpClient getSingleton(final Context context){
        if(singleton == null){
            synchronized (OkHttpUtils.class){
                if(singleton == null){
                    singleton = new OkHttpClient().newBuilder()
                            .cache(new Cache(RESPONSE_CACHE != null?RESPONSE_CACHE:new File(context.getCacheDir(),"defalut_cache"),RESPONSE_CACHE_SIZE))
                            .addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
                            .connectTimeout(CONNECT_TIMEOUT, TimeUnit.MILLISECONDS)
                            .readTimeout(READ_TIMEOUT, TimeUnit.MILLISECONDS)
                            .build();
                }
            }
        }
        return singleton;
    }

    private static final Interceptor REWRITE_CACHE_CONTROL_INTERCEPTOR = new Interceptor() {
        @Override
        public Response intercept(Interceptor.Chain chain) throws IOException {
            Response originalResponse = chain.proceed(chain.request());
            if (NetUtil.isNetworkAvailable(App.getContext())) {
                int maxAge = 60; // 在线缓存在1分钟内可读取
                return originalResponse.newBuilder()
                        .header("Cache-Control", "public, max-age=" + maxAge)
                        .build();
            } else {
                int maxStale = 60 * 60 * 24 * 28; // 离线时缓存保存4周
                return originalResponse.newBuilder()
                        .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                        .build();
            }
        }
    };
}

（2）RetrofitUtilsze则初始化Retrofit2配置：

public class RetrofitUtils {

    private static Retrofit singleton;

    static <T> T createApi(Context context, Class<T> clazz, String host){
        if(singleton == null){
            synchronized (RetrofitUtils.class){
                if(singleton == null){
                    singleton = new Retrofit.Builder()
                            .baseUrl(host)
                            .addConverterFactory(GsonConverterFactory.create())
                            .client(OkHttpUtils.getSingleton(context))
                            .build();
                }
            }
        }


        return singleton.create(clazz);
    }

}

三、使用

（1）定义接口，封装访问的方法：

public interface AllApi {

    @GET("txapi/mvtp/meinv")
    Call<GrilBean> getGril(@Header("apikey") String key, @Query("num") int num);

}

（2）调用访问的方法：

public class ApiUser {
    public static AllApi get(){
        return NetUtils.createApi(AllApi.class, Constant.url);
    }
}

Call<GrilBean> call = ApiUser.get().getGril(Constant.AES_KEY,12);
call.enqueue(new Callback<GrilBean>() {
    @Override
    public void onResponse(Call<GrilBean> call, Response<GrilBean> response) {
        if (response.isSuccessful()) {
            GrilBean result = response.body();
            //具体操作......
        }
    }

    @Override
    public void onFailure(Call<GrilBean> call, Throwable t) {

    }
});

四、总结

上面只是给出个初始的封装，后续可根据其添加所需配置，源码请看这里

总之，Retrofit解耦的很彻底：比方说通过注解来配置请求参数，通过工厂来生成CallAdapter,Converter，你可以使用不同的请求适配器(CallAdapter)，比方说RxJava,Java8,Guava。你可以使用不同的反序列化工具(Converter)，比方说son,protobuff,xml,moshi等等。所以非常推荐使用。