注意

Retrofit 2.0+和Retrofit 2.0之前的版本语法上有差别，本文基于Retrofit2.1.0

什么是Retrofit?

retrofit是一款针对Android网络请求的开源框架，它与okhttp一样出自Square公司。Rotrofit2.0的网络框架全部交给了okhttp来实现，Android N之后Apache的httpclient已经被Google从SDK中移除，Okhttp则成功上位。Retrofit的网络请求实现风格与URLconnection和httpClient有较大的差别。创建请求的时候需要先创建基于注解的服务接口（不了解的可以先了解一下注解），进行网络请求的时候再通过retrofit.creat()方法创建请求。

Retrofit中http POST/GET请求

Retrofit中的网络请求都是通过注解方式的接口方法来表示的,此处只对常用的post和get请求进行说明，Retrofit还提供有put，delete等请求方式可自己研究文档使用

post请求

• Body对象作为post参数

@POST("user/login")
Call<User> login(@Body LoginInfo loginInfo);

• Field方式

@FormUrlEncoded
@POST("user/login")
Call<User> login(@Field("username") String username,
                 @Field(password) String password);

• FieldMap方式

@FormUrlEncoded
@POST("user/login")
Call<User> login(@FieldMap Map<String,String> map);

参数较多时建议用Body方式和FieldMap方式

get请求

• 直接请求某一地址获取列表

//接口我瞎写的
@GET("news/toplist")
Call<ArrayList<News> news> getNewsList(); 

• url拼接固定查询条件

@GET("news/toplist?date=20161030")
Call<ArrayList<News> news> getNewsList(); 

• url中拼接地址信息

@GEt("news/{city}/newslist")
Call<ArrayList<News> news> getCityNewsList(@Path("city") String city);

• 通过Query注解添加其他查询条件

@GET("news/{city}/newslist")
Call<ArrayList<News> news> getCityNewsList(@Path("city") String city
                                           @Query("date") String date
                                           @Query("newsType") String newsType);

• 查询条件较多时同样有QueryMap注解方法供使用

@GET("news/{city}/newslist")
Call<ArrayList<News> news> getCityNewsList(@Path("city") String city
                                           @QueryMap<String, String> options);

通过上面的API方法会发现都是在进行请求条件的配置，假如我要给请求加请求头怎么办？放心，retrofit也有相应的注解。除了注解之外还有一个万用的处理方法。

Header请求头设置

• 为请求添加固定请求头

//添加单个固定请求头
@Header("Cache-Control: max-aget-640000")
@GET("news/toplist?date=20161030")
Call<ArrayList<News> news> getNewsList(); 
//多个请求头以数组的形式提交
@Header(
    {"Accept: application/vnd.github.v3.full+json",
    "User-Agent: Retrofit-Sample-App"
    })
@GET("news/toplist?date=20161030")
Call<ArrayList<News> news> getNewsList(); 

• 动态添加请求头

//添加动态请求头，比如获取的认证信息等
@GET("news/toplist?date=20161030")
Call<ArrayList<News> news> getNewsList(@Header(Authorization) String authorization); 

上面的两种添加请求头的方法作用范围只是添加注解的单个方法，如果想为每个请求都添加请求头还按这种方式来做的话就很不程序猿了。Retrofit的网络请求全部交给okhttp来处理，因此我们可以通过OkHttpClient来做文章，自己重写okhttp的拦截器在拦截器内再进行需要的操作

Okhttp interceptor

拦截器顾名思义，所有通过okhttp进行的请求都会过一遍okhttpClient的拦截器，发出去的请求，收到的响应都会经过他，就像一个双向的安检通道。
okhttp拦截器的原理如下：

如图所示拦截器分为Application Interceptors和NetWork Interceptors。Application拦截器工作区域为应用发出请求到okhttp核心之间，远端响应经过okhttp核心后到达应用处理之前。而NetWork拦截器的作用域为okhtt核心到远端服务器之间的部分。明显区别就是当一次请求中会有一个重定向的时候Application拦截器只会响应一次，因为对于应用来说就进行了一次请求。而NetWork拦截器会在重定向时也响应即响应两次，也不难理解，毕竟重定向也会经过一次okhttp核心嘛。

