RxJava与retorfit联合使用

最新推荐文章于 2020-05-26 20:35:52 发布
最新推荐文章于 2020-05-26 20:35:52 发布
阅读量472 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoleisb10/article/details/78714139
版权

使用的接口：http://m.yunifang.com/yunifang/mobile/home

创建一个按钮进行点击执行

接口类：IInterface

import io.reactivex.Observable;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.DELETE;
import retrofit2.http.GET;

/**
 * Created by muhanxi on 17/12/4.
 */

public interface IInterface {



    @GET("/yunifang/mobile/home")
    Call<ResponseBody> get();



    @GET("/yunifang/mobile/home")
    Observable<Bean> get1();

}


主要使用方法：

MainActivity：


import android.app.Activity;
import android.os.Bundle;
import android.view.View;

import com.google.gson.Gson;

import org.reactivestreams.Subscription;

import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;
import io.reactivex.FlowableEmitter;
import io.reactivex.FlowableOnSubscribe;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);



        findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                zip1();
            }
        });













    }
    Disposable disposable = null;


    private void onObserverable(){

        //创建了一个被观察者
        Observable<String> observable =  Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
//                e 发射器

                //发送onnext事件

                for(int i=0;i<100;i++){
//                    if(i == 50){
//                        disposable.dispose();
//                    }
                    e.onNext(""+i);
                    if(i == 50){
//                        e.onComplete();
//                        e.onError(new Exception("1"));
                    }
                    //只要执行了  onComplete  onError ， 后续在发送的onNext 事件， 再也无法接受
                }
//                e.onError(new Exception(""));

//                e.onComplete();

            }
        });


        //创建观察者
        Observer observer = new Observer<String>(){

            @Override
            public void onSubscribe(Disposable d) {

                disposable = d ;

//                断开 被观察者和观察者之间的关系
//                disposable.dispose();
                // 判断 被观察者和观察者 之间是否还订阅关系
//                disposable.isDisposed()

            }

            @Override
            public void onNext(String s) {
                //用于接受  被观察者所方法的事件

                System.out.println("Observer s = " + s);

            }

            @Override
            public void onError(Throwable e) {
                //发生异常
                System.out.println("onError s = " + e.getMessage());

            }

            @Override
            public void onComplete() {
//                 事件完成
                System.out.println("onComplete s = ");


            }
        };


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


    private void test1(){

        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {

                System.out.println("Observable  " + Thread.currentThread().getName());
                for(int i=0;i<1000;i++){
                    e.onNext(i+"");
                }
                System.out.println("Observable over " );


            }
//            subscribeOn 指定 被观察者所在的线程
        }).subscribeOn(Schedulers.io())
//                指定 观察者所在的线程
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                System.out.println("Observer  " + Thread.currentThread().getName());

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(" "+ s);

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

    }





    private void test2(){


        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {

                for(int i=0;i<1000;i++){
                    e.onNext(""+i);
                }

            }
        }, BackpressureStrategy.LATEST)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {

                        Thread.sleep(100);
                        System.out.println("Consumer   " + s);
                    }
                });

    }



    private void test3(){






        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {

                e.onNext("onnext");
                e.onError(new Exception("1"));
//                e.onComplete();

            }
        },BackpressureStrategy.BUFFER)
//                .subscribeOn(Schedulers.io())
//                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {

//                        onnext
                        System.out.println("Consumer  onnext" + s);

                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
//                      onerror
                        System.out.println("Consumer  onerror" + throwable.getMessage());

                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
