android——retrofit+rxjava超级详细讲解与使用

在自我学习的过程中，和项目中，使用到了retrofit+rxjava访问接口，记录一下自己的学习过程，可能有不准确或者不到位的地方，请指正，嘻嘻！！！

Lane.Lin

9936人浏览 · 2021-05-22 17:07:18

Lane.Lin · 2021-05-22 17:07:18 发布

在自我学习的过程中，和项目中，使用到了retrofit+rxjava访问接口，记录一下自己的学习过程，可能有不准确或者不到位的地方，请大家多指正，嘻嘻！！！

retrofit+rxjava使用

一、什么是Retrofit？
二、怎么用retrofit？
三、什么是rxjava？
四、rxjava+retrofit怎么用？

一、什么是Retrofit？

1、Retrofit的定义

Retrofit是android的网络请求库，是一个RESTful的HTTP网络请求框架的封装（基于okhttp）。它内部网络请求的工作，本质上是通过OkHttp完成，而Retrofit仅负责网络请求接口的封装。

2、具体的流程

客户端通过Retrofit访问网络，实际上是通过Retrofit的接口封装了访问参数即我们所说的网址URL，接着通过okhttp去完成后面的请求工作。在服务端返回数据之后，OkHttp将原始的结果传递给Retrofit，Retrofit根据客户端的相关配置，将结果进行解析回调给客户端。

APP应用—→retrofit—→okhttp—→服务器(查到数据并返回)—→okhttp—→retrofit—→APP应用

3、Retrofit的作用

retrofit它将网络请求的参数通过注解配置进行封装，它支持同步、异步两种网络请求，支持多种数据格式的解析与序列化（如平时用的比较多的json、gson、xml等等），支持Rxjava。一般我们在使用的网络的请求的时候都应该先想到它。

二、怎么用retrofit？

1、在manifest里面添加网络请求

    <uses-permission android:name="android.permission.INTERNET"/>

2、添加依赖（需要添加okhttp的库和retrofit自己的库）

    implementation 'com.squareup.okhttp3:okhttp:3.9.1'
    implementation 'com.squareup.retrofit2:retrofit:2.4.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.4.0'
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'

3、创建服务器返回的数据类

这个根据定义的规则和数据解析类型（xml格式、json格式），自己定义类。下面这个网站是把json格式转成实体类 json在线转成实体类

举个例子，访问接口给我返回的是json格式的数据如左下图，右下图为其对应的树在这里插入图片描述
（1）首先我们新建一个PelpleBean类。转换也挺简单的，一个对象对应一个类，相同的格式的数据就用对象数组转换就可以了。

public class PelpleBean{
    public Head head;
    public Content content;

    public Head getHead() {
        return head;
    }

    public void setHead(Head head) {
        this.head = head;
    }

    public class Head {
        private String cmd;

        private String result;

        private String describle;

        public void setCmd(String cmd) {
            this.cmd = cmd;
        }

        public String getCmd() {
            return this.cmd;
        }

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

        public String getResult() {
            return this.result;
        }

        public void setDescrible(String describle) {
            this.describle = describle;
        }

        public String getDescrible() {
            return this.describle;
        }
    }

    public class Content {
        public PeopleData[] data;
    }
}

（2）由于content的data里返回的是相同格式的数据，所以这种我一般喜欢分开来写，即创建一个PelpleData类，存放一些个体的特征。

public class PeopleData {
    private int i_id;

    private String p_name;

    private int p_age;

    private double p_height;

    public int getI_id() {
        return i_id;
    }

    public void setI_id(int i_id) {
        this.i_id = i_id;
    }

    public String getP_name() {
        return p_name;
    }

    public void setP_name(String p_name) {
        this.p_name = p_name;
    }

    public int getP_age() {
        return p_age;
    }

    public void setP_age(int p_age) {
        this.p_age = p_age;
    }

    public double getP_height() {
        return p_height;
    }

    public void setP_height(double p_height) {
        this.p_height = p_height;
    }

    @Override
    public String toString() {
        return "PeopleData{" +
                "i_id=" + i_id +
                ", p_name='" + p_name + '\'' +
                ", p_age=" + p_age +
                ", p_height=" + p_height +
                '}';
    }
}

这样对应的数据类就创建好啦，是不是还挺简单的。

4、创建注解，即用于描述网络请求的接口

retrofit是使用注解来描述网络请求的参数的，所以创建一个RetrofitService接口
在这里插入图片描述
在我用到的地方是用的post请求，表单的形式。当你请求的接口网址为

//这里网址我就随便写个了，主要是为了将其和注解接口对应起来
http://111.111.111.111:8089/PeopleApp?req=

我们可以把http://111.111.111.111:8089/抽取成公共的，即BaseURL，方便以后根据不同的ip地址调试

