使用retrofit框架的网络请求方法使用例子，同时＋MVP ＋rxjava ＋ rxandroid使用

本文转自：http://blog.csdn.net/qq_16628781/article/details/51455320

关于使用retrofit框架的网络请求方法使用例子，同时＋MVP ＋rxjava ＋ rxandroid使用

今天去看了下关于一个新的网络请求框架－－retrofit，之前就已经了解和使用volley，okhttp和imageloader等网络请求框架，当然还有原生的http请求。这些各自有各自的优缺点。我这里就不做评论了，只做使用简介。

Retrofit是一个不错的网络请求库，用官方自己的介绍就是：

A type-safe REST client for Android and Java

这个网络请求框架，毕竟是Google的亲生儿子，支持什么的都很不错。

关于详细的retrofit请点击以下链接：

https://futurestud.io/blog/retrofit-getting-started-and-android-client#

点击打开链接

一开始入门的时候，找了不少资料，都是直奔用法的，一些语法之前没怎么看过，所以就显得不怎么看得懂。像是如何拼接url等等的语法，都不是直接 ＋ 的。第一次看起来很生涩难懂。例如：

[java] view plain copy

 

1. @GET("repos/{user}/{psw}/contributors")  
2.     Call<List<GithubUser>> getDataByLs(@Path("user") String user, @Path("psw") String psw);  

@GET -get方式请求数据???

(“repos/{user}/{psw}/contributors”) -???

@Path("user") String user -???

是不是很蒙？好多看不懂啊。。。。。

但是我这里给你一个解释的版本，让你好好理解：

[java] view plain copy

 

1. /** 
2.      * @GET 使用get方法请求数据 
3.      * 括号里面的是网站的后缀url地址 
4.      * 而在baseurl则是在retrofit里面设定了 
5.      * {user} ＝ 要传入的参数 由函数参数传参——》@Path("user") String user 
6.      * {psw} ＝ 要传入的参数 由函数参数传参——》@Path("psw") String psw 
7.      * 最后拼成的url地址为：https://api.github.com/repos/user/psw/contributors 
8.      * 
9.      * @param user user 
10.      * @param psw psw 
11.      * @return Call<List<GithubUser>> 
12.      */  
13.     @GET("repos/{user}/{psw}/contributors")  
14.     Call<List<GithubUser>> getDataByLs(@Path("user") String user, @Path("psw") String psw);  

更多详细的解释，请站在巨人的肩膀上吧：

http://blog.csdn.net/jiangxuqaz/article/details/50759239

点击打开链接

实例开始位置－－－－－－－－－－－－－－－－－－－－－－－－－－

首先在项目的build.gradle文件的dependencies加入gradle依赖包：

[html] view plain copy

 

1. compile 'io.reactivex:rxandroid:1.0.1'  
2.     compile 'io.reactivex:rxjava:1.0.14'  
3.   
4.     //retrofit  
5.     compile 'com.squareup.retrofit2:retrofit:2.0.0-beta4'  
6.     compile 'com.squareup.retrofit2:converter-gson:2.0.0-beta4'  
7.   
8.     //RxJava 适配器  
9.     compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4'  

我在项目里面使用的MVP ＋ Rxjava ＋ Rxandroid 的结构来做，以下是我的部分重要代码展示，解释直接看代码注释就好了。

首先你要知道请求回来的数据是什么类型的，比如gson类型的，retrofit默认的认为服务器返回的是gson格式的数据。所以我们首先要有一个bean。如下：

[java] view plain copy

 

1. /** 
2.  * bean类 
3.  * 
4.  * Created by kuyu.yaojt on 16/5/19. 
5.  */  
6. public class GithubUser {  
7.     private String login;  
8.     private int id;  
9.     private int contributions;  
10.   
11.     @Override  
12.     public String toString() {  
13.         return "GithubUser{" +  
14.                 "login='" + login + '\'' +  
15.                 ", id=" + id +  
16.                 ", contributions=" + contributions +  
17.                 '}';  
18.     }  
19.   
20.     public GithubUser(String login, int id, int contributions) {  
21.         this.login = login;  
22.         this.id = id;  
23.         this.contributions = contributions;  
24.     }  
25.   
26.     public String getLogin() {  
27.         return login;  
28.     }  
29.   
30.     public void setLogin(String login) {  
31.         this.login = login;  
32.     }  
33.   
34.     public int getId() {  
35.         return id;  
36.     }  
37.   
38.     public void setId(int id) {  
39.         this.id = id;  
40.     }  
41.   
42.     public int getContributions() {  
43.         return contributions;  
44.     }  
45.   
46.     public void setContributions(int contributions) {  
47.         this.contributions = contributions;  
48.     }  
49. }  

