Android OkHttp+Retrofit+Rxjava+Hilt实现网络请求框架(1)

.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>>() {

@Override

public void onResponse(Call<ResponseData<List>> call, Response<ResponseData<List>> 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>> 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>() {

@Override

public void onResponse(Call<ResponseData> call, Response<ResponseData> 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> 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();

@POST(“user/register”)

@FormUrlEncoded

Observable<ResponseData> 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 {

@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 implements ObservableTransformer<ResponseData, T> {

public ResponseTransformer() {

}

public static  ResponseTransformer obtain(){

return new ResponseTransformer<>();

}

@NotNull

@Override

public ObservableSource apply(@NotNull Observable<ResponseData> upstream) {

return upstream.onErrorResumeNext(new Function<Throwable, ObservableSource<? extends ResponseData>>() {

@Override

public ObservableSource<? extends ResponseData> apply(@NotNull Throwable throwable) throws Exception {

return Observable.error(ApiException.handleException(throwable));

}

}).flatMap(new Function<ResponseData, ObservableSource>() {

@Override

public ObservableSource apply(@NotNull ResponseData 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”>

<application

android:name=“.App”

…>

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

💥 设置OkHttp+Retrofit+RxJava+Hilt

---

总结

现在新技术层出不穷，如果每次出新的技术，我们都深入的研究的话，很容易分散精力。新的技术可能很久之后我们才会在工作中用得上，当学的新技术无法学以致用，很容易被我们遗忘，到最后真的需要使用的时候，又要从头来过（虽然上手会更快）。

我觉得身为技术人，针对新技术应该是持拥抱态度的，入了这一行你就应该知道这是一个活到老学到老的行业，所以面对新技术，不要抵触，拥抱变化就好了。

Flutter 明显是一种全新的技术，而对于这个新技术在发布之初，花一个月的时间学习它，成本确实过高。但是周末花一天时间体验一下它的开发流程，了解一下它的优缺点、能干什么或者不能干什么。这个时间，并不是我们不能接受的。

如果有时间，其实通读一遍 Flutter 的文档，是最全面的一次对 Flutter 的了解过程。但是如果我们只有 8 小时的时间，我希望能关注一些最值得关注的点。

（跨平台开发(Flutter)、java基础与原理，自定义view、NDK、架构设计、性能优化、完整商业项目开发等）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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

💥 设置OkHttp+Retrofit+RxJava+Hilt

---

总结

现在新技术层出不穷，如果每次出新的技术，我们都深入的研究的话，很容易分散精力。新的技术可能很久之后我们才会在工作中用得上，当学的新技术无法学以致用，很容易被我们遗忘，到最后真的需要使用的时候，又要从头来过（虽然上手会更快）。

我觉得身为技术人，针对新技术应该是持拥抱态度的，入了这一行你就应该知道这是一个活到老学到老的行业，所以面对新技术，不要抵触，拥抱变化就好了。

Flutter 明显是一种全新的技术，而对于这个新技术在发布之初，花一个月的时间学习它，成本确实过高。但是周末花一天时间体验一下它的开发流程，了解一下它的优缺点、能干什么或者不能干什么。这个时间，并不是我们不能接受的。

如果有时间，其实通读一遍 Flutter 的文档，是最全面的一次对 Flutter 的了解过程。但是如果我们只有 8 小时的时间，我希望能关注一些最值得关注的点。

（跨平台开发(Flutter)、java基础与原理，自定义view、NDK、架构设计、性能优化、完整商业项目开发等）

[外链图片转存中…(img-0XIpzB8x-1714286534996)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！