public interface RetrofitService {
  	// 注解里传入 网络请求的部分URL地址
    // Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里
    // 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略
    // getPeopleInfo()是接受网络请求数据的方法
    @FormUrlEncoded
    @POST("PeopleApp")
    //call
    Call<PeopleBean> getPeopleInfo(@Field("req") String param);
}

好了，前面的准备工作都已经准备就绪，接下来就到了具体的访问怎么访问了。

5、访问的具体逻辑

接下的就是在你需要用到的地方使用他就可以了，我们这里有个GetPeopleInfoActivity类去访问这个接口

public class GetPeopleInfoActivity extends AppCompatActivity {

    private List<PeopleData> peopleDataLists = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        request();
        // 使用Retrofit封装的方法
    }

    private void request() {
    //1、第一步拼接req的请求的json数据字符串
        JSONObject json_param = null;
        JSONObject json_content = new JSONObject();
	//这个拼接我就不讲怎么拼接了
        try {
            json_param = JsonUtils.getJsonParam(this, "get_people_info", json_content);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        
        //2、创建retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(Constant.BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
                
        // 3、创建网络请求接口的实例
        RetrofitService request = retrofit.create(RetrofitService.class);
        
        //4、对发送请求进行封装(即req的内容)
        Call<PeopleBean> call = request.getPeopleInfo(json_param.toString());
        
        //5、发送网络请求(异步)
        call.enqueue(new Callback<PeopleBean>() {
        
        //请求成功时回调
            @Override
            public void onResponse(Call<PeopleBean> call, Response<PeopleBean> response) {
            //这里的response就是返回的内容，然后访问你想访问的内容即可
                PeopleData[] peopledata = response.body().content.data;
                peopleDataLists.clear();
                for (PeopleData peo : peopledata) {
                    peopleDataLists.add(peo);
                }
                Log.e("TAG", "获取到的信息:  " + peopleDataLists);

            }
		//请求失败时回调
            @Override
            public void onFailure(Call<PeopleBean> call, Throwable t) {
                Log.e("TAG", "连接失败:  ");
            }
        });
    }
}

然后运行一下程序就大工告成啦！！！是不是还挺简单的呢。

三、什么是rxjava？

RxJava 是一种用于 Java 平台的响应式编程（Reactive Programming）库，它通过观察者模式（Observer Pattern）+ 数据流（Stream）的方式来处理异步事件和数据流。简单来说：
👉 RxJava = 用“流”的方式处理异步数据和事件的工具库。

3.1 rxjava核心思想

RxJava 的核心是：一切皆为数据流（Everything is a stream）。
例如这些都可以当作“流”处理：网络请求返回的数据、用户点击事件、数据库查询结果、定时器事件、文件读取。
RxJava 让你可以用链式方式处理这些数据流。

Observable.just("Hello", "RxJava")
    .map(s -> s + "!")
    .subscribe(System.out::println);

流程：
	数据源 → 转换(map) → 订阅(subscribe) → 输出结果

3.2 RxJava 的三个核心角色

1️⃣ Observable（被观察者 / 数据源）负责发送数据或事件。

Observable.just(1,2,3,4)

2️⃣ Observer（观察者）负责接收数据并处理。

Observer<Integer> observer = new Observer<Integer>() {
    @Override
    public void onNext(Integer value) {
        System.out.println(value);
    }
};

3️⃣ Subscribe（订阅）把 Observable 和 Observer 连接起来。

observable.subscribe(observer);

关系如下：

Observable  ——subscribe——>  Observer
   (发送数据)                  (接收数据)

3.3 RxJava 的主要特点

1️⃣ 异步处理：可以轻松实现异步任务。
例如：网络请求、IO 操作、数据库查询
2️⃣ 链式调用（函数式编程）

Observable.just(1,2,3)
    .map(x -> x * 2)
    .filter(x -> x > 2)
    .subscribe(System.out::println);

执行流程：

1,2,3
 ↓ map
2,4,6
 ↓ filter
4,6
 ↓ subscribe
输出

3️⃣ 线程控制：RxJava 可以非常简单地控制线程：

observable
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())

3.4 RxJava 的常见应用场景

1️⃣ 网络请求（结合 Retrofit）

api.getUser()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(user -> showUser(user));

2️⃣ UI 事件处理
例如：按钮点击、搜索输入、防抖处理
3️⃣ 多任务组合
例如：请求A → 请求B → 合并结果

四、rxjava+retrofit怎么用？

在上面使用的是 Retrofit 默认的 Call 方式进行网络请求：

Call<PeopleBean> call = request.getPeopleInfo(json_param.toString());
call.enqueue(...)

