Retrofit結合RxJava使用指南

bdg51847 8年前發布 | 16K 次閱讀 Retrofit RxJava

Retrofit是一個當前很流行的網絡請求庫, 官網的介紹是: "Type-safe HTTP client for Android and Java". 本文介紹Retrofit的使用.

先介紹單獨使用Retrofit進行網絡請求, 后面主要介紹和RxJava結合的請求, 有實例代碼.

Retrofit單獨使用

Setup

首先在manifest中加上網絡權限:

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

然后在 app/build.gradle 中加上依賴:

compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.google.code.gson:gson:2.8.0'
compile 'com.squareup.retrofit2:converter-gson:2.1.0'

準備API和model類

本例子中使用 Github API 做請求.

以Github的Root Endpoint為例:

https://api.github.com .

首先, 我們在命令行發送:

curl https://api.github.com

或者在Postman發送這個請求, 兩種方法都可以得到結果.

這個請求返回的是一個json.

利用這個網站: jsonschema2pojo , 可以用json生成一個java類, 比如上面這個, 我們給它起名字叫 Endpoints.java .

之后例子中的API都是這種方式, 先發送請求得到json, 然后轉成java的model類.

利用Retrofit發送請求并得到結果

首先寫一個 ServiceGenerator 類, 用于生成service:

public class ServiceGenerator {
    public static final String API_BASE_URL = "https://api.github.com";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    private static Retrofit.Builder builder =
            new Retrofit.Builder()
                    .baseUrl(API_BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create());

    public static <S> S createService(Class<S> serviceClass) {
        Retrofit retrofit = builder.client(httpClient.build()).build();
        return retrofit.create(serviceClass);
    }
}

這里指定了我們的base url.

createService() 方法返回的是一個泛型.

然后我們創建 GithubService , 注意這是一個接口 :

import com.ddmeng.helloretrofit.data.models.Endpoints;

import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Url;

public interface GitHubService {
    @GET
    Call<Endpoints> getAllEndpoints(@Url String url);
}

這里 @GET 指定了是一個GET請求, 因為我們請求的就是base url, 所以是這樣寫的.

Endpoints 類是這個請求所返回的json轉化的java類.

好了, 準備工作做完了, 現在就可以請求并得到結果:

請求github api的root url, 得到所有的endpoints:

GitHubService gitHubService = ServiceGenerator.createService(GitHubService.class);
Call<Endpoints> endpointsCall = gitHubService.getAllEndpoints("");
endpointsCall.enqueue(new Callback<Endpoints>() {
    @Override
    public void onResponse(Call<Endpoints> call, Response<Endpoints> response) {
        Endpoints endpoints = response.body();
        String repositoryUrl = endpoints.getRepositoryUrl();
        LogUtils.i(repositoryUrl);
        Toast.makeText(MainActivity.this, "repository url: " + repositoryUrl, Toast.LENGTH_LONG).show();
    }

    @Override
    public void onFailure(Call<Endpoints> call, Throwable t) {

    }
});

說明:

首先利用前面的ServiceGenerator來創建Service, 然后調用接口中定義的 getAllEndpoints() 方法, 此處傳入了空字符串, 因為我請求的就是base url.

同步和異步

這里注意用Retrofit請求的返回值是 Call<T> (后面我們還會介紹用RxJava的情形), 泛型T是model類型, 它有兩個方法:

execute() 是同步方法, 返回 Response<T> ;
enqueue() 是異步方法, 在上面的例子中用的就是這個, 在回調 onResponse() 中返回了 Response<T> .

Converter

Converter的作用: 如果不指定Converter, 默認情況下Retrofit只能返回 ResponseBody 類型, 加了Converter之后就可以返回我們定義的Model類型了.

所以Converter替我們做了json -> model的工作.

本例子中ConverterFactory指定的是 GsonConverterFactory . 這里我們選的是Gson Converter, 所以依賴的是 com.squareup.retrofit2:converter-gson .

