封装okhttp

import android.content.Context;
import android.os.Handler;
import android.os.Looper;

import com.google.gson.Gson;

import java.io.IOException;
import java.util.Map;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;

import okhttp3.Response;

public class OkHttpUtils {
    private Context context;
    private static OkHttpUtils okHttpUtils;
    private final Gson gson;
    private final OkHttpClient client;
    private final Handler handler;

    private OkHttpUtils() {
    

//        client = new OkHttpClient();
//        gson = new Gson();
//        //构造一个handler，不管是从哪个哪个线程中发出消息，
//        // 消息都会发送到主线程的messagequeue中
//        handler = new Handler(Looper.getMainLooper());
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    builder.addInterceptor(new LoggingIntercepto());
    client = builder.build();
    gson = new Gson();
   //构造一个handler，不管是从哪个哪个线程中发出消息，
   // 消息都会发送到主线程的messagequeue中
    handler = new Handler(Looper.getMainLooper());

    }

    public static OkHttpUtils getInstace() {

        if (okHttpUtils == null) {
            synchronized (OkHttpUtils.class) {
                if (okHttpUtils == null) {
                    okHttpUtils = new OkHttpUtils();
                }
            }
        }
        return okHttpUtils;
    }

    public void doGet(String url,MyHttpCallback callback){
        Request request= new Request.Builder().url(url).get().build();
        doRequest(request,callback);
    }
    //post方法. username  password
    public void doPost(String url, Map<String ,String> params, MyHttpCallback  callback){
        FormBody.Builder formBuilder=new FormBody.Builder();
        if(params!=null){
            for (Map.Entry<String,String> entry:params.entrySet()) {
                formBuilder.add(entry.getKey(),entry.getValue());
            }
        }
        RequestBody body=formBuilder.build();
        Request.Builder builder =new Request.Builder().url(url).post(body).addHeader("User-Agent", "OkHttp Example");//拦截器
        Request request = builder.build();
        doRequest(request,callback);
    }



    private void doRequest(Request request, final MyHttpCallback callback) {
        callback.onBeforeRequest(request);
        client.newCall(request).enqueue(new Callback() {
            //这些okhttp的回调方法执行在子线程里面，返回的数据为了给主线程使用，
            // 必须想办法把数据供给主线程使用，所以引用了自定义的回调接口
            @Override
            public void onFailure(final Call call, final IOException e) {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onFailure(call,e);
                    }
                });
            }
            @Override
            public void onResponse(Call call,final Response response) throws IOException {
                if(response.isSuccessful()){
                    //返回数据成功的话就解析json串
                    String json=response.body().string();
                    final Object o=gson.fromJson(json,callback.type);//将json解析成对应的bean
                    //handler 除了可以发送Message 也可以发送 runnable对象
                    //这个runnable对象的run方法就执行在 handler对应的线程中 当前的案例中 会执行在主线程中
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            //将response返回给主线程
                            try {
                                callback.onSuccess(response,o);
                            } catch (IOException e) {
                                e.printStackTrace();
                            }

                        }
                    });
                }else{
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                callback.onError(response,"服务器返回错误");
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    });
                }
            }
        });
    }
}

//回调接口

import com.google.gson.internal.$Gson$Types;
import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import okhttp3.Call;
import okhttp3.Request;
import okhttp3.Response;

public abstract class MyHttpCallback<T> {
    Type type;
    static Type getSuperclassTypeParameter(Class<?> subclass){
        Type superclass =subclass.getGenericSuperclass();
        if(superclass instanceof Class){
            throw new RuntimeException("Missing type parameter");

        }
        ParameterizedType parameterized=(ParameterizedType)superclass;
        return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
    }
    public MyHttpCallback(){
        type=getSuperclassTypeParameter(getClass());
    }
    public abstract void onBeforeRequest(Request request);
    public abstract void onFailure(Call call, IOException e);
    public abstract void onSuccess(Response response, T t) throws IOException;
    public abstract void onError(Response response,String errorMsg) throws IOException;
}

//拦截器类

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;

public class LoggingIntercepto implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        long t1 = System.nanoTime();
        System.out.println(String.format("Sending request %s on %s%n%s", request.url(),
                chain.connection(), request.headers()));

        Response response = chain.proceed(request);
        long t2 = System.nanoTime();
        System.out.println(String.format("Received response for %s in %.1fms%n%s",
                response.request().url(), (t2 - t1) / 1e6d, response.headers()));
        return response;
    }
}

//使用方法 MVP使用

M层

public class Model_A {
    private SS ss;
    public interface  SS{
        void Success(Shop shop);
    }
    public void setSs(SS ss) {
        this.ss = ss;
    }
    public void news(String url) {
        OkHttpUtils.getInstace().doGet(url, new MyHttpCallback<Shop>() {
            @Override
            public void onBeforeRequest(Request request) {
            }

            @Override
            public void onFailure(Call call, IOException e) {
            }

            @Override
            public void onSuccess(Response response, Shop shop) throws IOException {
                 ss.Success(shop);
            }
            @Override
            public void onError(Response response, String errorMsg) throws IOException {

            }
        });
    }
}
V层
public interface View_A {
    void Success(Shop shop);
}
 P层
public class Presenter_A implements Model_A.SS {
    private Model_A model_a;
    private View_A view_a;

    public Presenter_A(View_A view_a) {
        this.view_a = view_a;
        model_a=new Model_A();
        model_a.setSs(this);
    }
    public void shop(String url){
        model_a.news(url);
    }
    @Override
    public void Success(Shop shop) {
        view_a.Success(shop);
    }
}
Fragment里调用的接口
继承view层
实例化p层
pa=new Presenter_A(this);
pa.shop(Api.GOUWU);
@Override
public void Success(Shop shop) {
    try{
        final List<Shop.DataBean> data = shop.getData();
        getActivity().runOnUiThread(new Runnable() {
            @Override
            public void run() {
                sa=new ShopOneAdapter(getActivity(),data);
                rv.setLayoutManager(new LinearLayoutManager(getActivity()));
                rv.setAdapter(sa);
            }
        });
    }catch (Exception e){
        e.printStackTrace();
    }
}