❤️Android OkHttp+Retrofit+Rxjava+Hilt实现网络请求框架❤️

·  阅读 7221
❤️Android OkHttp+Retrofit+Rxjava+Hilt实现网络请求框架❤️

「这是我参与11月更文挑战的第3天,活动详情查看:2021最后一次更文挑战

🔥 介绍

本文通过OkHttp+Retrofit+Rxjava+Hilt实现一个网络请求框。

💥 最终代码

        iWanAndroidService.register(map)
                .compose(ResponseTransformer.obtain())
                .subscribe(registerData -> {
                    //请求成功
                }, new ErrorConsumer() {
                    @Override
                    protected void error(ApiException e) {
                        //请求失败
                    }
                });
复制代码

是不是特别省事。

💥 项目结构

🔥 OkHttp

💥 OkHttp是什么

OkHttp 是一个默认高效的 HTTP 客户端:

  • HTTP/2 支持允许对同一主机的所有请求共享一个 socket。
  • 连接池减少了请求延迟(如果 HTTP/2 不可用)。
  • 透明 GZIP 可缩小下载大小。
  • 响应缓存完全避免网络重复请求。
  • 网路出现问题后,OkHttp会保持不变,自动从问题中恢复。

官方文档

简单使用+源码解读

OkHttp的时候就不单独介绍了。

缺陷:

  • 网络请求的接口配置繁琐,尤其是需要配置复杂请求body,请求头,参数的时候;

  • 数据解析过程需要用户手动拿到responsbody进行解析,不能复用;

  • 无法适配自动进行线程的切换。

  • 存在嵌套网络请求就会陷入“回调陷阱”。

🔥 Retrofit

💥 Retrofit是什么

Retrofit 基于 OkHttp,网络请求工作实际由OkHttp完成,而Retrofit主要负责接口的封装

Retrofit不仅具备了OkHttp的高效特性,还有以下优势:

  • 支持RESTful API设计风格。

  • 通过注解配置请求:包括请求方法、请求参数、请求头,返回值等。

  • 可以搭配多种Converter将获得的数据自动解析和序列化:支持Gson,Jackson,Protobuff等。提供了对RxJava的支持。

  • 请求速度快,使用非常方便灵活。

注意:Retrofit不具备网络请求功能,因此你要设置分发器拦截器等则需要在OkHttpClient中设置。

💥 Retrofit注解

官方文档也提供了各类注解的用法。

🔥 OkHttp+Retrofit 实例

💥 添加依赖

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.8.1' // 必要依赖,retrofit
    implementation 'com.squareup.retrofit2:converter-gson:2.8.1' // 必要依赖,解析json字符
    implementation 'com.squareup.okhttp3:logging-interceptor:4.9.0' //非必要依赖,打印日志

}
复制代码

💥 定义请求接口

public interface IWanAndroidService {
    String BASE_URL = "https://www.wanandroid.com/";
    @GET("banner/json")
    Call<ResponseData<List<HomeBanner>>> homeBanner();

    @POST("user/register")
    @FormUrlEncoded
    Call<ResponseData<RegisterData>> register(@FieldMap Map<String,String> map);

}
复制代码

💥 设置OkHttp+Retrofit

public class NetworkManager {
    private static volatile NetworkManager instances;
    private static volatile OkHttpClient okHttpClient;
    private static volatile Retrofit retrofit;

    public static NetworkManager getInstance() {
        if (instances == null) {
            synchronized (NetworkManager.class) {
                if (instances == null) {
                    instances = new NetworkManager();
                }
            }

        }
        return instances;
    }

    private static int TIME_OUT = 30; //30秒超时断开连接

    private OkHttpClient initClient() {
        if (okHttpClient == null) {
            synchronized (NetworkManager.class) {
                if (okHttpClient == null) {
                    //请求日志打印
                    HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(message -> {
                        try {
                            MLog.e(URLDecoder.decode(message, "utf-8"));
                        } catch (UnsupportedEncodingException e) {
                            e.printStackTrace();
                            MLog.e(message);
                        }
                    });
                    loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
                    //注释1:创建OkHttpClient
                    okHttpClient = new OkHttpClient.Builder()
                            .sslSocketFactory(new NetworkSSL(TrustManager.trustAllCert), TrustManager.trustAllCert)
                            .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
                            .addInterceptor(loggingInterceptor)
                            .readTimeout(TIME_OUT, TimeUnit.SECONDS)
                            .writeTimeout(TIME_OUT, TimeUnit.SECONDS)
                            .build();
                }
            }
        }
        return okHttpClient;

    }

