Android读取缓存的入门教学 专为新手制作

package com.example.day_5_intent_lanjieqi;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.util.Log;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
import okhttp3.Cache;
import okhttp3.CacheControl;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.http.GET;

/**
 * Created by DELL on 2018/7/3.
 */

public class MyInterceptor {
    public static Context context;

    public MyInterceptor(Context context) {
        this.context=context;
    }
    public void interceptor(){
        Retrofit.Builder builder = new Retrofit.Builder();
        OkHttpClient.Builder builder1 = new OkHttpClient.Builder();
        File file = new File(context.getCacheDir(),"cache");
        //高速缓存
        Cache cache = new Cache(file,1024*1024*10);
        OkHttpClient okHttpClient = builder1.connectTimeout(5, TimeUnit.SECONDS)
                .writeTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .cache(cache)
                .addInterceptor(new LogIntertor())
                .addInterceptor(new CacheInterceptis())
                .addNetworkInterceptor(new LogIntertor())
                .build();
        Retrofit retrofit = builder.baseUrl(Myserver.url)
                .client(okHttpClient)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
        Myserver myserver = retrofit.create(Myserver.class);
        Observable<ResponseBody> observable = myserver.getData();
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<ResponseBody>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(ResponseBody responseBody) {
                try {
                    Log.e("MyInterceptor", responseBody.string());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.e("MyInterceptor", e.getMessage());
            }

            @Override
            public void onComplete() {

            }
        });


    }
    interface Myserver{
        public  final String url="http://gank.io/api/xiandu/";
        public  final String url12="http://www.baidu.com";
        @GET("categories")
        Observable<ResponseBody> getData();
    }
    //日志拦截器
    static class LogIntertor implements okhttp3.Interceptor {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Log.e("LogIntertor", request.url() + "\n头信息" + request.toString());
            request = request.newBuilder()
                    .url(Myserver.url12)
                    .get()
                    .header("User-Agent", "zq")
                    .build();
            Response response = chain.proceed(request);
            ResponseBody responseBody = response.peekBody(1024 * 1024);
            Log.e("LogIntertor", "拦截器" + responseBody.string());
            return response;
        }
    }
        static class CacheInterceptis implements Interceptor{

            @Override
            public Response intercept(Chain chain) throws IOException {
                //获取请求对象
                Request request = chain.request();
                if (!isNetworkConnected()){
                    request=request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
                }
                Response response = chain.proceed(request);
                if (isNetworkConnected()){
                    return response;
                }

                return response.newBuilder()
                        .header("Cache-Control","public,only-if-cached,max-stale=15")
                        .removeHeader("Pragma")
                        .removeHeader("Cache-Control")
                        .build();
            }
        }
        public static boolean isNetworkConnected(){
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
            if (networkInfo!=null){
                return networkInfo.isAvailable();
            }
            return false;
        }

}