深入理解RxJava编程思想

最新推荐文章于 2022-07-04 11:11:29 发布
置顶 最新推荐文章于 2022-07-04 11:11:29 发布
阅读量505 收藏 1
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26498311/article/details/112466280
版权

深入理解RxJava编程思想

RxJava前言

在RxJava中，一个实现了Observer接口的对象可以订阅(subscribe)一个Observable 类的实例。订阅者(subscriber)对Observable发射(emit)的任何数据或数据序列作出响应。这种模式简化了并发操作，因为它不需要阻塞等待Observable发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应Observable的通知。

为什么学习RxJava？

通过学习RxJava改变思维来提升效率

要想弄明白RxJava实现原理，就先学会怎么使用它。

应用场景

核心思想

RxJava是一种响应式编程思维 （起点--------->终点）

举一个生活中的例子：

起点（分发事件：我饿了）----------->下楼---------->去餐厅------------>点餐------------>终点（吃饭 消费事件）

程序中的例子：

起点（分发事件：点击登录）---------->登录API--------->请求服务器---------->获取响应码--------->终点（更新UI 登录成功 消费事件）

也就是说，我们的起点和终点始终是链接在一起的，没有被断掉，中间的过程是一环扣一环。

我们通过一个实现下载图片的功能的代码来比较传统思维和Rx思维

首先我们有一个需求：

网络获取图片显示在UI上。

传统的思维方式下载图片：

// 传统方式 思维 无法固定 （后面接手你写的项目，看不懂）
// A程序员：35356453 自己的思维 不同  封装方法....
// B程序员：46576576 自己的思维 不同  全部写在一起
// C程序员：43643654 自己的思维 不同  new Thread
// D程序员：66545655 自己的思维 不同  使用 线程池
// .....
// 零零散散 麻烦
public void downloadImageAction(View view) {
    progressDialog = new ProgressDialog(this);
    progressDialog.setTitle("下载图片中.....");
    progressDialog.show();

    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                URL url = new URL(PATH);
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                connection.setRequestMethod("GET");
                connection.setConnectTimeout(5000);
                connection.connect();
                int responseCode = connection.getResponseCode();
                Log.d(TAG, "apply: " + responseCode);
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    InputStream inputStream = connection.getInputStream();
                    Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                    Message message = handler.obtainMessage();
                    message.obj = bitmap;
                    handler.sendMessage(message);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }).start();
}

private final Handler handler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(@NonNull Message msg) {
        Bitmap bitmap = (Bitmap) msg.obj;
        imageView.setImageBitmap(bitmap);

        if (progressDialog != null) {
            progressDialog.dismiss();
        }
        return false;
    }
});

首先创建一个connection，把网络图片地址传进去，通过okhttp进行网络请求，将输入流转换成Bitmap，通过handler将message发送给主线程更新UI。这是我们用传统思维实现的功能。

接下来我们使用Rx思维：

我们首先画一个基本流程图来描述事件的流向：

在这里插入图片描述

接下来我们用代码实现：

public void rxJavaDownloadImageAction(View view) {
    
    //起点
    Observable.just(PATH) //内部会分发  //TODO 第二步
            
    //TODO 第三步  卡片式拦截  把String拦截成Bitmap
    .map(new Function<String, Bitmap>() {
        @Override
        public Bitmap apply(String s) throws Exception {
            URL url = new URL(PATH);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setConnectTimeout(5000);
            int responseCode = connection.getResponseCode();
            Log.d(TAG, "apply: " + responseCode);
            if (responseCode == HttpURLConnection.HTTP_OK) {
                InputStream inputStream = connection.getInputStream();
                Bitmap bitmap = BitmapFactory.decodeStream(inputStream);

                return bitmap;
            }

            return null;
        }
    })

    //加水印
    .map(new Function<Bitmap, Bitmap>() {
        @Override
        public Bitmap apply(Bitmap bitmap) throws Exception {
            Paint paint = new Paint();
            paint.setTextSize(88);
            paint.setColor(Color.RED);
            return drawTextToBitmap(bitmap, "同学们大家好", paint, 88, 88);
        }
    })

    //日志记录
    .map(new Function<Bitmap, Bitmap>() {
        @Override
        public Bitmap apply(Bitmap bitmap) throws Exception {
            Log.d(TAG, "apply: 这个时候下载了图片啊: " + System.currentTimeMillis());
            return bitmap;
        }
    })

    .subscribeOn(Schedulers.io())  //给上面的代码分配异步线程
    .observeOn(AndroidSchedulers.mainThread())  // 给下面的代码执行主线程
     //订阅  起点和终点订阅起来
    .subscribe(
            //终点
            new Observer<Bitmap>() {

                //订阅开始
                @Override
                public void onSubscribe(@io.reactivex.annotations.NonNull Disposable d) {
                    //预备 开始要分发
                    //TODO 第一步
                    progressDialog = new ProgressDialog(DownloadActivity.this);
                    progressDialog.setTitle("download run");
                    progressDialog.show();
                }
                
                //TODO 第四步
                //拿到事件
                @Override
                public void onNext(@io.reactivex.annotations.NonNull Bitmap bitmap) {
                    imageView.setImageBitmap(bitmap);
                }

                //错误事件
                @Override
                public void onError(@io.reactivex.annotations.NonNull Throwable e) {

                }
                //TODO 第五步
                //完成事件
                @Override
                public void onComplete() {
                    if (progressDialog != null)
                        progressDialog.dismiss();
                }
    });
}