上图是okhttp拦截器工作原理简图，重点在右边部分。当多个拦截器配合使用时，不用担心请求拦截和响应拦截顺序会错乱，okhttp已经给你排好了。

原理扯了一大堆，代码才是干货，看了代码才知道怎么用。

//官方的栗子
class LoggingInterceptor implements Interceptor {
        @Override
        public Response intercept(Interceptor.Chain chain) throws IOException {
         //拿到request实例在此对请求做需要的设置
            Request request = chain.request();
            long t1 = System.nanoTime();
            logger.info(String.format("Sending request %s on %s%n%s",
                    request.url(), chain.connection(), request.headers()));
            //发送request请求
            Response response = chain.proceed(request);
            //得到请求后的response实例，做相应操作
            long t2 = System.nanoTime();
            logger.info(String.format("Received response for %s in %.1fms%n%s",
                    response.request().url(), (t2 - t1) / 1e6d, response.headers()));
            return response;
        }
    }

通过Request request = chain.request();拿到请求实例，想怎么装扮就怎么装扮，什么加请求头，设置编码格式soeasy。前面说到的为每个请求设置请求头就是在这完成设置工作的。但是真正要加到请求里跟retrofit的ApiService接口一起用还需要将Okhttp注册拦截器后与Retrofit绑定才行。

//注册应用拦截器
OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(new LoggingInterceptor())
    .build();
Request request = new Request.Builder()
    .url("http://www.publicobject.com/helloworld.txt")
    .header("User-Agent", "OkHttp Example")
    .build();··
Response response = client.newCall(request).execute();
response.body().close();

//注册网络拦截器
OkHttpClient client = new OkHttpClient.Builder()
    .addNetworkInterceptor(new LoggingInterceptor())
    .build();
Request request = new Request.Builder()
    .url("http://www.publicobject.com/helloworld.txt")
    .header("User-Agent", "OkHttp Example")
    .build();
Response response = client.newCall(request).execute();
response.body().close();

该如何使用Retrofit?

基本也说得差不多了，那么怎么使用Retrofit进行一次完整的网络请求呢
需要注意一下Retrofit的Url拼接规则

• 1、当然是引入retrofit的库啦

//build.gradle的依赖中加入，其中第二条不一定要使用gson，其他方式在官方的github上也有
// retrofit
compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:converter-gson:2.1.0'
compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'

• 2、创建一个ServiceApi接口

//方便后面RxAndroid我把RxAndroid方式的接口也贴上来。只有返回类型不同而已
public interface RetrofitService {
    //单纯使用retrofit接口定义
    @GET("news/latest")
    Call<ZhiHuDaily> getZhihuDailyRetrofitOnly();

    //使用retrofit+RxAndroid的接口定义
    @GET("news/latest")
    Observable<ZhiHuDaily> getZhihuDaily();
}

• 3、我建议是维护一个统一的api管理类。当然你要直接拿接口用也行，但可维护性会降低很多

public class ApiManager {

    private RetrofitService mDailyApi;
    private static ApiManager sApiManager;
    //获取ApiManager的单例
    public static ApiManager getInstence() {
        if (sApiManager == null) {
            synchronized (ApiManager.class) {
                if (sApiManager == null) {
                    sApiManager = new ApiManager();
                }
            }
        }
        return sApiManager;
    }
    /**
     * 封装配置知乎API
     */
    public RetrofitService getDailyService() {
    //不需要使用拦截器就不创建直接从if开始
        OkHttpClient client = new OkHttpClient.Builder()
                //添加应用拦截器
                .addInterceptor(new MyOkhttpInterceptor())
                //添加网络拦截器
//                .addNetworkInterceptor(new MyOkhttpInterceptor())
                .build();
        if (mDailyApi == null) {
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(GlobalConfig.baseUrl)
                    //将client与retrofit关联
                    .client(client)
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
            //到这一步创建完成
            mDailyApi = retrofit.create(RetrofitService.class);
        }
        return mDailyApi;
    }
}

