RxJava 和 retrofit的封装的工具类

//首先是依赖
//添加retrofit依赖
compile 'com.squareup.retrofit2:retrofit:2.3.0'
//添加gson转换器的依赖
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile "io.reactivex.rxjava2:rxjava:2.1.10"
compile 'io.reactivex.rxjava2:rxandroid:2.0.2'
//注意 rxjava2是2.0的 不加2表示的是1.0
compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

//代码
public class RestoUtils {
private static RestoUtils restoUtils=null;
private OkHttpClient okHttpClient;
private Retrofit retrofit;

public RestoUtils() {
}
public RestoUtils(String beseurl) {
okHttpClient = new OkHttpClient.Builder()
.addInterceptor(new CommonParamsInterceptor())//添加拦截器
.connectTimeout(15, TimeUnit.SECONDS)//连接超时
.build();

//创建retrofit
retrofit = new Retrofit.Builder()
.baseUrl(beseurl)
.client(okHttpClient)
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())//设置rxjava，注意是2
.addConverterFactory(GsonConverterFactory.create())//添加gson的转换器

.build();
}
/**
* 单例模式
*/
public static RestoUtils getInstance(String baseurl) {
if (restoUtils==null){
synchronized (RestoUtils.class){
if (restoUtils==null){
restoUtils=new RestoUtils(baseurl);
}
}
}
return restoUtils;
}
/**
* 封装公共参数的拦截器
*/
private static class CommonParamsInterceptor implements Interceptor {

//intercept方法就是拦截的意思....拦截的是一个请求,,,一旦拦截之后可以对请求的参数进行处理
//Chain chain 链条的意思
@Override
public Response intercept(Chain chain) throws IOException {

Log.e("----", "拦截器------");

//调用request()方法得到拦截的请求
Request request = chain.request();

//获取请求的方式
String method = request.method();//GET POST
//拦截的请求的路径
String oldUrl = request.url().toString();

//要添加的公共参数...map
Map<String, String> map = new HashMap<>();
map.put("source", "android");

if ("GET".equals(method)) {
StringBuilder stringBuilder = new StringBuilder();//创建一个stringBuilder...字符串缓冲区

stringBuilder.append(oldUrl);

if (oldUrl.contains("?")) {
//?在最后面....2类型
if (oldUrl.indexOf("?") == oldUrl.length() - 1) {

} else {
//3类型...拼接上&
stringBuilder.append("&");
}
} else {
//不包含? 属于1类型,,,先拼接上?号
stringBuilder.append("?");
}

//添加公共参数....source=android&appVersion=100&
for (Map.Entry<String, String> entry : map.entrySet()) {
//拼接
stringBuilder.append(entry.getKey())
.append("=")
.append(entry.getValue())
.append("&");
}

//删掉最后一个&符号
if (stringBuilder.indexOf("&") != -1) {
stringBuilder.deleteCharAt(stringBuilder.lastIndexOf("&"));
}
//得到含有公共参数的新路径.....使用新路径去请求
String newUrl = stringBuilder.toString();

//新的路径构建一个新的请求
request = request.newBuilder().url(newUrl).build();

} else if ("POST".equals(method)) {
Log.e("--oldUrl--", oldUrl);
//参数在请求的实体内容上....拿到以前的参数,把以前的参数和公共参数全都添加到请求实体上
RequestBody requestBody = request.body();
if (requestBody instanceof FormBody) {//前边是不是后边的子类/实例对象
FormBody oldBody = (FormBody) requestBody;//keywords...page

FormBody.Builder builder = new FormBody.Builder();

//先添加之前的参数
for (int i = 0; i < oldBody.size(); i++) {
//键值对的形式添加
builder.add(oldBody.name(i), oldBody.value(i));
}
//添加公共参数
for (Map.Entry<String, String> entry : map.entrySet()) {

builder.add(entry.getKey(), entry.getValue());

}

//构建一个新的请求
request = request.newBuilder().url(oldUrl).post(builder.build()).build();

}

}

//执行请求 获取到响应
Response response = chain.proceed(request);
return response;
}

}
public <T> T createService(Class<T> service){
return retrofit.create(service);
}
}
//apiService类
import java.util.Map;

import io.reactivex.Observable;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.POST;
import retrofit2.http.Path;

import retrofit2.http.QueryMap;
public interface ApiService {

    /**
     * 坑点:--------------路径的字符被转义
     *
     */

    @GET("{url}")
    Observable<ResponseBody> doGetNoParam(@Path(value = "url",encoded = true) String url);

    @GET("{url}")
    Observable<ResponseBody> doGet(@Path(value = "url",encoded = true) String url, @QueryMap Map<String,String> map);

    @FormUrlEncoded
    @POST("{url}")
    Observable<ResponseBody> doPost(@Path(value = "url",encoded = true) String url, @FieldMap Map<String,String> map);

}