//图片上绘制文字，添加水印
private final Bitmap drawTextToBitmap(Bitmap bitmap, String text, Paint paint, int paddingLeft, int paddingTop) {
    Bitmap.Config bitmapConfig = bitmap.getConfig();

    paint.setDither(true); //获取更清晰的图片采样
    paint.setFilterBitmap(true);// 过滤一些
    if (bitmapConfig == null) {
        bitmapConfig = Bitmap.Config.ARGB_8888;
    }
    bitmap = bitmap.copy(bitmapConfig, true);
    Canvas canvas = new Canvas(bitmap);

    canvas.drawText(text, paddingLeft, paddingTop, paint);
    return bitmap;

}

我们使用了Rx编程思维后，从起点到终点这条线一直是连着的，没有断掉，中间需要加需求（加水印、日志记录等）我们可以进行卡片式拦截，把上游的Bitmap拦截成我们需要的新的Bitmap，再将新的Bitmap游下去，直到终点显示UI。这种思维也叫链式思维。

RxJava配合Retrofit

Retrofit其实是一个管理者，控制okhttp请求网络，请求是通过ohhttp，请求的结果丢给RxJava处理，拿到结果后通过起点流向下去，显示UI。

现在有一个需求：通过RxJava配合Retrofit来获取https://www.wanandroid.com/blog/show/2 里面的项目总数据和Item数据。

同样我们先用流程图来理清思路：

在这里插入图片描述

现在用代码实现：

  1. 创建客户端API
public interface WanAndroidApi {
    
    // 总数据
    @GET("project/tree/json")
    Observable<ProjectBean> getProject();  // 异步线程 耗时操作

    // ITem数据
    @GET("project/list/{pageIndex}/json") // ?cid=294
    Observable<ProjectItemBean> getProjectItem(@Path("pageIndex") int pageIndex, @Query("cid") int cid);  // 异步线程 耗时操作
}
  1. 封装网络请求框架
public class HttpUtil {

    private static final String TAG = "HttpUtils";

    private static final String BASE_URL = "https://www.wanandroid.com/";
    
    /**
     * 根据各种配置创建出retrofit
     *
     * @return  返回创建好的retrofit
     */
    public static Retrofit getOnlineCookieRetrofit() {
        // OKHttp客户端
        OkHttpClient.Builder httpBuilder = new OkHttpClient.Builder();
        // 各种参数配置
        OkHttpClient okHttpClient = httpBuilder
                .addNetworkInterceptor(new StethoInterceptor())
                .readTimeout(10000, TimeUnit.SECONDS)
                .connectTimeout(10000, TimeUnit.SECONDS)
                .writeTimeout(10000, TimeUnit.SECONDS)
                .build();
        
        return new Retrofit.Builder()
                .baseUrl(BASE_URL)
                //TODO 请求用OKHttp
                .client(okHttpClient)
                //TODO 响应用RxJava
                //添加一个json解析的工具
                .addConverterFactory(GsonConverterFactory.create(new Gson()))
                //添加RxJava处理工具
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
    }
}
  1. 将服务器返回的JSON数据转换为JavaBean

方式一：通过https://www.bejson.com/json2javapojo/new在线转化

方式二：使用Android Studio里面的GsonFormat插件进行转化

  1. 用Rxjava来实现我们的数据流向
