Android肝帝战纪之网络请求框架封装(Retrofit的封装)

最新推荐文章于 2024-08-30 22:08:13 发布
最新推荐文章于 2024-08-30 22:08:13 发布
阅读量1.2k 收藏
点赞数
文章标签： Android 网络请求 Retrofit 封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34599726/article/details/79711816
版权

网络请求框架封装(OkHttp3+Retrofit+loading的封装)

  • Retrofit的Github链接
    点此链接到Github

  • AVLoadingIndicatorView的Github链接（封装到请求框架中，请求过程中的loading样式框（不停转的那个））
    点此链接到Github

  • post请求封装后的的效果展示（在任意需要网络请求的地方）

RestClient.builder()
        .url("/sign_in")
        .loader(getContext())
        .params("account", mEmail.getText().toString())
        .params("password", mPassword.getText().toString())
        .success(new ISuccess(){
            @Override
            public void onSuccess(){
                //请求成功的处理逻辑
            }
        })
        .error(new IError(){
            @Override
            public void onError(){
                //请求错误的处理逻辑
            }
        })
        .failure(new IFailure(){
            @override
            public void onFailure(){
                //请求失败的处理逻辑
            }
        }
        .build()
        .post();
  • 引入依赖
  //网络请求依赖
  api 'com.squareup.okio:okio:1.13.0'
  api 'com.squareup.okhttp3:okhttp:3.8.1'
  api 'com.squareup.retrofit2:retrofit:2.3.0'
  api 'com.squareup.retrofit2:converter-scalars:2.3.0'
  // loader依赖
  api 'com.wang.avi:library:2.1.3'

  • 网络框架结构
    网络请求框架结构

  • loading封装结构
    loading

  • Loader的封装

  • 1.新建LoaderStyle即loading的样式，建立一个枚举类
public enum LoaderStyle{
    BallPulseIndicator,
    BallGridPulseIndicator,
    BallClipRotateIndicator,
    BallClipRotatePulseIndicator,
    SquareSpinIndicator,
    BallClipRotateMultipleIndicator,
    BallPulseRiseIndicator,
    BallRotateIndicator,
    CubeTransitionIndicator,
    BallZigZagIndicator
    ...
}
  • 2.新建LoaderCreator，通过映射，拿到需要的样式图标。
public final class LoaderCreator{
    private static final WeakHashMap<String, Indicator> LOADING_MAP = new WeakHashMap<>();

    static AVLoadingIndicatorView create(String type, Context context){
        final AVLoadingIndicatorView avLoadingIndicatorView = new AVLoadingIndicatorView(context);
        if (LOADING_MAP.get(type) == null){
            final Indicator indicator = getIndicator(type);
            LOADING_MAP.put(type, indicator);
        }

        avLoadingIndicatorView.setIndicator(LOADING_MAP.get(type));
        return avLoadingIndicatorView;
    }

    private static Indicator getIndicator(String name){
        if (name == null||name.isEmpty()){
            return null;
        }
        final StringBuilder drawableClassName = new StringBuilder();
        if (!name.contains(".")){
            final String defaultPackageName = AVLoadingIndicatorView.class.getPackage().getName();
            drawableClassName.append(defaultPackageName)
                    .append(".indicators")
                    .append(".");
        }
        drawableClassName.append(name);
        try {
            final Class<?> drawableClass = Class.forName(drawableClassName.toString());
            return (Indicator) drawableClass.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}
  • 3.新建MyLoader,通过映射得到的图标，显示到屏幕上。
public class MyLoader{
    private static final int LOADER_SIZE_SCALE=8;

    private static final int LOADER_OFFSET_SCALE=10;

    private static final ArrayList<AppCompatDialog> LOADERS=new ArrayList<>();

    private static final String DEFAULT_LOADER=LoaderStyle.BallSpinFadeLoaderIndicator.name();

    public static void showLoading(Context context,Enum<LoaderStyle> styleEnum){
        showLoading(context,styleEnum.name());
    }

    public static void showLoading(Context context,String type){
        final AppCompatDialog dialog=new AppCompatDialog(context, R.style.dialog);

        final AVLoadingIndicatorView avLoadingIndicatorView=LoaderCreator.create(type,context);
        dialog.setContentView(avLoadingIndicatorView);

        int deviceWidth= DimenUtil.getScreenWidth();
        int deviceHeight=DimenUtil.getScreenHeight();

        final Window dialogWindow=dialog.getWindow();

        if (dialogWindow!=null){
            WindowManager.LayoutParams lp=dialogWindow.getAttributes();
            lp.width=deviceWidth/LOADER_SIZE_SCALE;
            lp.height=deviceHeight/LOADER_SIZE_SCALE;
            lp.height=lp.height+deviceHeight/LOADER_OFFSET_SCALE;
            lp.gravity= Gravity.CENTER;
        }
        LOADERS.add(dialog);
        dialog.show();
    }

    public static void showLoading(Context context){
        showLoading(context,DEFAULT_LOADER);
    }

    public static void stopLoading(){
        for (AppCompatDialog dialog:LOADERS){
            if (dialog!=null){
                if (dialog!=null){
                    dialog.cancel();
                }
            }
        }
    }
}

  • RestClient封装

  • 1.先建立Retrofit请求必须要的接口文件RestService(泛式封装)

public interface RestService{
    @GET
    Call<String> get(@Url String url, @QueryMap Map<String, Object> params);

    @FormUrlEncoded
    @POST
    Call<String> post(@Url String url, @FieldMap Map<String, Object> params);

    @POST
    Call<String> postRaw(@Url String url, @Body RequestBody body);

    @FormUrlEncoded
    @PUT
    Call<String> put(@Url String url, @FieldMap Map<String, Object> params);

    @PUT
    Call<String> putRaw(@Url String url, @Body RequestBody body);

    @DELETE
    Call<String> delete(@Url String url, @QueryMap Map<String, Object> params);

    @Streaming
    @GET
    Call<ResponseBody> download(@Url String url, @QueryMap Map<String, Object> params);

    @Multipart
    @POST
    Call<String> upload(@Url String url, @Part MultipartBody.Part file);
}
  • 2.新建HttpMethod的枚举类
public enum HttpMethod{
    GET,
    POST,
    POST_RAW,
    PUT,
    PUT_RAW,
    DELETE,
    UPLOAD
}
  • 3.新建RestCreator类，将RetrofitService的接口实例化，然后用来进行网络请求。（静态内部类实现线程安全的单例模式）
public class RestCreator{
    // 参数的单例模式
    private static final class ParamsHolder{
        private static final WeakHashMap<String, Object> PARAMS = new WeakHashMap<>();
    }

    public static WeakHashMap<String, Object> getParams(){
        return ParamsHolder.PARAMS;
    }

    // 对外释放RestService的实例
    public static RestService getRestService(){
        return RestServiceHolder.REST_SRVICE;
    }

    private static final class RetrofitHolder{
        private static final String BASE_URL = "http://www.baidu.com/"
        private static final Retrofit RETROFIT_CLIENT = new Retrofit.Builder()
                                                                    .baseUrl(BASE_URL)
                                                                    .client(OKHttpHolder.OK_HTTP_CLIENT)
                                                                    .addConverterFactory(ScalarsConverterFactory.create())
                                                                    .build();
    }

    private static final class OKHttpHolder {
        private static final int TIME_OUT = 60;
        private static final OkHttpClient OK_HTTP_CLIENT = new OkHttpClient.Builder()
                .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
                .build();
    }

    private static final class RestServiceHolder{
        private static final RestService REST_SERVICE = RetrofitHolder.RETROFIT_HOLDER.create(RestService.class);
    }
}
  • 4.根据获取到的参数数据，组装之后进行网络请求（使用建造者模式进行数据的组装）先建立callback的回调接口
public interface ISuccess {
    void onSuccess(String response);
}
public interface IError {
    void onError(int Code, String msg);
}
public interface IFailure {
    void onFailure();
}
public interface IRequest {
    void onRequestStart();
    void onRequestEnd();
}
  • 5.新建RequestCallbacks实现Callback的接口，即处理网络请求的回调
public class RequestCallbacks implements Callback<String>{
    private final IRequest REQUEST;
    private final ISuccess SUCCESS;
    private final IFailure FAILURE;
    private final IError ERROR;
    private final LoaderStyle LOADER_STYLE;

    public RequestCallbacks(IRequest request, ISuccess success, IFailure failure, IError error, LoaderStyle loaderStyle){
        this.REQUEST = request;
        this.SUCCESS = success;
        this.FAILURE = failure;
        this.ERROR = error;
        this.LOADER_STYLE = loaderStyle;
    }

    @Override
    public void onResponse(Call<String> call, Response<String> response) {
        if (response.isSuccessful()) {
            if (call.isExecuted()) {
                if (SUCCESS != null) {
                    SUCCESS.onSuccess(response.body());
                }
            }
        } else {
            if (ERROR != null) {
                ERROR.onError(response.code(), response.message());
            }
        }
        stopLoader();
    }

    @Override
    public void onFailure(Call<String> call, Throwable t) {
        if (FAILURE != null) {
            FAILURE.onFailure();
        }
        if (REQUEST != null) {
            REQUEST.onRequestEnd();
        }
        stopLoader();
    }

    private void stopLoader() {
        if (LOADER_STYLE != null) {
           LatteLoader.stopLoading();
        }
    }
}
  • 6.新建RestClient类，就是将传入的数据进行组装然后用之前实例化的RestService对象进行网络请求。
public class RestClient{
    private final String URL;
    private static final WeakHashMap<String, Object> PARAMS = RestCreator.getParams();
    private final IRequest REQUEST;
    private final String DOWNLOAD_DIR;
    private final String EXTENSION;
    private final String NAME;
    private final ISuccess SUCCESS;
    private final IFailure FAILURE;
    private final IError ERROR;
    private final RequestBody BODY;
    private final LoaderStyle LOADER_STYLE;
    private final File FILE;
    private final Context CONTEXT;

    public RestClient(String url,
                      Map<String, Object> params,
                      IRequest request,
                      String download_dir,
                      String extension,
                      String name,
                      ISuccess success,
                      IFailure failure,
                      IError error,
                      RequestBody body,
                      LoaderStyle loaderStyle,
                      File file,
                      Context context) {
        this.URL = url;
        PARAMS.putAll(params);
        this.REQUEST = request;
        this.DOWNLOAD_DIR = download_dir;
        this.EXTENSION = extension;
        this.NAME = name;
        this.SUCCESS = success;
        this.FAILURE = failure;
        this.ERROR = error;
        this.BODY = body;
        this.LOADER_STYLE = loaderStyle;
        this.FILE = file;
        this.CONTEXT = context;
    }

    public static RestClientBuilder builder() {
        return new RestClientBuilder();
    }

    private void request(HttpMethod method){
        final RestService service = RestCreator.getRestService();
        Call<String> call = null;

        if(REQUEST != null){
            REQUEST.onRequestStart();
        }

        if (LOADER_STYLE != null) {
            LatteLoader.showLoading(CONTEXT, LOADER_STYLE);
        }

        switch (method) {
            case GET:
                call = service.get(URL, PARAMS);
                break;
            case POST:
                call = service.post(URL, PARAMS);
                break;
            case POST_RAW:
                call = service.postRaw(URL, BODY);
                break;
            case PUT:
                call = service.put(URL, PARAMS);
                break;
            case PUT_RAW:
                call = service.putRaw(URL, BODY);
                break;
            case DELETE:
                call = service.delete(URL, PARAMS);
                break;
            case UPLOAD:
                final RequestBody requestBody = RequestBody.create(MediaType.parse(MultipartBody.FORM.toString()), FILE);
                final MultipartBody.Part body = MultipartBody.Part.createFormData("file", FILE.getName(), requestBody);
                call = RestCreator.getRestService().upload(URL, body);
                break;
            default:
                break;
        }

        if (call != null) {
            call.enqueue(getRequestCallback());
        }
        RestCreator.getParams().clear();
    }

    private Callback<String> getRequestCallback() {
        return new RequestCallbacks(
                REQUEST,
                SUCCESS,
                FAILURE,
                ERROR,
                LOADER_STYLE
        );
    }

    public final void get() {
        request(HttpMethod.GET);
    }

    public final void post() {
        if (BODY == null) {
            request(HttpMethod.POST);
        } else {
            if (PARAMS.isEmpty()) {
                throw new RuntimeException("params must be null");
            }
            request(HttpMethod.POST_RAW);
        }

    }

    public final void put() {
        if (BODY == null) {
            request(HttpMethod.PUT);
        } else {
            if (PARAMS.isEmpty()) {
                throw new RuntimeException("params must be null");
            }
            request(HttpMethod.PUT_RAW);
        }
    }

    public final void delete() {
        request(HttpMethod.DELETE);
    }

    public final void upload() {
        request(HttpMethod.UPLOAD);
    }
}
  • 7.新建RestClientBuilder，就是RestClient的建造者类
public class RestClientBuilder {

    private String mUrl = null;
    private static final Map<String, Object> PARAMS = RestCreator.getParams();
    private IRequest mIRequest = null;
    private String mDownloadDir = null;
    private String mExtension = null;
    private String mName = null;
    private ISuccess mISuccess = null;
    private IFailure mIFailure = null;
    private IError mIError = null;
    private RequestBody mBody = null;
    private LoaderStyle mLoaderStyle = null;
    private File mFile = null;
    private Context mContext = null;

    RestClientBuilder() {
    }

    public final RestClientBuilder url(String url) {
        this.mUrl = url;
        return this;
    }

    public final RestClientBuilder params(WeakHashMap<String, Object> params) {
        PARAMS.putAll(params);
        return this;
    }

    public final RestClientBuilder params(String key, Object value) {
        PARAMS.put(key, value);
        return this;
    }

    public final RestClientBuilder file(File file) {
        this.mFile = file;
        return this;
    }

    public final RestClientBuilder file(String file) {
        this.mFile = new File(file);
        return this;
    }

    public final RestClientBuilder raw(String raw) {
        this.mBody = RequestBody.create(MediaType.parse("application/json;charset=UTF-8"), raw);
        return this;
    }

    public final RestClientBuilder dir(String dir) {
        this.mDownloadDir = dir;
        return this;
    }

    public final RestClientBuilder extension(String extension) {
        this.mExtension = extension;
        return this;
    }

    public final RestClientBuilder name(String name) {
        this.mName = name;
        return this;
    }

    public final RestClientBuilder onRequest(IRequest iRequest) {
        this.mIRequest = iRequest;
        return this;
    }

    public final RestClientBuilder success(ISuccess iSuccess) {
        this.mISuccess = iSuccess;
        return this;
    }

    public final RestClientBuilder failure(IFailure iFailure) {
        this.mIFailure = iFailure;
        return this;
    }

    public final RestClientBuilder error(IError iError) {
        this.mIError = iError;
        return this;
    }

    public final RestClientBuilder loader(Context context, LoaderStyle style) {
        this.mContext = context;
        this.mLoaderStyle = style;
        return this;
    }

    public final RestClientBuilder loader(Context context) {
        this.mContext = context;
        this.mLoaderStyle = LoaderStyle.BallSpinFadeLoaderIndicator;
        return this;
    }

    public final RestClient build() {
        return new RestClient(mUrl, PARAMS, mIRequest, mDownloadDir, mExtension, mName, mISuccess, mIFailure, mIError, mBody, mLoaderStyle, mFile, mContext);
    }

}
  • 8.小结
    至此网络框架告一段落，其中的download没有写全，调用方式就是开头写的那样。
王二鸣
关注
android 网络请求封装
08-18
android 网络请求封装
游戏社区App (二)：网络请求框架的封装
yeliang23的博客
04-29 382
网络请求框架的封装 封装后可以在需要网络请求的地方便捷地进行post请求 RestClient.builder() .url("https://www.baidu.com/") .success(new ISuccess() { @Override public void onSuccess(String respon...
【Android】最好用的网络库：Retrofit
最新发布
2303_79296612的博客
08-30 1902
Retrofit是一款由Square公司开发的网络库，但是它和OkHttp的定位完全不同。OkHttp侧重的是底层通信的实现，而Retrofit侧重的是上层接口的封装。事实上，Retrofit就是Square公司在OkHttp的基础上进一步开发出来的应用层网络通信库，使得我们可以用更加面向对象的思维进行网络操作。Retrofit的项目主页地址是：https://github.com/square/retrofit。Retrofit的设计基于以下几个事实。
Android简单基类封装（三）OKhttp网络请求——其实你也可以
热门推荐
王能的小屋
03-13 1万+
本文介绍如何抛弃那些高大上的、花里胡哨的、适配所有的完美http封装（壳子而已）。 学习地址：https://github.com/weimingjue/http 首先，OKhttp是现在所有安卓开发的网络请求框架（还在用Apache的我就不多说什么了，自行绕道），那些所谓的完美封装只是在OKhttp上加了几行代码而已。 其次，那些封装也是要考虑全局性，只是把OKhttp简化了一两行而已，真...
Retrofit(OKHttp封装)
ChaoXii的博客
07-28 162
Retrofit是对OKHttp的一种封装, 更针对于Android平台的一个网络通信框架,通过动态代理读取注解后进行适配器转换包装后发起OKHttp请求。
使用Retrofit+LiveData时的Error/Loading处理
移动端开发干货分享
01-29 2563
目前还有很多项目使用Retrofit2+LiveData进行API请求，LiveData在不像RxJava那样可以方便地进行Error处理，所以想基于LiveData封装一个工具类，对API请求中的Error/Loading等进行统一处理 HttpManager open class HttpManager<T>(context: Context, serviceClass: C...
Android网络请求框架Retrofit详解
08-29
Android网络请求框架Retrofit详解 Retrofit是Square公司开发的一款针对Android网络请求的框架，Retrofit2底层基于OkHttp实现的，OkHttp现在已经得到Google官方认可，大量的app都采用OkHttp做网络请求。本文将详细...
Android-android网络请求框架MVPRetrofitRxjava
08-13
本主题将深入探讨如何使用MVP（Model-View-Presenter）架构、Retrofit网络库以及RxJava响应式编程库来构建高效且可维护的网络请求框架。 首先，我们来看MVP架构。MVP是一种软件设计模式，它将应用程序分为三个主要...
基于Retrofit+RxJava实现的Java网络请求库封装源码.zip
07-05
基于Retrofit+RxJava实现的Java网络请求库封装，支持GET/POST/PUT/DELETE请求、动态BaseUrl、请求头、请求/响应日志、自定义加解密器等。同时，支持自定义Parser（数据解析器），用于解决不同返回数据Model。
Android中网络框架简单封装的实例方法
01-20
Android中网络框架的简单封装 前言 Android作为一款主要应用在移动终端的操作系统，访问网络是必不可少的功能。访问网络，最基本的接口有：HttpUrlConnection,HttpClient，而在后续的发展中，出现了Volley，OkHttp，...
Android组件化开发（二）--网络请求组件封装
yuhaibing111的博客
11-03 1877
前面一篇文章我们讲解了maven私服的搭建，maven私服在组件化框架中有一个很重要的地位就是可以将我们的lib库放到局域网中，供公司其他开发者使用，实现类库的分享。下面是这个系列准备实现的一个组件化实战项目框架笔者打算从下往上依次来实现我们项目中的组件，毕竟地基稳固了，房子才可以搭的很结实。注意：这里不会对封装代码进行长篇大论，主要还是以思路点拨的方式进行，如果需要看完整代码的可以移步到github。
Android中Retrofit网络请求封装(带加载等待框)[已验证get和post请求的可用性]
水月洞天
07-01 3118
最近一个小伙伴问我有关retrofit的用法，关于这个网络请求框架的内部暂且不讨论，因为除了它是基于okhttp编写的，我也是一无所知。不过用一用还是可以的，所以这里我贴出一个也是最近学习的封装好的代码，以供自己和他人使用。希望方便大家。 1.依赖包 //网络请求依赖 compile 'com.squareup.okio:okio:1.13.0' compile 'com.squareup....
Android中封装OkHttp，处理网络请求
zhangsp_dev_dxdc的博客
06-25 407
Android中封装OkHttp，处理网络请求
Android 网络请求-AsyncHttpClient封装（超详细版）
m0_46694056的博客
10-24 2349
最近捣鼓android，但学习不多，索性完全把android当前端玩了，然后自己写了个后端服务，所以这个中间过程就需要网络请求，找了个三方库，即，下面就是自己简单的封装了下get和post方法，这两个也够我目前业务开发了。
Android 目前最流行的网络请求框架【Retrofit】
datian1234的博客
04-16 990
Retrofit`可以节省老一套网络请求写那么多代码的冗杂 为开发者提供了相对简单的请求方案 作为安卓目前最流行的网络请求框架,确实名不虚传.
安卓okhttp网络请求封装使用
qq_41733851的博客
03-04 1719
安卓网络请求封装及其使用
[从零开始系列]AndroidApp研发之路(一) 网络请求的封装(一)
chengzichen_的博客
08-28 9849
文章目录： - 前言 - 封装成果 - 封装细节 - 如何使用 - 注意 - 作者前言写在前面Flyabbit是一个使用Retrofit+Rxjava2+dagger2+Mvp+Material Design 快速搭建的一个app,ui是其一,更重要的是我将通过一系列的文章从项目零开始 技术选型->到封装->组件化设计->本地Maven(nexus)简单使用->自动打包(Jenkins
Android 项目（一）：网络请求封装（一）
danfengw的博客
10-12 1189
单独的使用网络连接相信大家都一看就懂，一看就会，但是在实际项目中感觉然并卵啊！我们不可能在每个需要网络请求的界面都写个网络请求，那样不仅代码量增多且重复，因此要想个办法将所有的网络请求提取出来，每当有页面需要网络请求就调用同一个方法，方便简洁。 一、网络连接方法 关于网络连接可以使用volley也可以使用HTTPUtils的网络连接方式。 思路： 1、编写MyHttp.class用于网
【Android】kotlin+协程+retrofit+mvvm 优雅地实现并封装网络请求
full courage的博客
05-10 1550
网络请求是软件开发中必不可少的一个部分，通过客户端向服务器发送请求，获取服务器上的资源，这些资源可以是网页内容、数据、文件等。通常遵循HTTP或其他协议，http是超文本传输协议，被用于在web浏览器和网站服务器之间传递信息，基于TCP/IP通信协议。根据不同的需求和场景，网络请求可以采用不同的方法，如GET、POST、PUT、DELETE等。一个完整的网络请求分为三个部分：请求行、请求头、请求体。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值