    public Retrofit initRetrofit() {
        if (retrofit == null) {
            synchronized (NetworkManager.class) {
                if (retrofit == null) {
                    //注释2:创建Retrofit
                    retrofit = new Retrofit.Builder()
                            .client(initClient())//选填
                            .baseUrl(IWanAndroidService.BASE_URL)//必填
                            .addConverterFactory(GsonConverterFactory.create())//选填(数据转换器,解析)
                            .build();
                }
            }
        }
        return retrofit;
    }
}
复制代码
  • 注释1:创建OkHttpClient对象,构建一个网络类型的实例,一般会将所有的网络请求使用同一个单例对象。(如果OkHttpClient使用默认,可不设置)

  • 注释2:创建Retrofit对象,构建一个网络请求的载体对象,在build的时候有非常多的初始化内容,如设置OkHttpClient、设置请求的url,添加数据转换器等。

💥 网络请求

            //GET
            //注释1:动态获取IWanAndroidService对象
            IWanAndroidService service = NetworkManager.getInstance().initRetrofit().create(IWanAndroidService.class);
            //注释2:网络请求
            service.homeBanner().enqueue(new Callback<ResponseData<List<HomeBanner>>>() {
                @Override
                public void onResponse(Call<ResponseData<List<HomeBanner>>> call, Response<ResponseData<List<HomeBanner>>> response) {
                    if (response.body().getData() != null) {
                        MLog.e(response.body().getData().get(0).toString());
                        binding.loginTvContent.setText(response.body().getData().get(0).toString());
                    }
                }
                @Override
                public void onFailure(Call<ResponseData<List<HomeBanner>>> call, Throwable t) {
                    MLog.e(t.getMessage());
                }
            });
            
            //POST
            Map<String, String> map = new HashMap<>();
            map.put("username", account);
            map.put("password", passsword);
            map.put("repassword", passsword);
            NetworkManager.getInstance().initRetrofit().create(IWanAndroidService.class)
                    .register(map).enqueue(new Callback<ResponseData<RegisterData>>() {
                @Override
                public void onResponse(Call<ResponseData<RegisterData>> call, Response<ResponseData<RegisterData>> response) {
                    if (response.body().getData() != null) {
                        MLog.e(response.body().getData().toString());
                        binding.loginTvContent.setText(response.body().getData().toString());
                    }
                }

                @Override
                public void onFailure(Call<ResponseData<RegisterData>> call, Throwable t) {
                    MLog.e(t.getMessage());
                }
            });
复制代码

Retrofit的精髓:为统一配置网络请求完成动态代理的设置。

💥 效果图

🔥 Rxjava

RxJava使用了观察者模式建造者模式中的链式调用。

观察者模式:

Observable(被观察者)被Observer(观察者)订阅(Subscribe)之后,Observable在发出消息的时候会通知对应的Observer,并且,一个Observable可以有被多个Observer订阅。

链式调用:调用对应的方法对原对象进行处理后返回原对象,从而做到链式调用。

参与者:

  • Observable:被观察者,也就是消息的发送者
  • Observer:观察者,消息的接收者
  • Subscriber:订阅者,观察者的另一种表示
  • Scheduler:调度器,进行线程切换

RxJava当然是优秀而且强大的,有以下优势:

  • 具备响应式编程该有的特性。
  • 为异步而生,无需手动创建线程,并具备线程切换能力。
  • 支持链式调用,保证代码的简洁性。
  • 各种操作符,功能非常强大,满足各种业务需求。
  • 简化了异常的处理。

RxJava适用场景:网络请求、数据库读写、文件读写、定时任务等各种耗时操作需要通过异步来完成的操作都可以使用RxJava。

💥 添加依赖(新增)

    implementation "io.reactivex.rxjava2:rxjava:2.2.6" // 必要rxjava依赖
    implementation "io.reactivex.rxjava2:rxandroid:2.1.0" // 必要rxandrroid依赖,切线程时需要用到
    ...
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.5.0' // 必要依赖,和rxjava结合必须用到
复制代码

💥 修改请求接口

public interface IWanAndroidService {
    String BASE_URL = "https://www.wanandroid.com/";
    //OkHttp+Retrofit
    //OkHttp+Retrofit+RxJava
    @GET("banner/json")
    Observable<ResponseData<List<HomeBanner>>> homeBanner();

