网络请求类

MyApp

package com.lmx.shopcar.retrofit;

import android.app.Application;

import com.uuzuche.lib_zxing.activity.ZXingLibrary;

public class MyApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ZXingLibrary.initDisplayOpinion(this);
    }
}

HeadInteceptor

package com.lmx.shopcar.retrofit;

import android.content.Context;
import android.content.SharedPreferences;

import com.lmx.shopcar.MyApp;

import java.io.IOException;

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

/**
 * Author：草莓味的Name
 * Time：2019/6/12  20:15
 * 文件描述：
 */
public class HeadInteceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        SharedPreferences sp = MyApp.mContext.getSharedPreferences("wenjian", Context.MODE_PRIVATE);
        String sessionId = sp.getString("sessionId", "");
        String userId = sp.getString("userId", "");
        Request request = chain.request();
        Request.Builder builder = request.newBuilder();
        builder.addHeader("userId",userId);
        builder.addHeader("sessionId",sessionId);
        Request build = builder.build();
        Response proceed = chain.proceed(build);
        return proceed;
    }
}

Apis

package com.lmx.shopcar.retrofit;

import retrofit2.http.GET;

public class Apis {
//   public static String order_form_url="http://172.17.8.100/";
   public static String order_form_url="http://mobile.bwstudent.com/";
}

ObservedApis

package com.lmx.shopcar.retrofit;

import java.util.Map;

import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.http.Body;
import retrofit2.http.DELETE;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.Header;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.PUT;
import retrofit2.http.Part;
import retrofit2.http.QueryMap;
import retrofit2.http.Url;
import rx.Observable;

public interface ObservedApis {
    @POST
    @FormUrlEncoded
    Observable<ResponseBody> post(@Url String url, @FieldMap Map<String, String> map);

    //@Body RequestBody file
    @POST
    Observable<ResponseBody> postUpdatePhoto(@Url String url, @Body RequestBody file);

    @POST
    @FormUrlEncoded
    Observable<ResponseBody> postCreateOrder(@Url String url, @FieldMap Map<String, Object> map);

    @POST
    @Multipart
    @FormUrlEncoded
    Observable<ResponseBody> postMineCircle(@Url String url, @FieldMap Map<String, Object> map, @Part MultipartBody.Part[] parts);

    @POST
    @Multipart
    Observable<ResponseBody> postEvaluate(@Url String url, @QueryMap Map<String, Object> map, @Part MultipartBody.Part[] parts);

    @POST
    @Multipart
    Observable<ResponseBody> postIssueCircle(@Url String url, @QueryMap Map<String, Object> map, @Part MultipartBody.Part[] parts);

    @GET
    Observable<ResponseBody> syncGet(@Url String url, @Header("userId") String userid, @Header("sessionId") String sessionId);

    @PUT
    Observable<ResponseBody> put(@Url String url, @QueryMap Map<String, String> map, @Header("userId") String userid, @Header("sessionId") String sessionId);

    @PUT
    Observable<ResponseBody> putUpdateAddress(@Url String url, @QueryMap Map<String, Object> map);

    @GET
    Observable<ResponseBody> get(@Url String url);

    @DELETE
    Observable<ResponseBody> delete(@Url String url);

    @POST
    Observable<ResponseBody> postPayment(@Url String url);

    @PUT
    Observable<ResponseBody> putConsignee(@Url String url);

    @PUT
    Observable<ResponseBody> putUpdatePwd(@Url String url, @QueryMap Map<String, String> map);
}

RetrofitOkHttp

package com.lmx.shopcar.retrofit;

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

import com.google.gson.Gson;
import com.lmx.shopcar.login_fragment.Login;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import retrofit2.http.Header;
import rx.Observer;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

import static android.support.constraint.Constraints.TAG;

public class RetroFitOkHttp {
    //传递头参
    private Map<String, String> headMap = new HashMap<>();

    public RetroFitOkHttp setHead(Map<String, String> headMap) {
        this.headMap = headMap;
        return this;
    }

    private Handler handler;
    private OkHttpClient client;
    private ObservedApis observedApis;
    private String userId1;
    private String sessionId1;

    public RetroFitOkHttp() {
        initRetrofut();
    }

    private static class RetroFitOkHttpHolder {
        private static RetroFitOkHttp instance = new RetroFitOkHttp();
    }

