网络

RxJava+Retrofit+MVP学习笔记

2019-07-12  本文已影响0人  刘喵喵嗷呜

学习链接,都是跟着大佬一步步来的,本篇主要是自己的笔记
RxJava和Retrofit最近超火,不学不是人。

首先关于RxJava

概念

官方定义是罗里吧嗦一大堆看不懂,主要看这两个词就够了,异步,基于事件。

创建一个观察者模式

1.创建被观察者。
ObservableEmitter有三种的方法,

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                 //把这个消息发送出去。
                emitter.onNext("我花了两万块钱买了个包");
            }
        });

2.创建观察者。

Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String msg) {
                //你收到买包的消息。
                Log.e("RxJava--------------",msg);
                //你暗骂的话。
                Log.e("RxJava--------------","收到了,败家娘们");

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };

3.订阅

//订阅。
observable.subscribe(observer);

RxJava2.0的异步和链式编程

前言里面有提到,RxJava是支持异步的
需要Scheduler。Scheduler,英文名调度器,它是RxJava用来控制线程。
当我们没有设置的时候,RxJava遵循哪个线程产生就在哪个线程消费的原则,也就是说线程不会产生变化,始终在同一个。
RxJava后台执行,前台调用,这个原则,我们需要调用observeOn(AndroidSchedulers.mainThread()),observeOn是事件回调的线程,AndroidSchedulers.mainThread()一看就知道是主线程,subscribeOn(Schedulers.io()),subscribeOn是事件执行的线程,Schedulers.io()是子线程,这里也可以用Schedulers.newThread(),只不过io线程可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。前面的代码根据异步和链式编程的原则,我们可以写成

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("1");
                emitter.onNext("2");
                emitter.onNext("3");
                emitter.onComplete();
            }
        })
                .observeOn(AndroidSchedulers.mainThread())//回调在主线程
                .subscribeOn(Schedulers.io())//执行在io线程
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG,"onSubscribe");
                    }
                    @Override
                    public void onNext(String value) {
                        Log.e(TAG,"onNext:"+value);
                    }
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG,"onError="+e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG,"onComplete()");
                    }
                });

关于Retrofit的

Retrofit其实我们可以理解为OkHttp的加强版,它也是一个网络加载框架。底层是使用OKHttp封装的。准确来说,网络请求的工作本质上是OkHttp完成,而 Retrofit 仅负责网络请求接口的封装。它的一个特点是包含了特别多注解,方便简化你的代码量。并且还支持很多的开源库(著名例子:Retrofit + RxJava)。

优点

使用

1.创建Retrofit对象,采用建造者模式。

Retrofit retrofit = new Retrofit.Builder()
        //设置baseUrl,baseUrl+接口中配置的地址组成真正的请求地址。
        .baseUrl("http://wanandroid.com/")
        .client(new OkHttpClient())
        .build();

2.创建请求接口,这里是通过注解的方式获取到请求类型,参数等信息,所有的请求参数都可以在这里进行配置,然后框架层根据这些信息封装成一个Request对象,发给服务端

public interface WanAndroidService {
    /**
     * 获取公众号列表
     * @Call<ResponseBody>
     */
    @GET("wxarticle/chapters/json")
    //baseUrl+接口中配置的地址组成真正的请求地址。
    Call<ResponseBody> getPublicAccountList();
}

3.创建请求接口对象。

WanAndroidService service = retrofit.create(WanAndroidService.class);
 
 Call<ResponseBody> responseBodyCall = service.getPublicAccountList();

4.发送

 responseBodyCall.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    Log.e("玩Android数据-------",response.body().string());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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

            }
        });

两者怎么结合呢?

Retrofit retrofit = new Retrofit.Builder()
        //设置baseUrl,baseUrl+接口中配置的地址组成真正的请求地址。
        .baseUrl("http://wanandroid.com/")
        .client(new OkHttpClient())
        .addConverterFactory(GsonConverterFactory.create()) // 支持Gson解析
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava2
        .build();
public interface WanAndroidService {
    /**
     * 获取公众号列表
     * @return  Observable<PublicAccountBean>
     */
    @GET("wxarticle/chapters/json")
    Observable<PublicAccountBean> getPublicAccountList();
}

