首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Rxjava解析笔记 | Rxjava概述 & 传统观察者设计模式解析

Rxjava解析笔记 | Rxjava概述 & 传统观察者设计模式解析

作者头像
凌川江雪
发布2019-06-03 08:44:20
4660
发布2019-06-03 08:44:20
举报
文章被收录于专栏:李蔚蓬的专栏李蔚蓬的专栏

进行耗时任务

比如:在后台做一些网络操作、查询或者一些复杂计算的时候, 我们如果不用其他框架的话, 最常见做法即自己开一个子线程, 然后通过回调的形式获取到结果(如后台以结果为参数发送广播,前台回调onReceive()接收获取到结果); 但是这样有一个问题, 随着业务逻辑越来越复杂, 项目会陷入回调中套回调的病区, 这对后期维护代码来说是一个很严重的问题;


而Rxjava的出现解决了以上的问题

  • Rxjava本质上是一个异步操作库; 它是一个能用非常简单的逻辑,去处理那些繁琐复杂任务异步的操作事件库; Rxjava在一定的程度上, 也能替代项目中非常多的Handler、AsyncTask等等;

关于Rxjava的设计模式——观察者模式

定义对象间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到通知并被自动更新;
  • 在app开发中,如果有一个对象的状态/数据,是你非常要关心的, 同时你每个页面所有的UI都会跟这个对象绑定, 即当这个对象发生改变的时候,我们就需要通知所有的页面都去做UI改变; 以上所述其实便是一种观察者模式A对象对B对象的数据高度敏感, 当B对象变化的一瞬间,A对象要做出反应; 这时候A对象就是观察者,B对象就是被观察者; 观察者模式的情况, 就是众多的观察者,对被观察者的数据 高度敏感, 被观察者变化之后观察者自身的一种反应, 它是一种一对多的关系,多个观察者对应一个被观察者;
  • 观察者模式的UML类图
  • Observerable(被观察者接口,interface):
    • registerObserver():将观察者注册到被观察者当中;即订阅方法;
    • removeObserver():将观察者从被观察者中移出;取消订阅方法;
    • notifyObservers():当我们被观察者状态改变的时候,这个方法就会被调用; 而此方法内部又会调用观察者接口(Observer)update()方法, 去通知观察者(Observer)做出相应的处理改变;
  • ConcreteObserverable(被观察者具体的实现,class)
    • 实现了Observerable(被观察者接口,interface)定义的三个方法;
    • 定义了List<Observer>,用于保存注册好的观察者; 其泛型是Observer,是接口,而非具体的实现类, 这样做的原因就是, 为了让一个被观察者实例, 可以对应着,可能会有的, 多个实现了Observer(观察者)接口的观察者实现类, (一个被观察者实例可以对应多个观察者实现类实例) 如此便可把观察者和被观察者通过List进行解耦; 二来,泛型不指定具体的实现类,方便后续进行拓展, 即只要把拓展的观察者实现类去实现观察接口便合格, 由此可以实现各式各样的观察者;
  • Observer(观察者接口)
    • 定义了update()方法; 当我们被观察者状态改变的时候,notifyObservers()方法就会被调用; notifyObservers()内部则会调用本update()方法, 去通知观察者(Observer)做出相应的处理改变;
  • ConcreteObserver(观察者实现类) 具体实现了Observer(观察者接口)的update()方法;
简单看一下Observer的代码
  • Observerable接口:
package com.example.jiajiemu.a11.observe;



/**
 * Created by Mjj on 2017/10/6.
 */

public interface Observerable {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}
  • Observer接口:
package com.example.jiajiemu.a11.observe;

/**
 * Created by Mjj on 2017/10/6.
 */

public interface Observer {
    public void update(int edition,float cost);
}
  • ConcreteObserverable实现类:
package com.example.jiajiemu.a11.observe;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Mjj on 2017/10/6.
 */

public class ConcreteObserverable implements Observerable {

    private List<Observer> mObservers;
    private int edition;
    private float cost;

    public ConcreteObserverable() {
        mObservers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        mObservers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = mObservers.indexOf(o);
        if(i >= 0)
            mObservers.remove(i);
    }

    @Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            observer.update(edition, cost);
        }
    }

    public void setInfomation(int edition,float cost){
        this.edition = edition;
        this.cost = cost;
        //信息更新完毕,通知所有观察者
        notifyObservers();
    }

}
  • .
    • notifyObservers(): 可以看到方法中所写,遍历所有观察者, 依次使每一个观察者调用update()方法进行数据更新 (update()方法在ConcreteObserver中具体实现):
    @Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            observer.update(edition, cost);
        }
    }
  • ConcreteObserver实现类:
package com.example.jiajiemu.a11.observe;

/**
 * Created by Mjj on 2017/10/6.
 */

public class ConcreateObserver implements Observer {

    private String name;
    private int edition;
    private float cost;

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

    @Override
    public void update(int edition, float cost) {
        this.edition = edition;
        this.cost = cost;
        buy();
    }

    public void buy(){
        System.out.println(name+"购买了第"+edition+"期的杂志,花费了"+cost+"元。");
    }

}
  • .
    • 主要实现, update()方法中添加的业务逻辑buy()方法, buy()方法是可以根据不同场景做相应的逻辑判断,数据更新; 或者可以在update()方法中添加更多的业务逻辑
  • Client客户端测试类:
package com.example.jiajiemu.a11.observe;

/**
 * Created by Mjj on 2017/10/6.
 */

public class Client {
    public static void main(String[] args) {
        //创建被观察者
        ConcreteObserverable concreteObserverable = new ConcreteObserverable();

        //创建三个不同的观察者
        Observer observerA = new ConcreateObserver("A");
        Observer observerB = new ConcreateObserver("B");
        Observer observerC = new ConcreateObserver("C");

        //将观察者注册到被观察者中
        concreteObserverable.registerObserver(observerA);
        concreteObserverable.registerObserver(observerB);
        concreteObserverable.registerObserver(observerC);

        //更新被观察者中的数据,当数据更新后,会自动通知所有已注册的观察者
        concreteObserverable.setInfomation(5, 12);
    }

}
  • .
    • setInformation(),封装了一下notifyObservers():
@Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            observer.update(edition, cost);
        }
    }

    public void setInfomation(int edition,float cost){
        this.edition = edition;
        this.cost = cost;
        //信息更新完毕,通知所有观察者
        notifyObservers();
    }

传统观察者模式的使用场景

1.一个方面的操作/处理依赖于另一个方面的状态变化 (即观察者的操作依赖于被观察者的状态变化; 埋伏中的警察的操作依赖于小偷的状态变化, 球迷的操作依赖于球赛的状态变化)

  1. 如果在更改一个对象的时候, 需要同时连带改变其他的对象;
  2. 当一个对象必须通知其他的对象, 但是你又希望这个对象和其他被通知的对象是松散耦合的;

参考自 慕课网

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2019.06.02 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 进行耗时任务
  • 而Rxjava的出现解决了以上的问题
  • 关于Rxjava的设计模式——观察者模式
    • 定义对象间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到通知并被自动更新;
      • 简单看一下Observer的代码
      • 传统观察者模式的使用场景
      领券
      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档