我的 retrofit + rxjava +okhttp 之旅

阅读 1320
收藏 90
2017-01-05
原文链接:www.jianshu.com

项目重构,以下要求:
1,服务端完全遵守restful;
2,手机端网络请求完全遵循restful;
3,添加请求头;
4,打印每次请求log;
5,请求失败解析响应头;
6,因服务端自身改动,请求失败同样需要解析请求体;
7,支持https;
8,封装;
以上就是要求!!!

restful

restful是啥?
说实话,我也云里雾里,可以看下blog.csdn.net/lz0426001/a…
这篇博客的讲解.在我们这里只需要知道我们去请求,然后它会给我们返回数据就好..

retrofit

retrofit : 这个东西呢,关于这个东西的博客简直是太多了,不了解的伙计去自行百度就好.知道个大概意思就行,就能看懂我这片博客.

rxjava

rxjava : 关于这个东西,只需要知道是异步就行,知道了一个东西一件事物的本质之后再去研究它的表象会简单很多,各种操作符记起来很麻烦,实际上不需要记住,用的时候去查就好.照猫画虎即可.

okhttp

okhttp : 这个我也不说,自行百度,博客一大堆呢.

今天这篇博客说的是怎么用,不是去解释这是个什么东西.

开始

因为服务端是遵循的restful风格,所以呢,刚好retrofit就是遵循的restful风格的网络请求.支持的网络请求分别有 : @GET , @POST , @PUT , @PACTH , @DELETE , @HEADER等等,此处不多讲,一般这几个也就足够了.

第一步

创建APIService类来统一管理接口的请求,代码如下:

import com.google.gson.JsonObject;
import java.util.Map;
import retrofit2.http.Field;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.POST;
import retrofit2.http.Path;
import retrofit2.http.Query;
import retrofit2.http.QueryMap;
import rx.Observable;

/**
 * Created by scc on 2016/12/31.
 */
public interface APIService {

    /**
     * GET请求,后面的{id}是要动态来改变的变量,在getListData0方法的
     * 参数中传入,@Query()指定需要在url后面拼接的字符.
     * 示例:
     * 在调用getListData0时传入(6666,scc),@GET后面的url即为"你的后半分url/6666?scc
     */
    @GET("你的后半分url/{id}")
    Observable<JsonObject> getListData0(@Path("id") int id,@Query("name") String name);

    /**
     * GET请求,传入表单,也就是以map集合来传递参数
     * 示例:
     * 在调用getListData1时传入一个map集合,
     * ,@GET后面的url即为"你的后半分url?key1=value1&key2=value2...等等"
     */
    @GET("你的后半分url")
    Observable<JsonObject> getListData1(@QueryMap Map<String,String> ma);

    /**
     * ,@FormUrlEncoded表示请求体,可以理解为公共参数之类的.和get同理.
     * 只是get请求是添加在url后面,post是做为请求体传递.
     * ,@Field为单个key和value
     * ,@FieldMap为多个key个value的集合
     */
    @FormUrlEncoded
    @POST("你的后半分url")
    Observable<JsonObject> getData2(@Field("name") String name);

    //此处都用JsonObject为泛型,返回的对象JsonObject.toString之后为String类型,
    //当然也可以用responseBody或者自定义的bean类,或者String,当然要自定义CallAdapter
    @FormUrlEncoded
    @POST("你的后半分url")
    Observable<JsonObject> getData3(@FieldMap Map<String,String> map);

    /**
     * PATCH为修改某些或更新某些字段,对应的还有@PUT注解,如果要提交表单类型的公共参数的话
     * 需要FormUrlEncoded和FieldMap,然后传入你的key个value的集合即可.
     */
    @FormUrlEncoded
    @PATCH("你的后半分url")
    Observable<JsonObject> getData4(@FieldMap Map<String,String> map);
    /**
     * 注意在注意:----------------------------
     * 本人在使用delete的时候踩了坑,delete要提交公共参数的话必须要用
     * ,@HTTP(method = "DELETE",path = "你的url",hasBody = true)
     * 此种方法注解,我尝试了很多,FormUrlEncoded行不通.只有delete是需要
     * 这样来写注解才行.
     */
    @HTTP(method = "DELETE",path = "你的url",hasBody = true)
    Observable<JsonObject> getData5(@FieldMap Map<String,String> map);
}

第一步代码里面的注释基本上写的也还凑活,如有不明白的地方,加QQ吧,文末会有.良好的开端是成功的一半,接下来该到鸡冻人心的第二步了.

第二步