/**
   * TODO Retrofit+RxJava 查询 项目分类  (总数据查询)
   * @param view
   */
@SuppressLint("CheckResult")
public void getProjectAction(View view) {

    //获取网络API
    api.getProject()
        .subscribeOn(Schedulers.io()) //上面  异步
        .observeOn(AndroidSchedulers.mainThread()) //下面 主线程
        .subscribe(new Observer<ProjectBean>() {
            @Override
            public void onSubscribe(Disposable d) {
                progressDialog = new ProgressDialog(UseActivity.this);
                progressDialog.setTitle("资源获取中....");
                progressDialog.show();
            }

            @Override
            public void onNext(ProjectBean projectBean) {
                Log.d(TAG, "onNext: " + projectBean);
                textView.setText(projectBean.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e);
            }

            @Override
            public void onComplete() {
                if (progressDialog != null) {
                    progressDialog.dismiss();
                }
            }
        });
}

/**
   * TODO Retrofit+RxJava 查询 项目列表数据  (Item数据查询)
   * @param view
   */
@SuppressLint("CheckResult")
public void getProjectListAction(View view) {

    api.getProjectItem(3, 294)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Consumer<ProjectItemBean>() {
            @Override
            public void accept(ProjectItemBean projectItemBean) throws Exception {
                Log.d(TAG, "accept: " + projectItemBean);
            }
        });
}

防抖+网络嵌套

我们先了解什么是抖动？

假如我有个Button，写一个自动化脚本来实现2s之内点击20次，那我就得请求20次网络，这样是很过分的，这就是抖动；如果我2s之内还是点击20次，可我只响应你一次，这种情况就是没有抖动。我们要做的事情就是防止抖动。

Rx家族成员有RxJava、RxJS、RxBinding…，RxBinding里面就有防抖的功能。

通过上面的查询我们得到了项目分类数据和项目列表数据，如果我们想通过项目id来查询项目列表数据呢？这时候我们就需要进行网络嵌套，如果我们用传统的网络嵌套，那么会造成代码堆叠。（负面教程，嵌套的太厉害了）

/**
 * RxBinding  防抖动  TODO  网络嵌套
 */
@SuppressLint("CheckResult")
public void antiShakeActon() {
    //对哪个控件防抖动？
    Button bt_anti_shake = findViewById(R.id.bt_anti_shake);
    RxView.clicks(bt_anti_shake)
            .throttleFirst(2000, TimeUnit.MICROSECONDS)  //2秒钟之内，响应一次
            .subscribe(new Consumer<Object>() {
                @Override
                public void accept(Object o) throws Exception {
                    api.getProject()  //查询主数据
                            .compose(DownloadActivity.rxud())
                            .subscribe(new Consumer<ProjectBean>() {
                                @Override
                                public void accept(ProjectBean projectBean) throws Exception {
                                    for (ProjectBean.DataBean dataBean : projectBean.getData()) {
                                        api.getProjectItem(1, dataBean.getId()) //查询Item数据
                                                .compose(DownloadActivity.rxud())
                                                .subscribe(new Consumer<ProjectItemBean>() {
                                                    @Override
                                                    public void accept(ProjectItemBean projectItemBean) throws Exception {
                                                        Log.d(TAG, "accept: " + projectItemBean);
                                                    }
                                                });
                                    }
                                }
                            });
                }
            });
}

这样，虽然我们实现了通过项目ID查询列表数据的功能，但是我们发现，如果我们嵌套层级太多，那我们的代码会形成一个阶梯状的局势，这样的代码是很不好看的，而且如果有问题，我们排查起来十分困难。难道没有其他办法了吗？不不不，相信我们Rx爸爸，早已为我们铺好了道路。

通过RxJava里面的flatMap就能愉快地解决网络嵌套的问题。

flatMap示意图：
在这里插入图片描述
这个示意图的意思就是：flatMap可以自己分发多个数据给下面，终点就得到flatMap发的多个数据。
在这里插入图片描述

熟悉了flatMap的原理后，我们用代码实现：

/**
 * TODO 功能防抖 + 网络嵌套 (解决嵌套问题) flatMap
 */