很简单的一个实体类，重写了tostring方法，用来打印实体类的全部属性，这个很实用。

然后定义一个方法的接口

[java] view plain copy

 

1. /** 
2.  * 请求github的接口 
3.  * 
4.  * Created by kuyu.yaojt on 16/5/19. 
5.  */  
6. public interface GitHubNetworkInterface {  
7.   
8.     /** 
9.      * @GET 使用get方法请求数据 
10.      * 括号里面的是网站的后缀url地址 
11.      * 而在baseurl则是在retrofit里面设定了 
12.      * {user} ＝ 要传入的参数 由函数参数传参——》@Path("user") String user 
13.      * {psw} ＝ 要传入的参数 由函数参数传参——》@Path("psw") String psw 
14.      * 最后拼成的url地址为：https://api.github.com/repos/user/psw/contributors 
15.      * 
16.      * @param user user 
17.      * @param psw psw 
18.      * @return Call<List<GithubUser>> 
19.      */  
20.     @GET("repos/{user}/{psw}/contributors")  
21.     Call<List<GithubUser>> getDataByLs(@Path("user") String user, @Path("psw") String psw);  
22. }  
23.   
24. 这里定义了一个接口。  
25. 为什么用接口来定义？我这里还有点模糊，待会看源码，求解释。  
26.   
27. 然后就是比较熟悉的MVP模式啦，依次创建M, V, P 的接口或者类，如果不太熟悉MVP的可以去百度一下MVP模式。  
28. 当然还有rxjava和rxandroid的观察者模式，我觉得这个还是挺好的，至少我们可以把代码解耦很多，结构也很清晰，虽然类多了n倍多。－－这方面不是很熟悉的，请去百度，这里不做过多解释。  
29.   
30. 在我的登陆页面的m里面  
31. /** 
32.  * 登陆页面的视图控制层 
33.  * 
34.  * Created by kuyu.yaojt on 16/5/14. 
35.  */  
36. public interface LoginView extends BaseCustomView{  
37.     void loginSuccess(JSONObject jsonObject);  
38.     void getDataSueecss(List<GithubUser> githubUserList);  
39. }  
40. 定义了一个取数据返回成功的接口方法getDataSueecss()，然后你要做的就是在activity里面实现这个接口，并做更新ui的操作。  
41. 我这里LoginView.java的实现是这样的：  
42. //接口实现  
43.  @Override  
44.     public void getDataSueecss(List<GithubUser> githubUserList) {  
45.         for(GithubUser githubUser : githubUserList){  
46.             System.out.println("-=-=-=-=>>toString() = " + githubUser.toString());  
47.         }  
48.         ToastUtils.makeText(this, "--->get Data From github Sueecss");  
49.     }  

仅仅是做一个打印和弹窗而已。

然后是m类LoginModel.java：

[java] view plain copy

 