//                          onComplet
                        System.out.println("Consumer  Action");

                    }
                });




    }


    private void test4(){


        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> e) throws Exception {

                e.onNext(1);
                e.onError(new Exception(""));
            }
        },BackpressureStrategy.BUFFER).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {

                System.out.println(" onNext");
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                System.out.println(" onError");

            }
        });




    }




    private void map(){


        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                e.onNext("11");
            }
        },BackpressureStrategy.BUFFER)
                .map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return Integer.valueOf(s);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {

                System.out.println("integer = " + integer);
            }
        });




    }




    private void test5(){





        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(final FlowableEmitter<String> e) throws Exception {

                Retrofit retrofit = new Retrofit.Builder()
                        .baseUrl("http://m.yunifang.com")
                        .build();

                IInterface iInterface =  retrofit.create(IInterface.class);

                iInterface.get().enqueue(new Callback<ResponseBody>() {
                    @Override
                    public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {

                        try {
                            String result =    response.body().string() ;
                            e.onNext(result);
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }

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

                    }
                });

            }
        },BackpressureStrategy.BUFFER)
                .map(new Function<String, Bean>() {
            @Override
            public Bean apply(String s) throws Exception {

                Gson gson = new Gson();


                return gson.fromJson(s,Bean.class);
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Bean>() {
            @Override
            public void accept(Bean bean) throws Exception {

            }
        });


    }





    private void flatMap(){

//        Observable.create(new ObservableOnSubscribe<String>() {
//            @Override
//            public void subscribe(final ObservableEmitter<String> e) throws Exception {
//
//                e.onNext("1");
//                e.onNext("2");
//
                Retrofit retrofit = new Retrofit.Builder()
                        .baseUrl("")
                        .build();

                final IInterface iInterface = retrofit.create(IInterface.class);

                iInterface.get().enqueue(new Callback<ResponseBody>() {
                    @Override
                    public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {

                        try {
                            String result = response.body().string();

                            e.onNext(result);



                        } catch (IOException e) {
                            e.printStackTrace();
                        }
//
//
//                    }
//
//                    @Override
//                    public void onFailure(Call<ResponseBody> call, Throwable t) {
//
//                    }
//                });
//
//            }
//        }).flatMap(new Function<String, ObservableSource<ArrayList>>() {
//            @Override
//            public ObservableSource<ArrayList> apply(String s) throws Exception {
//
//
//
//                ArrayList list = new ArrayList<>();
//                for (int i=0;i<3;i++){
//                    list.add( s + " " + i);
//                }
//                return Observable.fromArray(list).delay(1, TimeUnit.SECONDS);
//            }
//        }).subscribe(new Consumer<ArrayList>() {
//            @Override
//            public void accept(ArrayList arrayList) throws Exception {
//
//
//                for (int i=0;i<arrayList.size();i++){
//                    System.out.println("arrayList = " + arrayList.get(i));
//                }
//
//            }
//        });


    }




    private void test9(){




    }



    private void t1(IInterface iInterface,String result){
        iInterface.get().enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {

                try {
                    String te = response.body().string();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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

            }
        });
    }



    private void concatMap(){

        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {

                e.onNext("1");
                e.onNext("2");
                e.onNext("3");
            }
        }).concatMap(new Function<String, ObservableSource<ArrayList>>() {
            @Override
            public ObservableSource<ArrayList> apply(String s) throws Exception {

                ArrayList list = new ArrayList<>();
                for (int i=0;i<3;i++){
                    list.add( s + " " + i);
                }
                return Observable.fromArray(list).delay(1, TimeUnit.SECONDS);
//                return null;
            }
        }).subscribe(new Consumer<ArrayList>() {
            @Override
            public void accept(ArrayList arrayList) throws Exception {
                for (int i=0;i<arrayList.size();i++){
                    System.out.println("arrayList = " + arrayList.get(i));
                }

            }
        });

    }



    private void zip(){


        Observable<String> observable =  Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {

                e.onNext("1");
                e.onNext("2");
                e.onNext("3");

            }
        });


        Observable<String> observable1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("A");
                e.onNext("B");
                e.onNext("C");
            }
        });


        Observable.zip(observable, observable1, new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s2) throws Exception {
                return s + s2;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println("s = " + s);
            }
        });




    }



    // rxjava 和retrofit 结合使用

    private void zip1(){




        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://m.yunifang.com")
                .addConverterFactory(GsonConverterFactory.create())
                // call 转化成 Observerable
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();

        IInterface iInterface = retrofit.create(IInterface.class);

        iInterface.get1()
                // 指定 被观察者 所在一个IO线程
                .subscribeOn(Schedulers.io())
                //指定观察者所在 住县城
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Bean>() {
                    @Override
                    public void accept(Bean bean) throws Exception {

                        System.out.println("bean = " + bean.toString());
                    }
                });




    }





}