@SuppressLint("CheckResult")
public void antiShakeActonUpdate() {
    Button bt_anti_shake = findViewById(R.id.bt_anti_shake);
    RxView.clicks(bt_anti_shake)
            .throttleFirst(2000, TimeUnit.MICROSECONDS)

            //我只给下面切换异步线程
            .observeOn(Schedulers.io())
            .flatMap(new Function<Object, ObservableSource<ProjectBean>>() {
                @Override
                public ObservableSource<ProjectBean> apply(Object o) throws Exception {
                    return api.getProject(); //主数据
                }
            })
            .flatMap(new Function<ProjectBean, ObservableSource<ProjectBean.DataBean>>() {
                @Override
                public ObservableSource<ProjectBean.DataBean> apply(ProjectBean projectBean) throws Exception {
                    return Observable.fromIterable(projectBean.getData());  //我自己搞一个发射器，发送多次
                }
            })
            .flatMap(new Function<ProjectBean.DataBean, ObservableSource<ProjectItemBean>>() {
                @Override
                public ObservableSource<ProjectItemBean> apply(ProjectBean.DataBean dataBean) throws Exception {
                    return api.getProjectItem(1, dataBean.getId());  //Item数据
                }
            })

            .observeOn(AndroidSchedulers.mainThread())  //给下面切换主线程
            .subscribe(new Consumer<ProjectItemBean>() {
                @Override
                public void accept(ProjectItemBean projectItemBean) throws Exception {
                    Log.d(TAG, "accept-------->: " + projectItemBean);
                    textView.setText(projectItemBean.toString());
                }
            });
}

doOnNext运用

在这里插入图片描述

*  需求：
*  1.请求服务器注册操作
*  2.注册完成之后，更新注册UI
*  3.马上去登录服务器操作
*  4.登录完成之后，更新登录的UI

现在我们有这样一个需求，首先我们分开写：

/**
 * TODO 方式一  分开写
 * @param view
 */
@SuppressLint("CheckResult")
public void request(View view) {

    // 1.请求服务器注册操作
    // 2.注册完成之后，更新注册UI
    MyRetrofit.createRetrofit().create(IRequestNetwork.class)
            .registerAction(new RegisterRequest())
            .compose(DownloadActivity.rxud())
            .subscribe(new Consumer<RegisterResponse>() {
                @Override
                public void accept(RegisterResponse registerResponse) throws Exception {
                    // 更新注册UI
                }
            });

    // 3.请求服务器登录操作
    // 4.登录完成之后，更新登录UI
    MyRetrofit.createRetrofit().create(IRequestNetwork.class)
            .loginAction(new LoginRequest())
            .compose(DownloadActivity.rxud())
            .subscribe(new Consumer<LoginResponse>() {
                @Override
                public void accept(LoginResponse loginResponse) throws Exception {
                    // 更新登录UI
                }
            });

}

我们用doOnNext来实现（一行代码）

/**
 * todo  方式二 doOnNext
 * @param view
 */
@SuppressLint("CheckResult")
public void request2(View view) {
    MyRetrofit.createRetrofit().create(IRequestNetwork.class)
            // todo 1.请求服务器注册操作
            .registerAction(new RegisterRequest())
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnNext(new Consumer<RegisterResponse>() {
                @Override
                public void accept(RegisterResponse registerResponse) throws Exception {
                    // todo 2.注册完成后，更新注册UI
                }
            })
            // todo 3.请求登录服务器操作
            .observeOn(Schedulers.io())
            .flatMap(new Function<RegisterResponse, ObservableSource<LoginResponse>>() {
                @Override
                public ObservableSource<LoginResponse> apply(RegisterResponse registerResponse) throws Exception {
                    return MyRetrofit.createRetrofit().create(IRequestNetwork.class)
                            .loginAction(new LoginRequest());
                }
            })
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<LoginResponse>() {
                @Override
                public void onSubscribe(Disposable d) {
                    progressDialog = new ProgressDialog(RequestActivity.this);
                    progressDialog.show();
                    disposable = d;
                }

                @Override
                public void onNext(LoginResponse loginResponse) {
                    // todo 4.登录完成后，更新登录UI
                    //
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {
                    //todo 5.杀青了
                    if (progressDialog != null) {
                        progressDialog.dismiss();
                    }
                }
            });
}

为什么使用doOnNext呢？因为doOnNext返回的是Observable对象，使得我们的链条没有被打断，我们可以继续向下流动，直到终点subscribe，如果我们刚开始使用subscribe，我们的链条就被打断了。

RxJava模式与原理

标准观察者与RxJava观察者

标准观察者设计模式

