Retrofit2(2.x)帮助类（全套）

最新推荐文章于 2025-07-25 13:33:44 发布

原创最新推荐文章于 2025-07-25 13:33:44 发布 · 1.1k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#android #retrofit

android 专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种基于Retrofit框架结合Gson进行网络请求的封装方法，包括单例Retrofit实例创建、OkHttp配置与拦截器实现、响应数据解析等关键环节。

retrofit帮助类

public class RetrofitGsonHelper {
    //private static RestAdapter singleton;
    private static Retrofit singleton;

    public static <T> T createApi(Context context, Class<T> clazz) {
        if (singleton == null) {
            synchronized (RetrofitGsonHelper.class) {
                if(singleton == null){
                    Retrofit.Builder builder = new Retrofit.Builder();
                    builder.baseUrl(Config.URL_BASE);
                    builder.addConverterFactory(GsonConverterFactory.create(GsonUtil.newInstance()));
                    builder.client(OkHttpInstance.getInstance(context));
                    singleton = builder.build();
                }
            }
        }
        return singleton.create(clazz);
    }
}

转换器使用gson,注册了Date类型的适配

public class GsonUtil {
    public static Gson newInstance() {
        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(Date.class, new DateTypeAdapter());
        return builder.create();
    }
}

绑定网络请求委托给OKhttp , 下面是OKhttp单例帮助类

public class OkHttpInstance {
    private static OkHttpClient singleton;

    public static OkHttpClient getInstance(final Context context) {
        if (singleton == null) {
            synchronized (OkHttpInstance.class) {
                if (singleton == null) {
                    File cacheDir = new File(FileUtil.getCacheDir(context), Config.RESPONSE_CACHE);

                    singleton = new OkHttpClient();
                    singleton.setCache(new Cache(cacheDir, Config.RESPONSE_CACHE_SIZE));
                    singleton.setConnectTimeout(Config.HTTP_CONNECT_TIMEOUT, TimeUnit.MILLISECONDS);
                    singleton.setReadTimeout(Config.HTTP_READ_TIMEOUT, TimeUnit.MILLISECONDS);
                    singleton.interceptors().add(new Interceptor() {
                        @Override
                        public Response intercept(Chain chain) throws IOException {

                            final Request request = chain.request();

                            Request newRequest = request.newBuilder().method(request.method(), new RequestBody() {
                                @Override
                                public MediaType contentType() {
                                    return request.body().contentType();
                                }

                                @Override
                                public void writeTo(BufferedSink sink) throws IOException {

                                    // 这里插入公共参数
                                    sink.writeUtf8("&hanzhu=基神&");
                                    sink.writeUtf8("&zijidong=B神&");
                                    request.body().writeTo(sink);
                                }
                            }).build();
                            return chain.proceed(newRequest);
                        }
                    });
                    singleton.interceptors().add(new Interceptor() {
                        @Override
                        public Response intercept(Chain chain) throws IOException {
                            Request request = chain.request();//拦截reqeust
                            if (!AppUtil.isNetworkReachable(context.getApplicationContext())) {//判断网络连接状况
                                request = request.newBuilder()
                                        .cacheControl(CacheControl.FORCE_CACHE)//无网络时只从缓存中读取
                                        .build();
                            }

                            Response response = chain.proceed(request);
                            if (AppUtil.isNetworkReachable(context.getApplicationContext())) {
                                int maxAge = 60*60; // 有网络时 设置缓存超时时间1个小时
                                response.newBuilder()
                                        .removeHeader("Pragma")
                                                //清除头信息，因为服务器如果不支持，会返回一些干扰信息，不清除下面无法生效
                                        .header("Cache-Control", "public, max-age=" + maxAge)//设置缓存超时时间
                                        .build();
                            } else {
                                int maxStale = 60 * 60 * 24 * 28; // 无网络时，设置超时为4周
                                response.newBuilder()
                                        .removeHeader("Pragma")
                                        .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                                                //设置缓存策略，及超时策略
                                        .build();
                            }
                            return response;
                        }
                    });
                }
            }
        }
        return singleton;
    }
}

二次封装返回操作

public abstract class ActivityCallback<K> implements retrofit.Callback<ResponseBean<K>> {
    private final WeakReference<BaseActivity> mRef;
    private Class<K> mClazz;
    private final int STATUS_OK = 10000;


    public ActivityCallback(@NonNull BaseActivity activity) {
        mRef = new WeakReference<>(activity);
    }

    public Activity getActivity() {
        return mRef.get();
    }


    @Override
    public void onResponse(Response<ResponseBean<K>> response, Retrofit retrofit) {
        ResponseBean<K> responseBean = response.body();
        if (responseBean.getCode() == STATUS_OK) {
            success(responseBean.getResult());
        } else {
            // todo 错误处理
            Toast.showShort(getActivity(), responseBean.getCode() + ":"+ responseBean.getMsg());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        final BaseActivity activity = mRef.get();
        if (t != null) {
            // TODO 失败处理
            Toast.showShort(activity, activity.getString(R.string.server_error));
            Log.e(activity, "FailureMsg:" + t.getMessage());
            t.printStackTrace();
        }
    }

    public abstract void success(K obj);
}

请求接口

public interface Api {

    /**
     * 登录
     *
     * @param userName 用户名
     * @param password 密码
     * @return
     */
    @FormUrlEncoded
    @POST(value = "login")
    Call<ResponseBean<User>> login(@Field("userName") String userName, @Field("password") String password);
}

封装默认实体类

public class ResponseBean<K> {
    private K result;
    private int code;
    private String msg;


    public K getResult() {
        return result;
    }

    public void setResult(K result) {
        this.result = result;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

使用方法：

        Call<ResponseBean<User>> call = RetrofitGsonHelper.createApi(this, Api
                .class).login("username", "password");

        call.enqueue(new ActivityCallback<User>(this) {
            @Override
            public void success(User obj) {
                 // TODO: 16/1/27 异步请求成功
            }
        });