第一步引入我们的OkHttp的依赖

   //ok依赖
    implementation 'com.squareup.okhttp3:okhttp:3.2.0'
//ok 日志的拦截器
    implementation 'com.squareup.okhttp3:logging-interceptor:3.12.0'
    //retrofit+RXjava
    implementation 'com.squareup.retrofit2:retrofit:2.3.0'//导入retrofit
    implementation 'com.google.code.gson:gson:2.6.2'//Gson 库
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
    implementation 'io.reactivex.rxjava2:rxjava:2.x.y'
    implementation 'com.squareup.retrofit2:converter-gson:2.3.0'//转换器，请求结果转换成//Model
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'//配合Rxjava 使用

依赖引入完成之后我们就可以进行我们的Retrofit+OkHttp的二次封装

public class NetUtils {
	String url="";//这里是域名
    private ApiService apiService;

    public NetUtils(){
        initModel();
    }
    private static class Coallack{
        private static final NetUtils NET_UTILS=new NetUtils();
    }
    public static NetUtils getInstance(){
        return Coallack.NET_UTILS;
    }
    private void initModel() {
        HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
        httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        OkHttpClient builder = new OkHttpClient.Builder()
                .connectTimeout(30, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .writeTimeout(30, TimeUnit.SECONDS)
                .addNetworkInterceptor(httpLoggingInterceptor)
                .addNetworkInterceptor(new MyHead())//添加请求头 如果后台给的不是请求头请求 完全可以删除这段代码
                .build();

        Retrofit build1 = new Retrofit.Builder()
        .baseUrl(url)
        .client(builder)
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .addConverterFactory(GsonConverterFactory.create())
        .build();
        apiService = build1.create(ApiService.class); //ApiService就是我们Retrofit接口
    }
//请求头
    private class MyHead implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            //获取token 
            String token=""; //token是用来存入本地的 所以看你怎么拿token信息  
            if(TextUtils.isEmpty(token)){
                return chain.proceed(request);
            }
            Request build = request.newBuilder().addHeader("", "").build();
            return chain.proceed(build);
        }
    }
}

在这里强调一下 addInterceptor和addNetworkInterceptor的区别

addInterceptor添加应用拦截器

 ● 不需要担心中间过程的响应,如重定向和重试.

 ● 总是只调用一次,即使HTTP响应是从缓存中获取.

 ● 观察应用程序的初衷. 不关心OkHttp注入的头信息如: If-None-Match.

 ● 允许短路而不调用 Chain.proceed(),即中止调用.

 ● 允许重试,使 Chain.proceed()调用多次.

addNetworkInterceptor 添加网络拦截器
 ● 能够操作中间过程的响应,如重定向和重试.

 ● 当网络短路而返回缓存响应时不被调用.

 ● 只观察在网络上传输的数据.

 ● 携带请求来访问连接.
 

>  而我们使用addInterceptor这个时候呢我们的程序就不会崩溃但是我们的onNext中的log日志不打印 
> 我们使用addNetworkInterceptor日志就会正常打印

为什么我们网络请求会使用静态内部类的方式呢
静态内部类的好处：是采用了类加载机制来保证创建一个instance实力它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题不一样的是，它是在内部类里面去创建对象实例。
这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全