• 4、调用接口方法进行网络请求

    public void getStoryDataByRetrofit(final OnEventLister<ArrayList<ZhihuStory>> eventLister) {
        ApiManager apiManager = ApiManager.getInstence();
        Call<ZhiHuDaily> call = apiManager.getDailyService().getZhihuDailyRetrofitOnly();
        //发送异步请求
        call.enqueue(new Callback<ZhiHuDaily>() {
            @Override
            public void onResponse(Call<ZhiHuDaily> call, Response<ZhiHuDaily> response) {
                eventLister.onSuccess(response.body().getStories());
            }

            @Override
            public void onFailure(Call<ZhiHuDaily> call, Throwable t) {
                eventLister.onFail(t.getMessage(), "");
            }
        });
    }

使用Retrofit的好处

• 可以少写不少的代码
• 接口方便维护需要改什么直接到ApiService中进行配置即可
• 异步请求不再需要自己来newThread再handler，也不需要自己再来写请求结果回调。异步请求只需要使用call.enqueue()即可。
• 支持RxAndroid，这个我觉得很重要
• 降低工程的耦合度，网络请求跟逻辑代码完全剥离开。需要的仅仅是传递参数有的请求甚至参数都不需要传递。直接在接口中配置就好。

Retrofit的好基友——RxAndroid

RxAndroid是RxJava在Android上的变种。那么RxJava到底是什么呢？
"a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这是github项目主页的自我概括，我觉得其实就两个关键词，异步、基于事件。这里我只说一下RxAndroid怎么跟Retrofit搭配使用，要进一步了解可以异步扔物线大神的文章给 Android 开发者的 RxJava 详解。讲的肯定比我好，我就是看这个入门的。

Retrofit+RxAndroid使用

因为用到Retrofit所以定义接口，创建ApiManager这些跟上面单纯用Retrofit是一毛一样的，唯一的不同是接口的返回类型从Retrofit的Call对象变成了Observable对象，即被观察者对象。然后就是调用进行网络请求部分变成如下形式

    //使用rxandroid+retrofit进行请求
    public void loadDataByRxandroidRetrofit() {
        mIMainActivity.showProgressBar();
        Subscription subscription = ApiManager.getInstence().getDailyService()
                .getZhihuDaily()
                .map(new Func1<ZhiHuDaily, ArrayList<ZhihuStory>>() {
                    @Override
                    public ArrayList<ZhihuStory> call(ZhiHuDaily zhiHuDaily) {
                        return zhiHuDaily.getStories();
                    }
                })
                //设置事件触发在非主线程
                .subscribeOn(Schedulers.io())
                //设置事件接受在UI线程以达到UI显示的目的
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<ArrayList<ZhihuStory>>() {
                    @Override
                    public void onCompleted() {
                        mIMainActivity.hidProgressBar();
                    }

                    @Override
                    public void onError(Throwable e) {
                        mIMainActivity.getDataFail("", e.getMessage());
                    }

                    @Override
                    public void onNext(ArrayList<ZhihuStory> stories) {
                        mIMainActivity.getDataSuccess(stories);
                    }
                });
        //绑定观察对象，注意在界面的ondestory或者onpouse方法中调用presenter.unsubcription();进行解绑避免内存泄漏
        addSubscription(subscription);
    }

网络请求得到的是一个Obserable对象，该对象再通过subscrible()绑定一个观察者对象，观察者对象中有onCompleted(),onError(),onNext()三个回调方法。事件过程中出错onError()触发并停止后续事件，一个Obserable对象一次发出多个事件每次都会触发onNext()，当不再有事件发出的时候onCompleted()方法触发并结束。异步在RxAndroid中变得很简单subscribeOn指定事件发生线程，如上面的网络请求被指定在io线程中，observeOn指定事件的消费线程，如上面的知乎故事数据结果被交给主线程显示。

RxAndroid的优点