GsonConverterFactory的作用是将请求的结果转化成具体的JavaBean。至于Observable,是不是很熟悉?对,它就是RxJava中的被观察者,RxJava2CallAdapterFactory是将该javaBean的对象再封装成Observable,中间经历了两次转化。让我们看下最终的调用:

 WanAndroidService service = retrofit.create(WanAndroidService.class);
        service.getPublicAccountList()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<PublicAccountBean>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(PublicAccountBean publicAccountBean) {
                        //请求成功
                        for (int i = 0; i < publicAccountBean.getData().size(); i++) {
                            Log.e("data----------", publicAccountBean.getData().get(i).getName());
                        }

                    }

                    @Override
                    public void onError(Throwable e) {
                        //失败
                    }

                    @Override
                    public void onComplete() {
                    }
                });

封装

封装net

首先创建一个Retrofit管理类,将Retrofit、OkHttpClient和请求接口的构建放一起。

public class RetrofitManager {
    private Retrofit mRetrofit;

    private static class InstanceHelper {
        static RetrofitManager instance = new RetrofitManager();
    }

    public static RetrofitManager getInstance() {
        return InstanceHelper.instance;
    }

    private RetrofitManager() {
        mRetrofit = new Retrofit.Builder()
                //设置baseUrl
                .baseUrl("http://wanandroid.com/")
                //设置OkHttpClient对象
                .client(createOkhttpClient())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                .addConverterFactory(GsonConverterFactory.create()) // 支持Gson解析
                .addConverterFactory(ScalarsConverterFactory.create())//支持字符串
                .build();
    }

    /*
    * 创建OkHttpClient对象。Retrofit底层基于OkHttpClient进行网络请求。
    * */
    private OkHttpClient createOkhttpClient() {
        HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
        httpLoggingInterceptor.setLevel(BuildConfig.DEBUG ? HttpLoggingInterceptor.Level.BODY : HttpLoggingInterceptor.Level.NONE);
        return new OkHttpClient.Builder()
                //设置连接超时时间
                .connectTimeout(30, TimeUnit.SECONDS)
                //设置读取超时时间
                .readTimeout(30, TimeUnit.SECONDS)
                .writeTimeout(30, TimeUnit.SECONDS)
                //添加日志过滤器
                .addInterceptor(httpLoggingInterceptor)
                //添加BaseInterceptor过滤器
                .addInterceptor(new BaseInterceptor())
                .build();
    }

    public <T> T createApi(final Class<T> service) {
        return mRetrofit.create(service);
    }
}

接着是创建请求接口API
三行代码完成get post设置,被监听的设置,参数的设置 。

public interface API {
    /**
     * 获取公众号列表
     * @return  Observable<PublicAccountBean>
     */
    @POST("wxarticle/chapters/json")
    @FormUrlEncoded
    Observable<PublicAccountBean> getPublicAccountList(@FieldMap Map<String, String> map);
}

BaseInterceptor是用来添加公共参数和头部等,get和post方法添加的方法不一样所以要区分。

public class BaseInterceptor implements Interceptor {
//    这里分了POST和GET等其它请求,POST和GET添加请求头和添加参数的代码不同,所以得判断请求的method。
    @NonNull
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        //POST请求
        if (request.method().equals("POST")) {
            FormBody formBody = null;
            FormBody.Builder bodyBuilder = new FormBody.Builder();
            if (request.body() instanceof FormBody) {
                formBody = (FormBody) request.body();
                //把原来的参数添加到新的构造器,(因为没找到直接添加,所以就new新的)
                for (int i = 0; i < formBody.size(); i++) {
                    bodyBuilder.add(formBody.name(i), formBody.value(i));
                }
                //添加公共参数
                formBody = bodyBuilder
                        .add("pubParam1", "1")
                        .add("pubParam2", "2")
                        .add("pubParam3", "3")
                        .build();

                //添加请求头
                request = request
                        .newBuilder()
                        .post(formBody)
                        .addHeader("Content-Type", "application/json;charset=UTF-8")
                        .addHeader("User-Agent", "android")
                        .build();
            }
            return chain.proceed(request);
        } else {
            //添加公共参数
            HttpUrl.Builder urlBuilder = request.url()
                    .newBuilder()
                    .addQueryParameter("pubParam1", "1")
                    .addQueryParameter("pubParam2", "2")
                    .addQueryParameter("pubParam3", "3");

            //添加请求头
            Request.Builder newBuilder = request.newBuilder()
                    .method(request.method(), request.body())
                    .url(urlBuilder.build())
                    .addHeader("Content-Type", "application/json;charset=UTF-8")
                    .addHeader("User-Agent", "android");

            return chain.proceed(newBuilder.build());
        }

    }

}

框架搭建差不多就是这样了。之后就是直接使用就行啦。

上一篇下一篇

猜你喜欢

热点阅读