这种方式虽然简单，但如果项目中存在多个网络请求、线程切换、数据转换等复杂逻辑，代码会逐渐变得复杂。

4.1 Retrofit 结合 RxJava 的原理

Retrofit 本身是支持 RxJava 的，只需要通过：

.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

即可让接口返回 Observable / Flowable 等 RxJava 类型。
流程变为：

APP
 ↓
Retrofit
 ↓
OkHttp
 ↓
服务器
 ↓
Retrofit
 ↓
RxJava处理数据流
 ↓
APP

4.2 添加 RxJava 相关依赖

在 build.gradle 中增加 RxJava 依赖：

implementation 'io.reactivex.rxjava2:rxjava:2.2.21'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'

其中：
rxjava ：核心库
rxandroid ：Android 线程调度
adapter-rxjava2 ：Retrofit 适配 RxJava

4.3修改 Retrofit 配置

创建 Retrofit 时，需要增加 RxJava 适配器：

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl(Constant.BASE_URL)
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .build();

这里的关键是下面的代码，它让 Retrofit 的接口返回 Observable 类型。

.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

4.4修改接口返回类型

之前的接口：

Call<PeopleBean> getPeopleInfo(@Field("req") String param);

使用 RxJava 后改成：

@FormUrlEncoded
@POST("PeopleApp")
Observable<PeopleBean> getPeopleInfo(@Field("req") String param);

返回类型由：Call<T>变为了Observable<T>

4.5使用 RxJava 发起网络请求

在 Activity 中调用接口：

private void request() {

    JSONObject json_param = null;
    JSONObject json_content = new JSONObject();

    try {
        json_param = JsonUtils.getJsonParam(this, "get_people_info", json_content);
    } catch (JSONException e) {
        e.printStackTrace();
    }

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(Constant.BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build();

    RetrofitService request = retrofit.create(RetrofitService.class);

    request.getPeopleInfo(json_param.toString())
            .subscribeOn(Schedulers.io())   // 在IO线程执行网络请求
            .observeOn(AndroidSchedulers.mainThread())  // 在主线程接收数据
            .subscribe(new Observer<PeopleBean>() {

                @Override
                public void onSubscribe(Disposable d) {
                }

                @Override
                public void onNext(PeopleBean peopleBean) {

                    PeopleData[] peopledata = peopleBean.content.data;

                    peopleDataLists.clear();

                    for (PeopleData peo : peopledata) {
                        peopleDataLists.add(peo);
                    }

                    Log.e("TAG", "获取到的信息: " + peopleDataLists);
                }

                @Override
                public void onError(Throwable e) {
                    Log.e("TAG", "请求失败");
                }

                @Override
                public void onComplete() {
                }
            });
}

4.6 RxJava 的线程切换

RxJava 最大的优势之一就是线程控制非常简单。

.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())

4.7 Retrofit + RxJava 的优点

相比普通 Retrofit 请求，它具有以下优势：
1）代码更简洁
不需要写 Callback：call.enqueue(...)，而是链式调用subscribeOn → observeOn → subscribe
2）线程控制简单
线程切换只需要一行代码：observeOn(AndroidSchedulers.mainThread())
3）方便组合多个请求
请求A → 请求B → 合并结果

可以使用 RxJava 的操作符：
flatMap()
zip()
map()

华为开发者空间

华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。

更多推荐

GaussDB(DWS) SQL性能问题案例集

华为开发者空间

码道助阵：Hermes本地部署轻松搞定

华为开发者空间

【案例共创】CodeArts+SKILL 双引擎：AI 驱动 WEB 服务器极速部署

华为开发者空间

所有评论(0)

查看更多评论

Lane.Lin

@weixin_45552475

已为社区贡献4条内容

android——retrofit+rxjava超级详细讲解与使用

Lane.Lin

retrofit+rxjava使用

一、什么是Retrofit？

1、Retrofit的定义

2、具体的流程

3、Retrofit的作用

二、怎么用retrofit？

1、在manifest里面添加网络请求

2、添加依赖（需要添加okhttp的库和retrofit自己的库）

3、创建服务器返回的数据类

4、创建注解，即用于描述网络请求的接口

5、访问的具体逻辑

三、什么是rxjava？

3.1 rxjava核心思想

3.2 RxJava 的三个核心角色

3.3 RxJava 的主要特点

3.4 RxJava 的常见应用场景

四、rxjava+retrofit怎么用？

4.1 Retrofit 结合 RxJava 的原理

4.2 添加 RxJava 相关依赖

4.3修改 Retrofit 配置

4.4修改接口返回类型

4.5使用 RxJava 发起网络请求

4.6 RxJava 的线程切换

4.7 Retrofit + RxJava 的优点

所有评论(0)

温馨提示：您尚未绑定手机号

Lane.Lin