首先举一个生活中常见的例子：当今时代，几乎我们人人都会玩微信，而在微信里面，会有一个微信公众号可供我们订阅，当我们订阅了某一个微信公众号后，我们会不定期收到该公共号的推送消息。

在这个微信公众号服务中，我们用户充当了观察者的角色，而公众号充当了被观察者的角色，当被观察者发生改变时，观察者会立即收到被观察者的改变，一个被观察者可以同时拥有多个观察者，他们之间时一对多的关系。

我们用代码来实现这个例子：

  1. 首先抽象一个被观察者和观察者
// todo 抽象层 被观察者
public interface Observable {
    //关注
    void addObserver(Observer observer);
    //取消关注
    void removeObserver(Observer observer);
    //被观察者发出改变
    void notifyObservers();
    //微信公众号的服务  编辑部门  发布一条消息
    void pushMessage(String message);
}

// todo 抽象层 观察者
public interface Observer {

    void update(Object o);
}
  1. 实现被观察者（这里我们就指微信公众号）
// 被观察者 实现
public class WechatServerObservable implements Observable {

    private List<Observer> observers = new ArrayList<>();
    private final static String TAG = MainActivity.class.getSimpleName();

    private String message;
    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        //遍历容器
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    @Override
    public void pushMessage(String message) {
        this.message = message;

        Log.d(TAG, "微信服务号更新了消息: " + message);
        notifyObservers();
    }
}
  1. 实现观察者（这里指用户）
//观察者 实现
public class UserPerson implements Observer {

    private static final String TAG = MainActivity.class.getSimpleName();

    private String name;
    private String message;

    public UserPerson(String name) {
        this.name = name;
    }


    @Override
    public void update(Object o) {
        this.message = (String) o;

        readMessage();
    }

    public void readMessage() {
        Log.d(TAG, name + " 读取到消息: " + message);
    }
}
  1. 写测试程序
public static void test() {
    //编辑部，编辑好的文案内容
    String msg = "学习Android必须学习Kotlin，哈哈";

    //创建一个微信公众号（被观察者）
    Observable server = new WechatServerObservable();

    //创建两个用户（观察者）
    Observer zhangsan = new UserPerson("张三");
    Observer lisi = new UserPerson("李四");

    //关注微信公众号
    server.addObserver(zhangsan);
    server.addObserver(lisi);
    //lisi取消了关注
    server.removeObserver(lisi);

    //微信公众号推送消息
    server.pushMessage(msg);

}

上面就是一个标准的观察者设计模式

RxJava Hook点

  1. 首先了解什么是Hook？

    Hook 技术又叫做钩子函数，在系统没有调用该函数之前，钩子程序就先捕获该消息，钩子函数先得到控制权，这时钩子函数既可以加工处理（改变）该函数的执行行为，还可以强制结束消息的传递。简单来说，就是把系统的程序拉出来变成我们自己执行代码片段。

  2. 找到RxJava的Hook点

    /**
 * todo RxJava Hook点
 */
@SuppressLint("CheckResult")
public static void testHook() {
    Observable.create(new ObservableOnSubscribe<Object>() {
        @Override
        public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
            emitter.onNext("A");
        }
    })
    .map(new Function<Object, String>() {
        @Override
        public String apply(Object o) throws Exception {
            return "null";
        }
    })
    .subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {

        }
    });
}

  3. 全局监听 hook

    //Hook之前的监听
RxJavaPlugins.setOnObservableAssembly(new Function<Observable, Observable>() {
    @Override
    public Observable apply(Observable observable) throws Exception {
        Log.d(TAG, "apply: 整个项目全局监听 到底多少个地方使用RxJava：" + observable);
        return observable;  //todo 不破坏人家的功能
    }
});

结论：很多操作符，都会经过【onAssembly】监听

RxJava的观察者模式
  1. 创建Observable
  2. 创建Observer
  3. 使用subscribe()订阅

首先我们分析Observer的源码：

public interface Observer<T> {

    void onSubscribe(@NonNull Disposable d);  //一订阅就会执行

    void onNext(@NonNull T t);  //拿到上一个卡片流下来的数据

    void onError(@NonNull Throwable e);  //拿到上一个卡片流下来的错误数据

    void onComplete();  //事件结束

}

Observer的源码很简单，就是一个泛型接口，有4个函数，真正实现这个接口就在这里：

 new Observer<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {
       
    }

    @Override
    public void onNext(String s) {
       
    }

    @Override
    public void onError(@NonNull Throwable e) {

    }

    @Override
    public void onComplete() {
       
    }
}

