Android ⽹络请求库的使⽤okhttp、retrofit、rxjava_android okhttp retrofit rxjava

---

前言

安卓逆向的必经之路，首先进行app的请求中的基本原理，以及实操！

一、okhttp

OkHttp 是一套处理 HTTP 网络请求的依赖库，由 Square 公司设计研发并开源，目前可以在 Java 和 Kotlin 中使用。对于 Android App 来说，OkHttp 现在几乎已经占据了所有的网络请求操作，RetroFit + OkHttp 实现网络请求似乎成了一种标配。因此它也是每一个 Android 开发工程师的必备技能，了解其内部实现原理可以更好地进行功能扩展、封装以及优化。

1、添加网络请求权限

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

2、添加依赖库

dependencies {
    implementation 'com.squareup.okhttp3:okhttp:4.9.1'
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
    implementation 'io.reactivex.rxjava2:rxjava:2.2.20'
}
1
2
3
4
5
6
7
8

并进行同步

3、编写布局以及点击事件

4、监听事件

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private final OkHttpClient client = new OkHttpClient();
    private static final String Tag = "good idea";

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

        findViewById(R.id.btn_test).setOnClickListener(this);
    }


    @Override
    public void onClick(View v) {
        okhttpDemo();

    }

    void okhttpDemo(){
        new  Thread(new Runnable() {
            @Override
            public void run() {
                Log.d(Tag,"okhttpStart:");
                String  url ="https://www.baidu.com";
                Request request = new Request.Builder()
                        .url(url)
                        .build();

                try {
                    Response response = client.newCall(request).execute();
                    Log.d(Tag,"okhttpDemo:"+response.body().string());
                }catch (Exception e){
                    e.printStackTrace();

                }
            }
        }).start();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

5、返回结果

6、okhttp的get传参

void okhttpParams(){     //对于get请求   拼接请求参数
    HttpUrl.Builder builder = HttpUrl.parse("https://reqres.in/api/users").newBuilder();
    builder.addQueryParameter("page","2");
    String url = builder.build().toString();
    Log.d(TAG, "okhttpParams: " + url);
}
1
2
3
4
5
6

7、okhttp的post传参

void okhttpPostDemo(){
    RequestBody body = new FormBody.Builder()
            .add("name","111")
            .add("job","222")
            .build();

    Request request = new Request.Builder().url("https://reqres.in/api/users")
            .post(body).build();

    tvContent.setText("请求中......");
    client.newCall(request).enqueue(new Callback() {
        @Override
        public void onFailure(@NotNull Call call, @NotNull IOException e) {
            Log.d(TAG, "onFailure:请求失败");
        }

        @Override
        public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
            Log.d(TAG, "onResponse:" + response.body().string());
            runOnUiThread(new Runnable() {  //更新UI不能在⼦线程当中, 必须在主线程当中
                @Override
                public void run() {
                    tvContent.setText("请求返回的状态码为:" + response.code());
                }
            });
        }
    });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

8、okhttp 的拦截器

public class LoggingInterceptor implements Interceptor {
    private static final String Tag = "good idea";

    @NotNull
    @Override
    public Response intercept(@NotNull Chain chain) throws IOException {
        Request request = chain.request();
        long t1 = System.nanoTime();
        Response response = chain.proceed(request);
        long t2 = System.nanoTime();
        Log.d(Tag,"interceptor"+(t2-t1));

        return response;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

二、retrofit

Retrofit并没有改变网络请求的本质，也无需改变，因为Okhttp已经足够强大，Retrofit的封装可以说是很强大，里
面涉及到一堆的设计模式,可以通过注解直接配置请求，可以使用不同的http客户端，虽然默认是用http ，可以使用
不同Json Converter 来序列化数据，同时提供对RxJava的支持，使用Retrofit + OkHttp + RxJava 可以说是目前比较
潮的一套框架，但是需要有比较高的门槛。

1、get请求

void okhttpAsyncDemo(){   
        Request request = new Request.Builder().url("https://www.baidu.com").build();
        tvContent.setText("请求中......");

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {   //请求失败的情况下走这个回调
                Log.d(Tag, "onFailure:请求失败");
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {   //请求成功的情况下走这个回调
                Log.d(Tag, "onResponse:" + response.body().string());
                runOnUiThread(new Runnable() {  //更新UI不能在⼦线程当中
                    @Override
                    public void run() {
                        tvContent.setText("请求返回的状态码为:" + response.code());
                    }
                });
            }
        });
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2、post请求

public class UserBean {
    @SerializedName("name")
    String name;
}
1
2
3
4

public interface ApiService {
    @GET("api/users")
    Call<PageResponceBean> listUsers(@Query("page") Integer page);

    @POST("api/users")
    @FormUrlEncoded
    Call<UserBean> createUser(@Field("name") String name,@Field("job") String job);
}
1
2
3
4
5
6
7
8

void retorfitPostDemo(){
    tvContent.setText("请求中。。。。");
    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://reqres.in")
            .addConverterFactory(GsonConverterFactory.create())
            .build();
    retrofit.create(ApiService.class).createUser("good idea","developer").enqueue(new retrofit2.Callback<UserBean>() {
        @Override
        public void onResponse(retrofit2.Call<UserBean> call, retrofit2.Response<UserBean> response) {
            Log.d(Tag, "onResponse:" + response.body().name);
            tvContent.setText("请求返回的状态码为:" + response.code());
        }

        @Override
        public void onFailure(retrofit2.Call<UserBean> call, Throwable t) {

        }
    });

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

三、rxjava

RxJava 是将事件从起点（上游）流向终点（下游），中间有很多卡片对数据进操作并传递，每个卡片获取上一个卡片传递下来的结果然后对事件进行处理然后将结果传递给下一个卡片，这样事件就从起点通过卡片一次次传递直到流向终点。类似于装饰器的一个东西。

1、rxjava的get请求

public interface ApiService {
    @GET("api/users")
    Call<PageResponceBean> listUsers(@Query("page") Integer page);

    @POST("api/users")
    @FormUrlEncoded
    Call<UserBean> createUser(@Field("name") String name,@Field("job") String job);

    @GET("api/users")
    Observable<PageResponceBean> rxListUsers(@Query("page") Integer page);

    @POST("api/users")
    @FormUrlEncoded
    Observable<UserBean> rxcreateUser(@Field("name") String name,@Field("job") String job);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void rxJavaGetDemo(){

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://reqres.in")
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())   //多添加一个rxjava的支持
            .build();

    retrofit.create(ApiService.class).rxListUsers(2)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<PageResponceBean>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                    tvContent.setText("请求中。。。。");
                }

                @Override
                public void onNext(@NonNull PageResponceBean pageResponceBean) {
                    Log.d(Tag, "onResponse:" + pageResponceBean.totalPages);
                }

                @Override
                public void onError(@NonNull Throwable e) {

                }

                @Override
                public void onComplete() {
                    tvContent.setText("请求完成");
                }
            });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2、rxjava的post请求

void rxJavaPostDemo(){

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://reqres.in")
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())   //多添加一个rxjava的支持
            .build();

    retrofit.create(ApiService.class).rxcreateUser("good idea","developer")
            .subscribeOn(Schedulers.io())  //切换线程
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<UserBean>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                    tvContent.setText("请求中。。。。");
                }

                @Override
                public void onNext(@NonNull UserBean userBean) {
                    tvContent.setText("用户创建成功:"+userBean.name);
                }

                @Override
                public void onError(@NonNull Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

总结

okhttp,retrofit,rxjava 三者的区别总结
1、Okhttp底层是socket 而retrofit,rxjava 都是基于okhttp的。
2、retrofit,rxjava 相对来说繁琐一些，但是更加安全，对字段进行了规定直接返回序列号对象。
3、对于做爬虫的我们更多关注点是apiservice中，还有拦截器中添加一些参数。
3、其他的希望大家也补充一些。