1. /** 
2.  * 实际登陆操作类 
3.  * <p/> 
4.  * Created by tanksu on 16/5/4. 
5.  */  
6. public class LoginModel {  
7.     private int mCount;  
8.   
9.     private boolean mBoolean = true;  
10.   
11.     public LoginModel() {  
12.   
13.     }  
14.     /** 
15.      * 从Github上面获取数据 
16.      * 
17.      * @param name 
18.      * @param psw 
19.      * @return 
20.      */  
21.     public Observable<List<GithubUser>> getDataFromGithub(String name, String psw) {  
22.         Observable mOservable = Observable.create(new Observable.OnSubscribe<List<GithubUser>>() {  
23.             @Override  
24.             public void call(Subscriber<? super List<GithubUser>> subscriber) {  
25.                 Retrofit retrofit = new Retrofit.Builder()  
26.                         .baseUrl("https://api.github.com/")  
27.                         .addConverterFactory(GsonConverterFactory.create())//添加 json 转换器  
28.                         .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//添加 RxJava 适配器  
29.                         .build();  
30.                 //这里用到一个创建一个接口，来调用方法,请求网络  
31.                 //Create an implementation of the API endpoints defined by the {@code service} interface.  
32.                 GitHubNetworkInterface gitHub = retrofit.create(GitHubNetworkInterface.class);  
33.                 Call<List<GithubUser>> call = gitHub.getDataByLs("square", "retrofit");  
34.                 List<GithubUser> list = null;  
35.                 try {  
36.                     //execute() - 同步操作  
37.                     //enqueue(Callback<T> callback) - 异步操作－用不到了，因为在观察者模式里面已经设置了在非ui线程中执行操作  
38.                     //最后返回一个反序列化的结果  
39.                     list = call.execute().body();  
40.                 } catch (IOException e) {  
41.                     e.printStackTrace();  
42.                 }  
43.                 subscriber.onNext(list);  
44.                 subscriber.onCompleted();  
45.             }  
46.         });  
47.         return mOservable;  
48.     }  
49.   
50. }  

baseUrl(“https://api.github.com/“)－－指的是服务器的地址，一般来说都是不变的

retrofit就在这里用到了，详细请看代码。

还有一点很重要，就是关于网络请求的异步问题，我们在观察者模式中，就开启了异步请求方式，所以我们这里不用再开一条线程来做网络请求操作了。

我的p类LoginPresenter.java：

[java] view plain copy

 

1. public class LoginPresenter {  
2. private LoginView mLoginView;  
3.     private LoginModel mLoginModel;  
4.     private Context mContext;  
5.   
6.     /** 
7.      * 构造函数 
8.      * 
9.      * @param context 
10.      * @param baseCustomView 
11.      */  
12.     public LoginPresenter(Context context, LoginView baseCustomView) {  
13.         this.mContext = (Context) baseCustomView;  
14.         this.mLoginView = baseCustomView;  
15.         mLoginModel = new LoginModel();  
16.     }  
17.   
18. /** 
19.      * 在github上面获取数据 
20.      * 
21.      * @param name 
22.      * @param psw 
23.      */  
24.     public void getDataFromGithub(String name, String psw) {  
25.     // 设置个2000ms的延迟，模拟网络访问、数据库操作等等延时操作  
26.     SystemClock.sleep(2000);  
27.         mLoginView.showProgressDialog();//在activity实现的通用用户友好体验的提示  
28.         mLoginModel.getDataFromGithub(name, psw)  
29.                 .subscribeOn(Schedulers.io())//在非UI线程进行耗时操作  
30.                 .observeOn(AndroidSchedulers.mainThread())//在UI线程进行观察监听  
31.                 .subscribe(new Subscriber<List<GithubUser>>() {//开始订阅观察监听  
32.                     @Override  
33.                     public void onCompleted() {  
34.                         mLoginView.hideProgressDialog();  
35.                     }  
36.   
37.                     @Override  
38.                     public void onError(Throwable e) {  
39.                         mLoginView.showError("--->>" + e.getMessage());  
40.                         Toast.makeText(mContext, e.getMessage(), Toast.LENGTH_SHORT).show();  
41.                     }  
42.   
43.                     @Override  
44.                     public void onNext(List<GithubUser> githubUsers) {  
45.                         mLoginView.hideProgressDialog();  
46.                         mLoginView.getDataSueecss(githubUsers);  
47.                     }  
48.                 });  
49.     }  
50. }  

LoginPresenter是作为分发者的角色，m和v的唯一沟通协调人，因为我们在p里面所做的一切都是逻辑和消息分发处理，但是不做耗时的操作。耗时的操作是在m里面实现的。

这里采用了观察者模式， mLoginModel.getDataFromGithub(name, psw)

                .subscribeOn(Schedulers.io())

                .observeOn(AndroidSchedulers.mainThread())

                .subscribe()

－－这里的方法就是，解释都在代码里面。

实例结束位置－－－－－－－－－－－－－－－－－－－－－－－－－－

以上就是我个人对retrofit使用的个人见解，顺带说了下mvp， rxjava，rxandroid的小小使用，希望对各位有个引导学习进步作用。谢谢。

如有异议疑问，请与我联系。