接下来看Observable创建过程，源码分析：

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

点进creat里面，看到creat传进去一个soure，这个source我们称之为自定义source，然后再将自定义source丢进ObservableCreate中，再进入看：

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

这时候new ObservableCreate的时候，将soure = 自定义source，所以最终得出结论：

new ObservableCreate() {souce = 自定义source}

再分析subscribe订阅过程，源码分析：

public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

        subscribeActual(observer);
    }

subscribe传进去一个observer，我们称之为自定义观察者，最终会把自定义观察者丢进subscribeActual中，而subscribeActual是一个抽象函数，实现这个抽象函数的一定是在ObservableCreate中，因为subscribe是通过ObservableCreate点出来的，我们再进入ObservableCreate中看，这个函数把我们的自定义观察者包装成一个发射器

protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    observer.onSubscribe(parent);

    try {
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

这时候我们用图片来展示流程：

在这里插入图片描述

我们不难发现，整体是一个U型流程

Observable 与 Observer 订阅的过程时序图如下：
在这里插入图片描述

标准的观察者设计模式与RxJava观察者设计模式区别

  1. 从直观角度分析

    在标准的观察者设计模式中：是一个“被观察者”，多个“观察者”，并且需要“被观察者”发出改变通知时，所有的“观察者”才能观察到。

    在RxJava观察者设计模式中：是多个“被观察者”，一个“观察者”，并且需要起点和终点在”订阅“一次后，才发出改变通知，终点（观察者）才能观察到。

  2. 从模式角度分析

    在标准的观察者设计模式中：当发出通知改变时，会遍历Observable里面的容器，此容器里面有10个Observer，就会通知10个Observer

    在RxJava观察者设计模式中：分发事件时，会拿到发射器，通过发射器关联到我们自定义的Observer，发射器调用到我们自定义的Observer

Map变换操作符原理

map示意图：
在这里插入图片描述
通过源码分析总结的流程图：

在这里插入图片描述
其实Map实现变换的本质就是不断进行封包裹和拆包裹，说白就是一个洋葱模型，具体实现变换的代码在MapObserver类中的onNext()函数中，通过mapper.apply(t)将类型变换

static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
    .....

    @Override
    public void onNext(T t) {
        .....

        try {
            v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
        } catch (Throwable ex) {
            fail(ex);
            return;
        }
        downstream.onNext(v);
    }
    
    public interface Function<T, R> {
    /**
     * Apply some calculation to the input value and return some other value.
     * @param t the input value
     * @return the output value
     * @throws Exception on error
     */
    R apply(@NonNull T t) throws Exception;
}

在这里插入图片描述
RxJava装饰模型
在这里插入图片描述

RxJava线程切换原理

  1. sunscribeOn 给上面代码分配线程

    首先分析Schedulers.io()这个流程：

在这里插入图片描述

从源码看到，第一步过程很简单，就是将IOSchedulers实例对象扔进线程池。

再分析subscribeOn()过程：
在这里插入图片描述

这时候我们发现在这个流程中，所有执行都在异步线程中，回到终点岂不是崩溃？？所以应该在终点切换为主线程，那么继续看下一个线程切换：

  1. observeOn 给下面的代码切换主线程

    首先分析AndroidSchedulers.mainThread()的流程：

在这里插入图片描述

第一步流程就是创建了主线程的Handler，把Handler传进去。

接下来看observeOn() 的流程：

在这里插入图片描述

伟子时代
关注
专栏目录
RXJava基本原理
TimPika的博客
08-07 927
什么是RXjava RxJava是近两年来越来越流行的一个异步开发框架,使用起来十分简单方便,功能保罗万象,十分强大 首先以代码的执行顺序来描述RXJava,回答几个问题 RxJava框架内部的主干逻辑是怎样的？ RxJava究竟是如何实现一句话线程切换的？ 多次调用subscribeOn()或observeOn()切换线程会有什么效果？ 回答了这几个问题之后,我们大概就能对RxJava的基本原理...
从根上理解RXJava，深入RxJava 的适用场景和使用方式（Retrofit、RxBinding、RxBus）
weixin_43901866的博客
12-31 299
前言 我从去年开始使用 RxJava ，到现在一年多了。今年加入了 Flipboard 后，看到 Flipboard 的 Android 项目也在使用 RxJava ，并且使用的场景越来越多 。而最近这几个月，我也发现国内越来越多的人开始提及 RxJava 。有人说『RxJava 真是太好用了』，有人说『RxJava 真是太难用了』，另外更多的人表示：我真的百度了也谷歌了，但我还是想问： RxJava 到底是什么？ 鉴于 RxJava 目前这种既火爆又神秘的现状，而我又在一年的使用过程中对 RxJava 有
Rxjava编程思想
BunnyCoffer的博客
12-16 784
随着android越来越成熟，为了开发更方便出现了不少新的开发框架，其中Rxjava是一个不能被忽视的重点。 Rxjava是响应式开发，它是一种特殊观察者模式，被观察者订阅观察者。和bolts框架正好反过来。 第一部分：角色 Rxjava分成两个角色，观察者和被观察者。 1）观察者：Observer类，但是因为该类并不好的可以满足开发的需求。之后推出
RxJava 从入门到爱上它 - 线程控制的深入理解
一只努力的小小程序猿
05-27 290
RxJava 从入门到爱上它 - 认识 RxJava 从入门到爱上它 - “变换”的深入理解 关于Backpressure 作者也将在后续的文章中做出解析。RxJava 的线程控制使用与原理 RxJava中的线程控制有两个方法subscribeOn : 发生在通知流程(如果对通知流程与发送流程不理解的请查看我的《”变换”深入理解》)，指定的是当前Observable.call()方法以及之后
讲述RxJava核心思想
shu_quan的博客
01-21 265
例: OkHttp是为了完成网络请求的一个需求 Glide是为了完成图片加载显示的一个需求 RxJava不能完成任何的需求他是为了转变编码思维,响应式流编程思维 改变思维有什么用呢?请往下看!!!!!!! 1.为什么要用Rxjava 传统方式编写代码 程序员(小明)编写方式 程序员(小杨)编写方式 rxjava编写方式 3.了解RxJava响应式流编程思维 所有的需求都会有起点和终点 例如1:点击获取数据,点击(起点)--->请求--->将...
RxJava核心思想
puppy的博客
02-04 289
为什么学习RxJava ? 改变思维来提升效率 RxJava核心思想 起点(被观察者)(Observable) 终点(观察者)(Observer)
fagdag-reactive:React式编程和 RxJava 主题日
06-23
通过学习和实践这个项目，您可以深入理解这两者如何协同工作，提升您的开发技能。 总之，React式编程和RxJava都是现代软件开发的有力工具，它们分别解决了UI组件化和异步数据处理的问题。将两者结合，可以为开发者...
Learning RxJava
07-14
通过学习本书，你可以更好地理解和掌握反应式编程的思想，提高自己的技术能力。 总之，《Learning RxJava》这本书是任何想要深入学习RxJava并将其应用于实际项目的开发者的必备资源。无论是初学者还是有一定经验的...
Reactive Streams 与 RxJava 2.0：理解响应式编程标准与规范
# 第一章：理解响应式编程 ## 1.1 什么是响应式编程 响应式编程是一种面向数据流和变化传播的编程范式。它利用异步数据流的概念，通过观察者模式实现对数据流的监听和处理，从而简化复杂的异步编程逻辑。 在响应式...
RxJava2.0异步请求
02-02
RxJava基于 Reactive Extensions (RX) 的理念，它将观察者模式、发布者订阅者模式和函数式编程思想融合在一起，使得处理事件和数据流变得更为简洁和高效。在异步请求中，RxJava提供了Observable（可观察者）和...
RxJava编程思想1-（实现简易版Rxjava，如何基本功能和链式调用？）
程序员
11-28 399
前言 已经使用rxjava两个月了，觉得rxjava特别好用，爱不释手。本文目的是通过几百行的代码，帮助大家理解rxjava中的链式调用，操作符，线程切换是如何实现的。记得代码自己敲一遍才能理解的更深刻。 Rxjava涉及的几个概念 Observable ：被观察者，用来生产发送事件； Observer：观察者，接收被观察者传来的事件； Data：数据，被观察者发出数据并传递给观察者；（数据传递过...
精通高级RxJava 2响应式编程思想
qingfengzhuy的博客
06-27 469
第1章 课程介绍—课程整体内容介绍简单介绍本系列课程的内容，并提前布置预先需要储备的知识。第2章 响应式编程思想概述—概念与案例讲解本章节主要阐释响应式编程思想，先做一个概念性的介绍，之后会以生活中的实例和代码实例相结合的方式来讲解。第3章 RxJava基本元素—源码解析与案例实践本章节开始进入源码讲解部分，主要讲RxJava的基本元素。先简单介绍和回顾RxJava，之后进入源码分析，再以实战项目...
RxJava 知识梳理(1) RxJava 基本思想
weixin_34411563的博客
12-21 113
一、基础概述 RxJava的关键是异步，即使随着程序的逻辑变得复杂，它依然能够保持简洁。 二、API介绍和原理剖析 观察者模式面向的需求是：A对象（观察者）对B对象（被观察者）的某种变化高度敏感，需要在B变化的一瞬间做出反应，观察者采用注册Register或者订阅Subscribe的方式，告诉观察者，我需要你的某某状态，并在它变化的时候通知我，在RxJava当中，Observable是被观察者，O...
RxJava核心思想（看懂再学RxJava）
zjcoming
08-11 510
文章目录【1】背景知识(异步与观察者模式）【2】RxJava有什么作用？【3】RxJava使用的模式：观察者模式【4】 RxJava的核心思想（流的思想）【5】最简单的使用：【6】 推荐阅读学习的RxJava好文 【1】背景知识(异步与观察者模式） 官网地址：https://github.com/ReactiveX/RxJava 在很多软件编程任务中，或多或少你都会期望你写的代码能按照编写的顺序，一次一个的顺序执行和完成。但是在ReactiveX(RX)中，很多指令可能是并行执行的，之后他们的执行结果才会
RxJava 使用及思想1
qq_44076155的博客
12-06 154
Rx 思维：响应式编程 生活中的例子： 起点（分发事件(PATH)：我饿了）----------下楼-------去餐厅--------点餐----------> 终点（吃饭 消费事件） 程序中的例子： 起点（分发事件：点击登录）----------登录API-------请求服务器--------获取响应码----------> 终点（更新UI登录成功 消费事件） Rx思维，从一个点（生产事件，需要处理的事件，对象）开始，中间可以使用各种操作符不断对这个点进行处理操作，进行完所.
深入理解RxJava的Side Effect Methods
afunyusong的专栏
07-27 1347
1. RxJava’s Side Effect MethodsRxJava’s Side Effect Methods 这篇文章可以让你对Side Effect Methods有更深的了解，建议好好品读一遍。 X 3 重要的话说三遍。时间有限，在这里我只说一些关键点。是什么？ RxJava’s Observable class has plenty of methods that can
RxJava的响应式编程思想
yueyue0211的博客
04-27 234
最近开始学习使用rxjava，记录一下自己边学边做的笔记。1，响应式编程是一种面向数据流和变化传播的编程范式。        数据流就是只能以实现规定好的顺序呗读取一次的数据的的一个序列        变换传播就是类似于观察者模式，变化了就要通知别人        计算机编程的基本风格和典范模式。2，响应式编程思想实例：        数据流的具体含义，在计算机中是数据，在现实中可以是任意对象组成...
RxJava编程思想理解
qq_26414049的博客
06-22 224
1.核心思想 有一个起点（Observable）、一个终点（Observer），事件从起点开始传递，无中断的流向终点，在传递的过程中，可以对事件进行拦截（拦截可以改变事件的返回值），但终点只关心它的上一个拦截 RxJava允许通过异步流的方式处理数据，并且提供了很多操作符，你可以将这些操作符作用于流上从而实现转换，过滤或者合并数据等操作。 假设有这样一个需求：我需要把网络上的一张图片，下载保存到本地，进行展示 传统的程序员会这样写 // 弹出加载框 private ProgressDi...
详细&全面的RxJava架构原理与设计讲解
u013643074的博客
07-04 840
RxJava是对响应式扩展（ Reactive Extensions，称之为 ReactiveX ）规范的Java 实现，该规范还有其他语言实现：RxJS、Rx.Net、RxScala、RxSwift等等（也即，ReactiveX 定义了规范，其他语言实现规范即可，所以我们这里学习RxJava的架构和设计思维，只需研究ReactiveX 即可）。......
深入理解RxJava响应式编程
对于初学者来说，理解RxJava的响应式编程思想至关重要。需要转变传统的命令式编程思维，将Observables视为数据生产者，而链式操作则代表数据处理过程。通过这种方式，开发者可以构建出更灵活、可维护的代码，提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值