Retrofit支持多種converters:

Gson: com.squareup.retrofit2:converter-gson
Jackson: com.squareup.retrofit2:converter-jackson
Moshi: com.squareup.retrofit2:converter-moshi
Protobuf: com.squareup.retrofit2:converter-protobuf
Wire: com.squareup.retrofit2:converter-wire
Simple XML: com.squareup.retrofit2:converter-simplexml
Scalars (primitives, boxed, and String): com.squareup.retrofit2:converter-scalars

Path和參數

從上面返回的endpoints可以看到, user_url是: https://api.github.com/users/{user}

這是一個帶path參數的url, 我們發請求的時候在{user}處寫一個github用戶名, 即可得到該用戶的信息, 比如:

https://api.github.com/users/mengdd .

那么用Retrofit如何處理呢?

只需要在 GithubService 中增加一個方法, 這樣寫:

public interface GitHubService {
    @GET
    Call<Endpoints> getAllEndpoints(@Url String url);

    @GET("users/{user}")
    Call<User> getUser(@Path("user") String user);
}

使用時的方法完全一樣, 不再贅述, 同理, 如果要在后面加參數, 可以用 @Query .

Retrofit + RxJava

RxJava近年來很流行, 主要優勢是流式操作, 可以處理并行發送請求, 使用靈活, 線程切換容易.

當你要處理的邏輯比較復雜時, 就會發現使用RxJava的優勢.

以我們的例子來說, 當前我們利用一個請求可以得到一個用戶的信息并顯示出來.

如果我們想得到這個用戶的所有repo的所有者或者其他信息, 所有他follow的人的信息, 以及他們的repo的信息呢?

這就需要發很多個請求, 并且其中有些請求是并行發送的, 如果按照前面的方法, 不斷地在callback里面嵌套, 那就太難看了.

Setup with RxJava

添加RxJava依賴

首先, 添加RxJava和RxAndroid的依賴:

compile 'io.reactivex:rxjava:1.2.2'
compile 'io.reactivex:rxandroid:1.2.1'

注: 雖然在我寫這篇文章的時候(2016.11.4)RxJava2.0剛剛release, 但是我們還是先用RxJava1來寫這個demo.

然后添加retrofit的adapter-rxjava:

compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'

所以現在我們的依賴總的看起來是這樣:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile "com.android.support:appcompat-v7:${supportLibVersion}"
    compile "com.android.support:design:${supportLibVersion}"
    compile "com.jakewharton:butterknife:${butterKnifeVersion}"
    apt "com.jakewharton:butterknife-compiler:${butterKnifeVersion}"
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.google.code.gson:gson:2.8.0'
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
    compile 'io.reactivex:rxjava:1.2.2'
    compile 'io.reactivex:rxandroid:1.2.1'
    testCompile 'junit:junit:4.12'
}

Retrofit結合RxJava

Retrofit.Builder()中加入這一行:

.addCallAdapterFactory(RxJavaCallAdapterFactory.create());

ServiceGenerator變成這樣:

public class ServiceGenerator {
    public static final String API_BASE_URL = "https://api.github.com";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    private static Retrofit.Builder builder =
            new Retrofit.Builder()
                    .baseUrl(API_BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create());

    public static <S> S createService(Class<S> serviceClass) {
        Retrofit retrofit = builder.client(httpClient.build()).build();
        return retrofit.create(serviceClass);
    }
}

這樣我們在 GithubService 中定義的接口方法, 既可以像原來一樣返回 Call , 也可以返回 Observable .

Retrofit + RxJava請求實例

以單個請求為例,

不用RxJava的時候:

@GET("users/{user}/following")
Call<List<User>> getUserFollowing(@Path("user") String user);

請求的時候是這樣的:

請求指定用戶follow的所有人:

