Android Retrofit 2 + Retrofit 2

实现MVC基础框架
实现MVP基础框架（一）
Android Retrofit 2 + Retrofit 2 封装（二）
实现Retrofit2.0 + RxJava2.0 + MVP框架（三）
一、Base实体类

public class BaseModel<T> {
    private int errorCode;
    private String errorMessage;
    private T results;

    public int getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(int errorCode) {
        this.errorCode = errorCode;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public void setErrorMessage(String errorMessage) {
        this.errorMessage = errorMessage;
    }

    public T getResults() {
        return results;
    }

    public void setResults(T results) {
        this.results = results;
    }
}

二、Retrofit2的封装
（1）网络请求封装接口

public interface Request_Interface {
    String HOST = "http://服务器地址.com/";

    @POST()
    Observable<BaseModel> postBody(@Url String url, @Body RequestBody body);

    @POST()
    Observable<String> postBody(@Url String url);
}

（2）封装网络请求拦截器、日志拦截器以及必要的参数初始化

public class RetrofitApi {
    private static Retrofit retrofit;
    private static final int DEFAULT_TIMEOUT = 10;//超时时间
    private static volatile Request_Interface request_interface = null;

    /**
     * 创建网络请求接口实例
     *
     * @return
     */
    public static Request_Interface getRequestInterface() {
        if (request_interface == null) {
            synchronized (Request_Interface.class) {
                request_interface = provideRetrofit().create(Request_Interface.class);
            }
        }
        return request_interface;
    }

    /**
     * 初始化必要对象和参数
     *
     * @return
     */
    private static Retrofit provideRetrofit() {
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .addInterceptor(getHttpLoggingInterceptor())//Application拦截器
                .addNetworkInterceptor(getRequestHeader())//Network拦截器
                .build();
        retrofit = new Retrofit.Builder()
                .baseUrl(Request_Interface.HOST)//设置网络请求的Url地址
                .addConverterFactory(GsonConverterFactory.create())//设置数据解析器
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//支持RxJava平台
                .client(client)
                .build();
        return retrofit;
    }

    /**
     * 日志拦截器
     *
     * @return
     */
    private static HttpLoggingInterceptor getHttpLoggingInterceptor() {
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                Log.e("OkHttpLog", "log = " + message);
            }
        });
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        return loggingInterceptor;
    }

    /**
     * 请求头拦截器
     *
     * @return
     */
    private static Interceptor getRequestHeader() {
        Interceptor headerInterceptor = new Interceptor() {
            @Override
            public okhttp3.Response intercept(Chain chain) throws IOException {
                okhttp3.Request originalRequest = chain.request();
                okhttp3.Request.Builder builder = originalRequest.newBuilder();
                builder.addHeader("Content-Type", "application/json; charset=utf-8");
                builder.addHeader("token", "d08986536b5e3678119aac9b892439a8");
                okhttp3.Request.Builder requestBuilder = builder.method(originalRequest.method(), originalRequest.body());
                okhttp3.Request request = requestBuilder.build();
                return chain.proceed(request);
            }
        };
        return headerInterceptor;
    }
}

（3）创建BaseObserver类：请求错误的封装和进度条显示与消失的封装

public abstract class BaseObserver<T extends BaseModel> implements Observer<T> {
    private Activity activity;

    public BaseObserver(Activity activity) {
        this.activity = activity;
        CommonDialogUtils.showDialog(activity);
    }

    public BaseObserver(Activity activity, boolean isShowLoading) {
        this.activity = activity;
        if (isShowLoading) {
            CommonDialogUtils.showDialog(activity, "Loading...");
        }
    }

    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(T t) {
        CommonDialogUtils.dismissDialog();
        if (t.getErrorCode() == 200) {
            onSuccess(t);
        } else {
            onFail(t);
        }
    }

    @Override
    public void onError(Throwable e) {
        CommonDialogUtils.dismissDialog();
        if (e instanceof HttpException) {     //   HTTP错误
            onException(ExceptionReason.BAD_NETWORK);
        } else if (e instanceof ConnectException
                || e instanceof UnknownHostException) {   //   连接错误
            onException(CONNECT_ERROR);
        } else if (e instanceof InterruptedIOException) {   //  连接超时
            onException(CONNECT_TIMEOUT);
        } else if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException) {   //  解析错误
            onException(PARSE_ERROR);
        } else {
            onException(UNKNOWN_ERROR);
        }
    }

    @Override
    public void onComplete() {

    }

    public abstract void onSuccess(T response);

    public void onFail(T response) {
        String message = response.getErrorMessage();
        if (TextUtils.isEmpty(message)) {
            ToastUtils.showToast(R.string.unknown_error);
        } else {
            ToastUtils.showToast(message);
        }
    }

    /**
     * 网络请求异常
     *
     * @param reason
     */
    public void onException(ExceptionReason reason) {
        switch (reason) {
            case BAD_NETWORK:
                ToastUtils.showToast(R.string.bad_network);
                break;
            case CONNECT_ERROR:
                ToastUtils.showToast(R.string.connect_error);
                break;
            case CONNECT_TIMEOUT:
                ToastUtils.showToast(R.string.connect_timeout);
                break;
            case PARSE_ERROR:
                ToastUtils.showToast(R.string.parse_error);
                break;
            case UNKNOWN_ERROR:
            default:
                ToastUtils.showToast(R.string.unknown_error);
                break;
        }
    }

    /**
     * 网络请求失败原因
     */
    public enum ExceptionReason {
        //网络问题
        BAD_NETWORK,
        //连接错误
        CONNECT_ERROR,
        //连接超时
        CONNECT_TIMEOUT,
        //解析数据失败
        PARSE_ERROR,
        //未知错误
        UNKNOWN_ERROR,
    }
}

（4）进度条显示封装

public class CommonDialogUtils {
    private static CommonDialog commonDialog = null;

    public static void showDialog(Activity activity) {
        commonDialog = new CommonDialog(activity, R.style.common_dialog);
        Window window = commonDialog.getWindow();
        WindowManager.LayoutParams lp = window.getAttributes();
        lp.width = WindowManager.LayoutParams.WRAP_CONTENT;
        lp.height = WindowManager.LayoutParams.WRAP_CONTENT;
        window.setAttributes(lp);
        commonDialog.setCanceledOnTouchOutside(false);
        commonDialog.show();
    }

    public static void showDialog(Activity activity, String name) {
        commonDialog = new CommonDialog(activity, R.style.common_dialog);
        Window window = commonDialog.getWindow();
        WindowManager.LayoutParams lp = window.getAttributes();
        lp.width = WindowManager.LayoutParams.WRAP_CONTENT;
        lp.height = WindowManager.LayoutParams.WRAP_CONTENT;
        window.setAttributes(lp);
        commonDialog.setCanceledOnTouchOutside(false);
        commonDialog.show();
    }

    public static void dismissDialog() {
        if (commonDialog != null) {
            commonDialog.dismiss();
        }
    }
}

（5）自定义进度条

public class CommonDialog extends Dialog {
    private Context context;

    public CommonDialog(@NonNull Context context) {
        super(context);
    }

    public CommonDialog(@NonNull Context context, int themeResId) {
        super(context, themeResId);
        this.context = context;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View layout = inflater.inflate(R.layout.common_dialog_utils, null);
        this.setContentView(layout);
    }
}