retrofit_rxjava_okhttp封装类

Retrofit+Rxjava+OkHttp 单例模式+双重锁模式 封装类

package com.app.mvp.retrofit_rxjava_okhttp;

import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

/**
 * Retrofit+Rxjava+OkHttp 单例模式+双重锁模式 封装类
 */
public class RetrofitUnitl {
    private Retrofit mRetrofit;
    private String baseUrl;
    OkHttpClient client;
    private static RetrofitUnitl mRetrofitManager;
    private RetrofitUnitl(String baseUrl,OkHttpClient client){
        this.baseUrl=baseUrl;
        this.client=client;
        initRetrofit();
    }

    //单例模式+双重锁模式 封装方法
    public static synchronized RetrofitUnitl getInstance(String baseUrl,OkHttpClient client){
        if (mRetrofitManager == null){
            mRetrofitManager = new RetrofitUnitl(baseUrl,client);
        }
        return mRetrofitManager;
    }

    //实例化Retrofit请求
    private void initRetrofit() {
        mRetrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .client(client)
                .build();
    }

    //封装泛型方法
    public  T setCreate(Class reqServer) {
        return mRetrofit.create(reqServer);
    }
}

拦截器

package com.app.mvp.retrofit_rxjava_okhttp;

import java.io.IOException;
import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;

//自定义添加公共请求参数的拦截器
public class LoggingInterceptor implements Interceptor {
  @Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();

    //开始响应的时间
    long t1 = System.nanoTime();
    //执行请求，返回响应的数据
    Response response = chain.proceed(request);
    //请求结束，响应返回
    long t2 = System.nanoTime();

    //响应的耗费时间
    System.out.println(" this request  url  " + response.request().url() + "  "  + (t2 - t1)/1000000);

    return response;
  }
}

IGetDataBase

package com.app.mvp.retrofit;

import com.app.mvp.bean.Bean;
import io.reactivex.Observable;
import retrofit2.http.GET;
import retrofit2.http.Query;

/**
 * 网络接口数据的请求类
 * 接口： http://api.tianapi.com/military/?key=71e58b5b2f930eaf1f937407acde08fe&num=10
 */
public interface GetDataInterface {
    /*
     * 使用Observable被观察者模式下的的get请求数据 @Query注解传递参数
     */
    @GET("/military/?key=18e883dd6b316eb1d97fd86338abbf06&num=10")
    Observable getData(@Query("key") String key,@Query("num") int num);

}

mymodel

package com.app.mvp.model;

import com.app.mvp.bean.Bean;
import com.app.mvp.retrofit.GetDataInterface;
import com.app.mvp.retrofit_rxjava_okhttp.LoggingInterceptor;
import com.app.mvp.retrofit_rxjava_okhttp.RetrofitUnitl;
import java.util.concurrent.TimeUnit;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import okhttp3.OkHttpClient;

//model接口实现类
public class MyModel {
    /**
     * 使用Retrofit结合RxJava的get请求数据，使用@Query注解传递参数
     * @param callBack
     */
    public void getData(final ModelCallBack callBack) {
        //使用okhttp请求,添加拦截器时把下面代码解释
        OkHttpClient ok = new OkHttpClient.Builder()
                .connectTimeout(20000, TimeUnit.SECONDS)
                .writeTimeout(20000,TimeUnit.SECONDS)
                .readTimeout(20000,TimeUnit.SECONDS)
                .addInterceptor(new LoggingInterceptor())
                .build();

        //使用Retrofit结合RxJava，okhttp封装类的单例模式
        RetrofitUnitl.getInstance("http://api.tianapi.com",ok)
                .setCreate(GetDataInterface.class)
                .getData("71e58b5b2f930eaf1f937407acde08fe",18)
                .subscribeOn(Schedulers.io())               //请求完成后在io线程中执行
                .observeOn(AndroidSchedulers.mainThread())  //最后在主线程中执行

                //进行事件的订阅，使用Consumer实现
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Bean bean) throws Exception {
                        //请求成功时返回数据
                        callBack.onSuccess(bean);
                        System.out.println(bean.toString());
                    }
                });
    }

}