GLqueen110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用Retrofit+RxJava实现网络请求
丶Jy
10-09 3022
安卓基础开发库，让开发简单点。 DevRing &amp; Demo地址：https://github.com/LJYcoder/DevRing 学习/参考地址： Retrofit： 整体教程 http://blog.csdn.net/jdsjlzx/article/details/52015347 文件上传 http://blog.csdn.net/jdsjlzx/a...
RxJava2+Retrofit2快速接入指南
qq_35484395的博客
04-11 974
本文主要是介绍本人在项目中接入Rxjava2和Retrofit2的过程中的一些经验心得、遇到的问题，特别是本人的学习曲线，希望能帮助到你。主要的概念介绍涉及较少，但是在文中会给出我在接入的过程中参考过的文章。
Retorfit+RxJava的联合使用
OutOfThinAir的博客
05-26 711
有关Retofit 的知识请看http://blog.csdn.net/outofthinair/article/details/71663349 有关RxJava 的知识请看http://blog.csdn.net/outofthinair/article/details/71703027 当我们对这两者有了一个认识之后,我们来看一下它们的结合使用 在使用之前我们要添加依赖 标准的retrof
Rxjava和retorfit的混合使用
Mydtudysy的博客
11-04 462
1.导入依赖 compile 'com.squareup.retrofit2:retrofit:2.0.1' compile 'com.squareup.retrofit2:converter-gson:2.0.1' compile 'com.squareup.retrofit2:adapter-rxjava:2.0.1' compile 'io.reactivex:rxandroid:1.
RxJava的学习 以及和retrofit的连用
vily_luky的博客
03-11 189
// retrofit compile 'com.squareup.retrofit2:retrofit:2.3.0' compile 'com.squareup.retrofit2:converter-gson:2.3.0' // rxjava implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'...
RxJava与Retrofit结合使用案例
11-09
RxJava与Retrofit结合使用是Android开发中一种高效、灵活的网络请求处理方式。RxJava是一个响应式编程库，它允许开发者通过观察者模式来处理异步数据流，而Retrofit则是一个简洁的HTTP客户端库，用于将网络接口转换...
RxJava2配置及使用详解
08-30
RxJava2 配置及使用详解 RxJava2 是一个功能强大且流行的响应式编程库，用于处理异步数据流。它基于观察者模式，实现了事件的异步处理。RxJava2 的配置和使用涉及到多个方面，包括 Observable、Observer、Emitter、...
RxJava与Retrofit结合使用学习记录
06-12
总结来说，RxJava与Retrofit的结合使用，能够使Android应用的网络请求变得更为灵活、强大且易于管理。通过理解并熟练运用RxJava的操作符和Retrofit的注解，开发者可以构建出更高效的网络层代码，同时提高代码的...
Rxjava_Retrofit_Module:rxjava和retorfit结合的一个模块化(业务层面)项目基类，包括网络请求状态的处理，部分基类的封装，屏幕适配
05-12
1 模块化实现（module+router）本套模块化方案实现来源于对模块化的概念理解，且根据公司...自动生成module之间的跳转调用方法moduleEventBus：实现module之间通信(此基础项目版本中暂未使用)3 项目代码主体架构设计app
RxJava2使用简介Demo
12-27
**RxJava2使用简介** RxJava是一个在Java虚拟机上运行的反应式编程库，它将观察者模式和函数响应式编程的概念结合在一起，为异步编程和事件处理提供了强大的工具。RxJava2是其第二代版本，相较于第一代，它在性能、...
Retorfit+Rxjava
weixin_44668058的博客
05-18 211
Apis(写接口) package com.lmx.shopcar.retrofit; import retrofit2.http.GET; public class Apis { public static String order_form_url="http://172.17.8.100/ks/product/"; } ObservedApis package com.lmx....
retorfit+RxJava+OKhttp+MVP
qq_39753947的博客
12-21 562
CustomJiaJian  import android.content.Context; import android.support.annotation.Nullable; import android.util.AttributeSet; import android.view.View; import android.widget.Button; import androi
RxJava与Retrofit的基本使用和结合使用
阿泽
02-15 1495
RxJava是什么？ Rx全称为ReactiveX，它一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流。它基于设计模式中的观察者模式，通过以下的方式简化代码： 函数式风格：对可观察数据流使用无副作用的输入输出函数，避免了程序里错综复杂的状态 简化代码：Rx的操作符通通常可以将复杂的难题简化为很少的几行代码 异步错误处理：传统的try/catch没办法处理异步计算，R...
Retrofit+RxJava 的结合使用
qq_31353347的博客
11-26 242
  这里只是简单的说一下 他们的用法  具体的原理不做解释因为我也不会 1.首先导入retrofit的依赖 implementation 'com.squareup.retrofit2:retrofit:2.5.0' 最新版本地址: https://github.com/square/retrofit 2.rxjava 第二个依赖   retrofit 对 rxjava2的适配的一个...
Retrofit+RxJava配置访问网络
Silicon_Valley
09-22 558
Android网络框架使用过的包括HttpClient，HttpURLConnection，Volley，OKhttp等等，OKhttp是现在常用的用于网络访问的框架。 现在常常开发中是Okhttp配合Retrofit和RxJava一起使用，单独显得更加优雅。 本文就介绍下这三个配合使用，现在Retrofit默认就是使用的OKhttp作为网络访问框架。下次可以把OKhttp单独使用写一下。 ...
Rxjava+Retrofit
weixin_45697390的博客
05-26 981
Rxjava异步线程 所需依赖 //Rxjava implementation 'io.reactivex.rxjava2:rxjava:2.2.6' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' //okhttp3 implementation 'com.squareup.okhttp3:okhttp:3.11.0' //日志 implementation 'com.squareup.okhttp3:logging-interceptor:3
retorfit与Rxjava的权限
分享人生
11-03 193
compile 'com.squareup.retrofit2:retrofit:2.0.1'     compile 'com.squareup.retrofit2:converter-gson:2.0.1'     compile 'com.squareup.retrofit2:adapter-rxjava:2.0.1'     compile 'io.reactivex:rxandro
Retrofit+RxJava+RxAndroid+Gson快速构建网络框架
贺祥的博客-清风依然
08-19 1275
Retrofit+RxJava+RxAndroid+Gson快速构建网络框架
DataBinding+Retorfit+Rxjava简单示例
小老头的博客
10-25 196
目前比较流行的DataBinding+Retorfit+Rxjava框架，在网上找了些资料，写个demo，分享给大家 github地址：https://github.com/wudongze/Android-MVVMFramework-master
RxJava入门与实战指南
最后，文档提到了RxJava与Retrofit的集成，Retrofit是一个流行的网络库，与RxJava配合可以实现无缝的RESTful API调用。这包括了项目的架构设计和如何创建Activity与Retrofit服务的交互。 这份RxJava文档全面覆盖了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值