    @POST("user/register")
    @FormUrlEncoded
    Observable<ResponseData<RegisterData>> register(@FieldMap Map<String,String> map);

}
复制代码

💥 设置OkHttp+Retrofit+RxJava

    public Retrofit initRetrofitRxJava() {
        if (retrofit == null) {
            synchronized (NetworkManager.class) {
                if (retrofit == null) {
                    retrofit = new Retrofit.Builder()
                            .client(initClient())//选填
                            .baseUrl(IWanAndroidService.BASE_URL)//必填
                            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//新增网络请求适配器
                            .addConverterFactory(GsonConverterFactory.create())//选填(数据转换器,解析)
                            .build();
                }
            }
        }
        return retrofit;
    }
复制代码

💥 进行网络请求

        NetworkManager.getInstance().initRetrofitRxJava()
                .create(IWanAndroidService.class)
                .homeBanner()
                .subscribeOn(Schedulers.io())//切换到IO线程
                .observeOn(AndroidSchedulers.mainThread())//切换到主线程
                // 添加订阅
                .subscribe(listResponseData -> {
                    //请求成功
                    if (listResponseData != null) {
                        MLog.e(listResponseData.getData().get(0).toString());
                        binding.loginTvContent.setText(listResponseData.getData().get(0).toString());
                    }
                }, throwable -> {
                    //请求失败
                    MLog.e(throwable.getMessage());
                });
复制代码

💥 效果图

💥 进一步封装

由于请求过于繁琐,咱们试着复进一步封装。

🌀 统一异常处理(自定义ApiException)

public class ApiException extends Exception {
    //未知错误
    public static final int UNKNOWN = 1000;
    //解析错误
    public static final int PARSE_ERROR = 1001;
    //网络错误/连接错误
    public static final int NETWORK_ERROR = 1002;
    private int code;
    private String displayMessage;

    public ApiException(int code, String displayMessage) {
        this.code = code;
        this.displayMessage = displayMessage;
    }

    public int getCode() {
        return code;
    }

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

    public String getDisplayMessage() {
        return displayMessage;
    }

    public void setDisplayMessage(String displayMessage) {
        this.displayMessage = displayMessage;
    }

    public static ApiException handleException(Throwable e) {
        ApiException ex;
        if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException) {
            //解析错误
            ex = new ApiException(PARSE_ERROR, e.getMessage());
            return ex;
        } else if (e instanceof ConnectException) {
            //网络错误
            ex = new ApiException(NETWORK_ERROR, e.getMessage());
            return ex;
        } else if (e instanceof UnknownHostException || e instanceof SocketTimeoutException) {
            //连接错误
            ex = new ApiException(NETWORK_ERROR, e.getMessage());
            return ex;
        } else {
            //未知错误
            ex = new ApiException(UNKNOWN, e.getMessage());
            return ex;
        }
    }
}
复制代码

🌀 统一异常处理(实现Consumer<Throwable>接口)

public abstract class ErrorConsumer implements Consumer<Throwable> {
    @Override
    public void accept(@NotNull Throwable throwable) throws Exception {
        //对异常进行处理
        ApiException exception;
        if (throwable instanceof ApiException) {
            exception = (ApiException) throwable;
        } else {
            exception = ApiException.handleException(throwable);
        }
        //调用error方法
        error(exception);
    }
    //使用时实现error方法即可。
    protected abstract void error(ApiException e);
}
复制代码

🌀 响应转换处理

public class ResponseTransformer<T> implements ObservableTransformer<ResponseData<T>, T> {
    public ResponseTransformer() {
    }
    public static <R> ResponseTransformer<R> obtain(){
        return new ResponseTransformer<>();
    }

    @NotNull
    @Override
    public ObservableSource<T> apply(@NotNull Observable<ResponseData<T>> upstream) {
        return upstream.onErrorResumeNext(new Function<Throwable, ObservableSource<? extends ResponseData<T>>>() {
            @Override
            public ObservableSource<? extends ResponseData<T>> apply(@NotNull Throwable throwable) throws Exception {
                return Observable.error(ApiException.handleException(throwable));
            }
        }).flatMap(new Function<ResponseData<T>, ObservableSource<T>>() {
            @Override
            public ObservableSource<T> apply(@NotNull ResponseData<T> responseData) throws Exception {
                //请求成功,开始处理你的逻辑吧
                if (0==responseData.getErrorCode()) {
                    if (null!=responseData.getData()) {
                        return Observable.just(responseData.getData());
                    } else {
                        //有可能存在返回的数据结果为ull,直接传Null会产生异常。
                        //用过反射创建一个没有内容的数据实例。
                        return Observable.just(responseData.getData());
                    }
                }
                //请求异常
                return Observable.error(new ApiException(responseData.getErrorCode(), responseData.getErrorMsg()));
            }
        }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
    }
}

复制代码

🌀 封装后使用

数据拿到。

🔥 Hilt(JetPack成员)

在 Android 上使用Hilt进行依赖注入。Hilt 建立在 Dagger 之上,它提供了一种将 Dagger 依赖注入合并到 Android 应用程序中的标准方法。

官方文档最为致命

💥 添加依赖(新增)