GitHubService service = ServiceGenerator.createService(GitHubService.class);
Call<List<User>> userFollowing = service.getUserFollowing(inputUserNameView.getText().toString());
userFollowing.enqueue(new Callback<List<User>>() {
    @Override
    public void onResponse(Call<List<User>> call, Response<List<User>> response) {
        List<User> followingUsers = response.body();
        peopleListAdapter.setUsers(followingUsers);
        peopleListAdapter.notifyDataSetChanged();
    }

    @Override
    public void onFailure(Call<List<User>> call, Throwable t) {

    }
});

現在改用RxJava了, 返回的不是Call而是Observable:

@GET("users/{user}/following")
Observable<List<User>> getUserFollowingObservable(@Path("user") String user);

結合RxJava請求的時候變為這樣:

還是請求用戶follow的所有人:

GitHubService service = ServiceGenerator.createService(GitHubService.class);
String username = inputUserNameView.getText().toString();
service.getUserFollowingObservable(username)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber<List<User>>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(List<User> users) {
                LogUtils.i("onNext: " + users.size());
                peopleListAdapter.setUsers(users);
                peopleListAdapter.notifyDataSetChanged();
            }
        });

用RxJava實現后, 請求返回的是一個Observable, 用 subscribe() 添加一個訂閱者, 即它的觀察者.

當請求返回后, 回到主線程, 更新UI.

這是單個請求的例子, 所以RxJava的優勢不是很明顯, 如果我們有多個請求, 用RxJava進行變換組合顯然就是更好的選擇.

用RxJava進行線程切換

上個例子中 .subscribeOn(Schedulers.io()) 指定Observable的工作, 在我們的例子中Observable的工作即發送請求, 在io線程做, 指定了被觀察者的處理線程;

.observeOn(AndroidSchedulers.mainThread()) 指定最后onNext()回調在主線程, 即指定了通知后續觀察者的線程.

RxJava處理多個請求的例子

設計這樣一個場景, 我們現在取到了一個用戶follow的所有人, 但是取回的信息中并不包含每個人擁有的repo個數, 只有一個url可用戶查看所有repo.

接下來我們要取其中每一個人的詳細信息, 就要查詢另一個API, 重新查詢這個人的完整信息.

查詢用戶follow的所有人, 然后查詢每一個人的詳細信息:

subscription = service.getUserFollowingObservable(username)
        .flatMap(new Func1<List<User>, Observable<User>>() {
            @Override
            public Observable<User> call(List<User> users) {
                return Observable.from(users);
            }
        })
        .flatMap(new Func1<User, Observable<User>>() {
            @Override
            public Observable<User> call(User user) {
                return service.getUserObservable(user.getLogin());
            }
        })
        .toList()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber<List<User>>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(List<User> users) {
                peopleListAdapter.setUsers(users);
                peopleListAdapter.notifyDataSetChanged();
            }
        });

可以看到我們加了兩個 flatMap() 和一個 toList() 來做這個事情.

首先, 第一步我們用 getUserFollowingObservable() 得到的是一個 Observable<List<User>> ;

我們之后用 .flatMap() , 它的輸入是 List<User> , 返回的是 Observable<User> . 我們在其中用了一個 .from() 來生成一個發射一組User的 Observable ;

之后第二個 .flatMap() 里, 輸入是前一個 Observable 的輸出, 即User, 調用了 getUserObservable() , 返回的結果是 Observable<User> , 之后加一個 .toList() , 把輸出的結果從單個的User變為List , 即和我們最初的例子一樣.

只不過此時得到的用戶信息是更詳細的用戶信息, 包含了他的repo數據和follow數據. 因為它們是通過單獨查詢每一個人得到的.

運行, 雖然可以得到我們想要的結果, 但是這個例子仍然是有問題的.

線程問題處理

上面多個請求的例子, 發現雖然實現了我們的需求, 但是結果回來得很慢.

我們加上一個 .map 操作符來加上log:

(這里省略了一些前后的代碼, 只是在 .flatMap() 里加了一個 .map() )