总不能每次请求的时候我们都去写一下retrofit吧,总不能每次都new一个对象吧,烦都烦死了.来个单例即可.

    private Retrofit retrofit;
    private APIService service;
    private static RetrofitManager r;
    private OkHttpClient client;
    //私有化构造方法

    private RetrofitManager() {
        retrofit = new Retrofit.Builder()
                .baseUrl("你的baseurl") //记得以/结尾
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .client(getOkClient())
                .build();
        service = retrofit.create(APIService.class);
    }

此处类名为RetrofitManager,类名自己随意即可,字段声明好了之后,我们私有构造方法来单例,然后在构造方法中,初始化retrofit,并且初始化我们第一步的接口对象.到这里不难吧,哈哈,继续加油.
上方的getOKClient()方法里是我们对okhttp的初始化和一些自己需要实现的需求;

第三步

在getOKClient方法中我们现在做几件事.
1,支持https请求
2,支持每次请求log打印
3,获得每次请求的响应头
4,添加请求头

/**
     * 获得Okhttp对象,并且初始化一次.
     * @return
     */
    private OkHttpClient getOkClient() {

        /**
         * 支持请求所有的https前缀URL
         */
        X509TrustManager xtm = new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                X509Certificate[] x509Certificates = new X509Certificate[0];
                return x509Certificates;
            }
        };

        SSLContext sslContext = null;
        try {
            sslContext = SSLContext.getInstance("SSL");

            sslContext.init(null, new TrustManager[]{xtm}, new SecureRandom());

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };

        /**
         * 初始化okhttp
         */
        if (mOkHttpClient == null) {
            mOkHttpClient = new OkHttpClient.Builder()
                    //添加http请求头
                    .addInterceptor(new Interceptor() {
                        @Override
                        public Response intercept(Chain chain) throws IOException {
                            Request re = chain.request().newBuilder()
                                    .addHeader("Authorization", "Basic MjEzMjEzOg==")
                                    .build();
                            return chain.proceed(re);
                        }
                    })
                    .addInterceptor(new LoggingInterceptor())
                    //获取响应头
//                    .addInterceptor(new Interceptor() {
//                        @Override
//                        public Response intercept(Chain chain) throws IOException {
//                            Response response = chain.proceed(chain.request());
//                            if (!response.isSuccessful()) {
//                                EventBus.getDefault().post(new Code(response.code()));
//                            }
//                            return response;
//                        }
//                    })
                    .sslSocketFactory(sslContext.getSocketFactory())
                    .hostnameVerifier(DO_NOT_VERIFY)
                    .build();
        }
        return mOkHttpClient;
    }

其中LoggingInterceptor类为自己定义的打印每次请求log的类.代码如下:

import com.orhanobut.logger.Logger;

import java.io.IOException;

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;

public class LoggingInterceptor implements Interceptor {
    @Override
    public Response intercept(Interceptor.Chain chain) throws IOException {
        //这个chain里面包含了request和response,所以你要什么都可以从这里拿
        Request request = chain.request();

        long t1 = System.nanoTime();//请求发起的时间
//        Logger.i(String.format("发送请求 %s on %s%n%s",
//                request.url(), chain.connection(), request.headers()));

        Response response = chain.proceed(request);

        long t2 = System.nanoTime();//收到响应的时间

        //这里不能直接使用response.body().string()的方式输出日志
        //因为response.body().string()之后,response中的流会被关闭,程序会报错,我们需要创建出一 
        //个新的response给应用层处理
        ResponseBody responseBody = response.peekBody(1024 * 1024);

        Logger.i(String.format("接收响应: [%s] %n返回json:【%s】",
                response.request().url(),
                responseBody.string()));
//        Logger.e(String.format("响应头: [%s]",response.code()));

        return response;
    }
}

接下来写一个方法,来获得RetrofitManager的单例对象;

/**
     * 得到本类的单例对象
     */
    public static RetrofitManager getInstance() {
        if (mManager == null) {
            return new RetrofitManager();
        } else {
            return mManager;
        }
    }

在接下来,封装请求;

public void async(Observable<JsonObject> observable,Subscriber<JsonObject> s){
        observable.subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(s);
    }

    public APIService getService(){
        return mAPIService;
    }

好了,到此为止,此类完成,然后在要使用的地方去使用就好.

示例

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;


import com.google.gson.JsonObject;
import com.orhanobut.logger.Logger;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.IOException;

import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.HttpException;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import rx.Observable;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

/**
 * Created by Administrator on 2016/12/30.
 */
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    private Button mTextView;
    private Button mButton1, mButton2, mButton3;
    private int status;
    private String ss;


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (Button) findViewById(R.id.main_tv);
        mButton1 = (Button) findViewById(R.id.main_tv1);
        mButton2 = (Button) findViewById(R.id.main_tv2);
        mButton3 = (Button) findViewById(R.id.main_tv3);
        mTextView.setText("get网络请求");
        mButton1.setText("post网络请求");
        mButton2.setText("path网络请求");
        mButton3.setText("delete网络请求");