    public static RetroFitOkHttp getInstance() {
        return RetroFitOkHttpHolder.instance;
    }

    private boolean isNet(Context context) {
        if (context != null) {
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            if (networkInfo != null) {
                return networkInfo.isAvailable();
            }
        }
        return false;
    }

    private void initRetrofut() {
        handler = new Handler();
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.writeTimeout(10, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.SECONDS)
                .connectTimeout(30, TimeUnit.SECONDS)
                .addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
                .addInterceptor(new HeadInteceptor())
                .retryOnConnectionFailure(true);
        client = builder.build();
        Retrofit.Builder retrofit = new Retrofit.Builder()
                .baseUrl(Apis.order_form_url)
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .client(this.client);
        Retrofit build = retrofit.build();
        observedApis = build.create(ObservedApis.class);
    }

    public void doGetHeader(String url, String userid, String sessionid, CallBack callBack) {
        observedApis.syncGet(url, userid, sessionid)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));

    }

    public void doPostUpdatePhoto(String url, RequestBody file, CallBack callBack) {

        observedApis.postUpdatePhoto(url, file)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }

    public void doPost(String url, Map<String, String> map, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        observedApis.post(url, map)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }

    public void doPostEvaluate(String url, Map<String, Object> map, List<File> list, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        MultipartBody.Part[] parts = new MultipartBody.Part[list.size()];
        int index = 0;
        for (File file : list) {
            RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
            MultipartBody.Part filePart = MultipartBody.Part.createFormData("image", file.getName(), requestBody);
            parts[index] = filePart;
            index++;
        }
        observedApis.postEvaluate(url, map, parts)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }

    public void doPostIssueCircle(String url, Map<String, Object> map, List<File> list, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        MultipartBody.Part[] parts = new MultipartBody.Part[list.size()];
        int index = 0;
        for (File file : list) {
            RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
            MultipartBody.Part filePart = MultipartBody.Part.createFormData("image", file.getName(), requestBody);
            parts[index] = filePart;
            index++;
        }
        observedApis.postIssueCircle(url, map, parts)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }
    public void doPostMineCircle(String url, Map<String, Object> map, List<File> list, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        MultipartBody.Part[] parts = new MultipartBody.Part[list.size()];
        int index = 0;
        for (File file : list) {
            RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
            MultipartBody.Part filePart = MultipartBody.Part.createFormData("image", file.getName(), requestBody);
            parts[index] = filePart;
            index++;
        }
        observedApis.postMineCircle(url, map, parts)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }
    public void doPut(String url, Map<String, String> map, @Header("userId") String userid, @Header("sessionId") String sessionId, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        Log.d(TAG, "doPut: " + map.get("data"));
        observedApis.put(url, map, userid, sessionId)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }

    public void doPutUpdateAddress(String url, Map<String, Object> map, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        Log.d(TAG, "doPut: " + map.get("data"));
        observedApis.putUpdateAddress(url, map)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }

    public void doGet(String url, CallBack callBack) {
        observedApis.get(url)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }

    public void doDelete(String url, CallBack callBack) {
        observedApis.delete(url)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));

    }

    public void doPostPayment(String url, CallBack callBack) {
        observedApis.postPayment(url)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));

    }

    public void doPutConsignee(String url, CallBack callBack) {
        observedApis.putConsignee(url)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));

    }

    public void doPutUpdatePwd(String url, Map<String, String> map, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        observedApis.putUpdatePwd(url, map)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));

    }

    public void doPostCreateorder(String url, Map<String, Object> map, CallBack callBack) {
        if (map == null) {
            map = new HashMap<>();
        }
        observedApis.postCreateOrder(url, map)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserve(callBack));
    }

    public Observer getObserve(final CallBack callBack) {
        Observer<ResponseBody> observer = new Observer<ResponseBody>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                if (callBack != null) {
                    callBack.onFail("error+RetrofitOkHttp" + e.getMessage().toString());
                    Log.i(TAG, "onError: " + e.getMessage().toString());
                }
            }

            @Override
            public void onNext(ResponseBody responseBody) {
                try {
                    String string = responseBody.string();
                    if (callBack != null) {
                        callBack.onSuccess(string);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        };
        return observer;
    }

    CallBack callBack;

    public void result(CallBack callBack) {
        this.callBack = callBack;
    }

    public interface CallBack {
        void onSuccess(String str);

        void onFail(String str);
    }
}

加粗样式