  implementation 'com.google.dagger:hilt-android:2.40.1'
  annotationProcessor 'com.google.dagger:hilt-compiler:2.40.1'
复制代码

💥 Hilt Gradle plugin

🌀 build.gradle(Project)

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.40.1'
    }
}
复制代码

🌀 build.gradle(Module)

apply plugin: 'dagger.hilt.android.plugin'
复制代码

🌀 Hilt Application

所有使用 Hilt 的应用程序都必须包含一个用 @HiltAndroidApp 注释的 Application 类。

创建Application

import android.app.Application;

import dagger.hilt.android.HiltAndroidApp;

@HiltAndroidApp
public class App extends Application {
}

复制代码

设置AndroidManifest

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.scc.wanandroid">
    <uses-permission android:name="android.permission.INTERNET"/>
    <application
        android:name=".App"
        ...>
    </application>

</manifest>
复制代码

准备工作做完了,开始使用Hilt搭建网络框架

💥 设置OkHttp+Retrofit+RxJava+Hilt

🌀 创建NetworkModule用来初始化

@InstallIn(SingletonComponent.class)
@Module
public class NetworkModule {
    private static int TIME_OUT = 30; //30秒超时断开连接
    @Provides
    @Singleton
    OkHttpClient providesOkHttpClient(){
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                try {
                    MLog.e("--network--", URLDecoder.decode(message, "utf-8"));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    MLog.e("--network--", message);
                }
            }
        });
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        return new OkHttpClient.Builder()
                .sslSocketFactory(new NetworkSSL(TrustManager.trustAllCert), TrustManager.trustAllCert)
                .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
                .addInterceptor(loggingInterceptor)
                .readTimeout(TIME_OUT, TimeUnit.SECONDS)
                .writeTimeout(TIME_OUT, TimeUnit.SECONDS)
                .build();
    }
    @Singleton
    @Provides
    Retrofit providesRetrofit(OkHttpClient okHttpClient){
        return new Retrofit.Builder()
                .client(okHttpClient)
                .baseUrl(IWanAndroidService.BASE_URL)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .build();
    }
    @Singleton
    @Provides
    IWanAndroidService providesWanAndroidService(Retrofit retrofit){
        return retrofit.create(IWanAndroidService.class);
    }
}
复制代码

🌀 使用

@AndroidEntryPoint
public class LoginActivity extends AppCompatActivity {
    ActivityLoginBinding binding;
    @Inject
    IWanAndroidService iWanAndroidService;
    //Retrofit+RxJava+Hilt
        iWanAndroidService.homeBanner()
                .compose(ResponseTransformer.obtain())
                .subscribe(homeBanners -> {
                    //请求成功
                    if (homeBanners != null) {
                        MLog.e(homeBanners.get(0).toString());
                        binding.loginTvContent.setText(homeBanners.get(0).toString());
                    }
                }, new ErrorConsumer() {
                    @Override
                    protected void error(ApiException e) {
                        //请求失败
                        MLog.e(e.getMessage()+e.getCode());
                    }
                });
}
复制代码

🌀 效果图

🔥 小结

项目拿到就能用,当然还有可优化的地方。

  • 获取的data为null的时候的处理。
  • 对外隐藏进行网络请求的实现细节。
  • 根据实际情况进一步细化,如API分模块创建等。

💥 项目传送门

🔥 链接汇总

🌀 OkHttp Github

🌀 Retrofit Github

🌀 RxJava Github

🌀 Hilt 官方文档最为致命

🔥 感谢

🌀 感谢鸿神wanandroid提供的API

🌀 Android Retrofit + RxJava使用详解

🌀 封装Retrofit2+RxJava2网络请求框架

分类:
Android
标签:
分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改