...
subscription = service.getUserFollowingObservable(username)
        .flatMap(new Func1<List<User>, Observable<User>>() {
            @Override
            public Observable<User> call(List<User> users) {
                return Observable.from(users);
            }
        })
        .flatMap(new Func1<User, Observable<User>>() {
            @Override
            public Observable<User> call(User user) {
                return service.getUserObservable(user.getLogin())
                        .map(new Func1<User, User>() {
                            @Override
                            public User call(User user) {
                                // this .map is used to output log information to check the threads
                                LogUtils.i("getUserObservable: " + user.getLogin());
                                return user;
                            }
                        });
            }
        })
        .toList()
        ...

由Log可以發現(log中的線程號是一樣的)單獨取每一個用戶詳細信息的請求都發生在同一個線程, 是順次進行的.

回頭梳理一下我們的需求, 請求一個所有follow的人, 返回一個follow的人的List, 然后對List中的每一個人, 單獨請求詳細信息.

那么按理來說, 第二個批量的請求是可以同時發送, 并行進行的.

所以我們想要的行為其實是平行發送多個請求, 然后最后統一結果到UI線程.

改動如下:

subscription = service.getUserFollowingObservable(username)
        .subscribeOn(Schedulers.io()) // 從io線程開始, 取用戶follow的所有人
        .flatMap(new Func1<List<User>, Observable<User>>() {
            @Override
            public Observable<User> call(List<User> users) {
                LogUtils.i("from");
                return Observable.from(users);
            }
        })
        .flatMap(new Func1<User, Observable<User>>() {
            @Override
            public Observable<User> call(User user) {
                return service.getUserObservable(user.getLogin()) // 取每個人的詳細信息
                        .subscribeOn(Schedulers.io()) // 指定取每個人詳細信息的工作都在單獨的io線程
                        .map(new Func1<User, User>() {
                            @Override
                            public User call(User user) {
                                // this map operation is just used for showing log
                                LogUtils.i("getUserObservable: " + user.getLogin());
                                return user;
                            }
                        });
            }
        })
        .toList()
        .observeOn(AndroidSchedulers.mainThread()) // 最后返回到主線程
        .subscribe(new Subscriber<List<User>>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(List<User> users) {
                LogUtils.i("onNext: " + users.size());
                peopleListAdapter.setUsers(users);
                peopleListAdapter.notifyDataSetChanged();
            }
        })

給改動的部分加上了注釋, 這樣更清楚一些.

注意 subscribeOn() 指定的是當前的這個Observable的工作在什么線程進行.

所以在本例子中, subscribeOn(Schedulers.io()) 的位置放在 .flatMap() 里面才會產生多個請求并行的效果.

這樣一改, 我們的顯示時間不再是所有請求時間之和, 而是只取決于最慢的那個請求時間.

取消訂閱

正常情況下, 行為結束之后, 到達 onComplete() 或者 onError() , RxJava的訂閱會自動取消.

但是在處理網絡請求的時候, 很可能會出現請求還沒有返回, 界面就已經結束了的情況.

上面的代碼中已經出現了, 訂閱方法 subscribe() 的返回值是一個 Subscription 對象, 我們保存了這個對象的引用, 然后在 onPause() 的時候取消了請求, 防止內存泄露.

@Override
public void onPause() {
    super.onPause();
    if (subscription != null && subscription.isUnsubscribed()) {
        subscription.unsubscribe();
    }
}

當然也可以選別的生命周期回調, 比如 onDestroyView() 或者 onDestroy() .

如果有多個請求, 可以用:

private CompositeSubscription compositeSubscription = new CompositeSubscription();

...
// 在發請求的地方, 返回subscription
compositeSubscription.add(subscription);
...

// 選一個生命周期注銷所有請求
@Override
public void onPause() {
    super.onPause();
    compositeSubscription.unsubscribe();
}

References

來自：http://www.cnblogs.com/mengdd/p/6047948.html

本文由用戶 bdg51847 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1478758197529.html

Retrofit RxJava