好用的retrofit2请求封装类

package com.nbniu.app.common.tool;

import android.content.Context;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

/**
 * 请求回调封装
 */
public abstract class Request<T> {

    private Call<T> request;

    private Context context;

    public Request(Call<T> request) {
        this(request, null);
    }

    public Request(Call<T> request, Context context) {
        this.request = request;
        this.context = context;
    }

    public void setContext(Context context) {
        this.context = context;
    }

    /**
     * 执行请求
     */
    public void execute() {
        request.enqueue(new Callback<T>() {
            @Override
            public void onResponse(Call<T> call, Response<T> response) {
                if (!dispose(call, response))
                    onError(call, response);

                mustDo();
            }

            @Override
            public void onFailure(Call<T> call, Throwable t) {
                if (call.isCanceled())
                    return;

                Request.this.onFailure(call, t);
                mustDo();
            }
        });
    }

    /**
     * 处理请求，返回处理结果，处理失败就执行失败动作.
     * @param call
     * @param response
     * @return
     */
    public abstract boolean dispose(Call<T> call, Response<T> response);

    /**
     * 处理失败后动作
     * @param call
     * @param response
     */
    public abstract void onError(Call<T> call, Response<T> response);

    /**
     * 请求失败后动作，默认执行失败动作并提示提示请求服务器失败
     * @param call
     * @param t
     */
    public void onFailure(Call<T> call, Throwable t){
        t.printStackTrace();
        Notify.toast(context, JSONTool.REQUEST_SERVER_ERROR);
    }

    /**
     * 不管请求成功失败，必须执行
     */
    public void mustDo(){}
}

使用示例：

new Request<Order>(call) {
            @Override
            public boolean dispose(Call<Order> call, Response<Order> response) {
                if (response.body() != null) {
                    order = response.body();
                    runOnUiThread(() -> {
                        setData();
                    });
                    return true;
                }
                return false;
            }

            @Override
            public void onError(Call<Order> call, Response<Order> response) {
                Toast.makeText(this, "dispose error", Toast.LENGTH_SHORT).show();
            }

			@Override
            public void onFailure(Call<Order> call, Throwable t) {
            	onError(call, null);
                super.onFailure(call, t);
            }

			@Override
            public void mustDo() {
                Toast.makeText(this, "it works", Toast.LENGTH_SHORT).show();
            }
        }.execute();