//        EventBus.getDefault().register(this);
    }

    //get
    public void click(View v) {
        RetrofitManager.getInstance()
                .async(RetrofitManager.getInstance().getService().getData(NetRequestUtils.getParams("id", 6643 + "")), new Subscriber<JsonObject>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(JsonObject jsonObject) {
                        mTextView.setText(jsonObject.toString());
                    }
                });
    }

    //post
    public void click1(View v) {
        RetrofitManager.getInstance()
                .async(RetrofitManager.getInstance().getService()
                                .getDatas(NetRequestUtils.getParams("username", "heihei2111", "password", "775342", "type", "1", "phone", "13245678910")),
                        new Subscriber<JsonObject>() {
                            @Override
                            public void onCompleted() {
                                Logger.e("结束..");
                            }

                            @Override
                            public void onError(Throwable e) {
//
                                if (e instanceof HttpException){
                                    ResponseBody body = ((HttpException) e).response().errorBody();
                                    try {
                                        JSONObject object = new JSONObject(body.string());
                                        Toast.makeText(MainActivity.this,object.getString("msg"),Toast.LENGTH_SHORT).show();
                                    } catch (Exception e1) {
                                        e1.printStackTrace();
                                    }
                                }
                            }

                            @Override
                            public void onNext(JsonObject jsonObject) {
//                                Logger.e(status + "");
//                                Logger.e(jsonObject.toString());
                                try {
                                    JSONObject object = new JSONObject(jsonObject.toString());
                                    ss = object.getString("msg");

                                } catch (JSONException e) {
                                    e.printStackTrace();
                                }
                                mButton1.setText(ss);


                            }
                        });
    }

    //patch
    public void click2(View v) {
        RetrofitManager.getInstance()
                .async(
                        RetrofitManager.getInstance().getService()
                                .getDatass(NetRequestUtils.getParams("username", "hahahaha1", "id", "6645"))
                        , new Subscriber<JsonObject>() {
                            @Override
                            public void onCompleted() {

                            }

                            @Override
                            public void onError(Throwable e) {
                                Logger.e(e.toString());
                                if (e instanceof HttpException){
                                    ResponseBody body = ((HttpException) e).response().errorBody();
                                    try {
                                        JSONObject object = new JSONObject(body.string());
                                        Toast.makeText(MainActivity.this,object.getString("msg"),Toast.LENGTH_SHORT).show();
                                    } catch (Exception e1) {
                                        e1.printStackTrace();
                                    }
                                }
                            }

                            @Override
                            public void onNext(JsonObject jsonObject) {
                                Toast.makeText(MainActivity.this, jsonObject.toString(), Toast.LENGTH_SHORT).show();
                            }
                        }
                );
    }

    //delect
    public void click3(View v) {
        RetrofitManager.getInstance()
                .async(
                        RetrofitManager.getInstance().getService()
                                .getDatasss(NetRequestUtils.getParams("id", "6645"))//
                        , new Subscriber<JsonObject>() {
                            @Override
                            public void onCompleted() {

                            }

                            @Override
                            public void onError(Throwable e) {
                                Logger.e(e.toString());
                                if (e instanceof HttpException){
                                    ResponseBody body = ((HttpException) e).response().errorBody();
                                    try {
                                        JSONObject object = new JSONObject(body.string());
                                        Toast.makeText(MainActivity.this,object.getString("msg"),Toast.LENGTH_SHORT).show();
                                    } catch (Exception e1) {
                                        e1.printStackTrace();
                                    }
                                }
                            }

                            @Override
                            public void onNext(JsonObject jsonObject) {
                                Toast.makeText(MainActivity.this, jsonObject.toString(), Toast.LENGTH_SHORT).show();
                            }
                        });
    }

    public static String getBase64(String s) {
        String base64Token = Base64.encodeToString(s.getBytes(), Base64.DEFAULT);
        Logger.e(base64Token);
        return base64Token;
    }

//    @Subscribe
//    public void onEventMainThread(Code code) {
//        status = code.getCode();
//        Logger.i(status + "请求错误"+ss);
//
//    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
//        EventBus.getDefault().unregister(this);
    }
}

好了,代码就提交到这里,这就是全部的源码,其中的NetRequestUtils.getParams()方法是我们自己的一个排序的集合方法,此处各位需要换成自己的map集合去使用即可,代码写的不优雅之处见谅.共同进步.

有问题,请随时留言或加本人QQ:271860925

感谢大家阅读,2017 , 祝您心想事成!!!

评论