看完上面单独使用retrofit和使用retrofit+rxandroid两种方式之后你也许会吐槽，尼玛脑子有坑？明明代码变多了。
但是你也会发现代码中都是.XX()的形式如果需求变化更多一些会更明显。比如说就上面的例子我要在每一条信息中修改某一个值。并且又要对结果进行一些筛选。只用retrofit的话是不是应该向这样：

    call.enqueue(new Callback<ZhiHuDaily>() {
        @Override
        public void onResponse(Call<ZhiHuDaily> call, Response<ZhiHuDaily> response) {
            ArrayList<ZhihuStory> stories = response.body().getStories();
            for(ZhihuStory story : stories){
                //修改每一条story中的某一值,这里用XXX代替
                story.setXXX(XXX);
                //筛选出id<100的
                if(story.getId()>100){
                    stories.remove(story);
                }
            }
            eventLister.onSuccess(response.body().getStories());
        }

        @Override
        public void onFailure(Call<ZhiHuDaily> call, Throwable t) {
            eventLister.onFail(t.getMessage(), "");
        }
    });

如果需要设置和条件赛选层次越多会发现for套if，if再if会越嵌套越多。隔一段时间之后就真的成了“当初写下这段代码的时候只有我跟上帝知道他是干嘛的，现在只有上帝知道他是干嘛的”。而使用RxAndroid的话整个变换过程都是线性的哪一步做了什么都会很清楚不会出现各种蜜汁缩进：

        Subscription subscription = ApiManager.getInstence().getDailyService()
                .getZhihuDaily()
                //从ZhihuDaily中获取Stories列表
                .map(new Func1<ZhiHuDaily, ArrayList<ZhihuStory>>() {
                    @Override
                    public ArrayList<ZhihuStory> call(ZhiHuDaily zhiHuDaily) {
                        return zhiHuDaily.getStories();
                    }
                })
                //将列表拆开成事件发送
                .flatMap(new Func1<ArrayList<ZhihuStory>, Observable<ZhihuStory>>() {
                    @Override
                    public Observable<ZhihuStory> call(ArrayList<ZhihuStory> stories) {
                        return Observable.from(stories);
                    }
                })
                //将story中的XXX设置为xxx
                .map(new Func1<ZhihuStory, ZhihuStory>() {
                    @Override
                    public ZhihuStory call(ZhihuStory zhihuStory) {
                        zhihuStory.setXXX(xxx);
                        return zhihuStory;
                    }
                })
                //过滤掉Id>10的story
                .filter(new Func1<ZhihuStory, Boolean>() {
                    @Override
                    public Boolean call(ZhihuStory zhihuStory) {
                        return zhihuStory.getId()<10;
                    }
                })
                //将结果重新整理成List
                .toList()
                //设置事件触发在非主线程
                .subscribeOn(Schedulers.io())
                //设置事件接受在UI线程以达到UI显示的目的
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<List<ZhihuStory>>() {
                    @Override
                    public void onCompleted() {
                        mIMainActivity.hidProgressBar();
                    }

                    @Override
                    public void onError(Throwable e) {
                        mIMainActivity.getDataFail("", e.getMessage());
                    }

                    @Override
                    public void onNext(List<ZhihuStory> stories) {
                        mIMainActivity.getDataSuccess((ArrayList<ZhihuStory>) stories);
                    }
                });

越复杂的逻辑，Rx的优势也就越明显。Rx的操作符各种组合起来几乎能够满足所有的变换需求。开始写可能会觉得很不适应，但熟练使用之后会默念Rx大法好的。
对于RxJava操作符鼠标悬停都会有文字和示意图的，另外发现一个不错的博客里面也有较详细的解析RxJava/RxAndroid操作符

Demo地址

在之前的那个MVPDemo的基础上写的，okhttp请求方式，单纯retrofit方式，retrofit+rxAndroid方式的请求都有保留，可以对比着感受一下。
demo仓库地址

觉得本文对你有帮助

关注简书PandaQ404，持续分享中。。。
Github主页