Android：rxjava简单实现原理（map/flatmap操作符）

最新推荐文章于 2022-02-22 21:23:57 发布
最新推荐文章于 2022-02-22 21:23:57 发布
阅读量833 收藏
点赞数
分类专栏： Android 文章标签： map/flatmap rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JMW1407/article/details/119517435
版权

rxjava

装饰者模式

1、背景

假设奶茶店有两种茶，果茶（fruit tea）和奶茶(milky tea)，同时这两种茶饮料可以添加不同的配料 果肉（pulp）或者蔗糖（sugar），茶品可以和配料进行组合，所以可以得到：

  • 1、pulp_fruit_tea（果茶加果肉）
  • 2、pulp_milky_tea（奶茶加果肉）
  • 3、sugar_fruit_tea（果茶加糖）
  • 4、sugar_milky_tea（奶茶加糖）
  • 5、 fruit_tea（果茶）
  • 6、milky_tea（奶茶）
    日后还会增加新的茶品和配料。

1、采用单一继承的方式的UML图： 有多少个技能就写多少个子类来继承这个tea类。
在这里插入图片描述
可以明显发现一个问题：就是随着物品修饰种类的增加，继承的类也越来越多，每增加一个技能可以组合出N个子类，那不就要加到天荒地老？
2、直接抽象一个tea类，里面包含了所有的配料。

在这里插入图片描述
这样子有多少个角色就增加多少个子类就可以了，不用根据技能增加类，避免造成子类爆炸，但是，每个角色的技能是可以叠加使用的，角色越多或者技能叠加种类越多，那么就要在超类增加越多的方法，而且直接修改超类不符合开闭原则（超类对扩展开放，对修改关闭）。

综上：

  • 装饰模式实际上是一直提倡的组合代替继承的实践方式,个人认为要理解装饰者模式首先需要理解为什么需要组合代替继承,继承又是为什么让人深恶痛绝.

为什么建议使用组合代替继承?
面向对象的特性有继承与封装,但两者却又有一点矛盾,继承意味子类依赖了父类中的实现,一旦父类中改变实现则会对子类造成影响,这是打破了封装性的一种表现. 而组合就是巧用封装性来实现继承功能的代码复用.

2、定义

1.定义：

-装饰器模式又名包装(Wrapper)模式。动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

  • 装饰器模式以对客户端透明的方式拓展对象的功能，是继承关系的一种替代方案。

在这里插入图片描述
UML关系图说明：

继承关系：实线、空三角箭头 ，具体装饰继承Decorator，Decorator继承Component； 聚合：实线、菱形

  • 1、抽象构件(Component)角色：一个抽象接口。装饰对象和被装饰对象【具体组件对象】共有的父类接口。这样客户端对象就能以相同的方式操作具体组件对象和装饰对象【或者说可以将装饰类作为组件类看待】

  • 2、具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类。装饰模式是为这个基类动态添加新功能。

  • 3、装饰(Decorator)角色：装饰对象包含一个真实组件对像的引用。它的作用是接受需要扩展功能的具体组件类；实现抽象组件接口，使得在动态添加功能时具体装饰类和具体组件类用法相同，使模式更加灵活。

  • 4、具体装饰(ConcreteDecorator)角色：负责给构件对象“贴上”附加的责任。

3、特征

  • 需要扩展一个类的功能或给一个类增加附加责任。
  • 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
  • 需要增加由一些基本功能的排列组合而产生的非常大量的功能

优点：

  • 1、装饰这模式和继承的目的都是扩展对象的功能，但装饰者模式比继承更灵活 通过使用不同的具体装饰类以及这些类的排列组合，设计师可以创造出很多不同行为的组合装饰者模式有很好地可扩展性
  • 2、装饰类和被装饰类可以独立发展，而不会相互耦合。Component类无须知道Decorator类，而Decorator也不用知道具体的构件，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时再对其进行组合，原有代码无须改变，符合“开闭原则”。

缺点：

  • 装饰者模式会导致设计中出现许多小对象，如果过度使用，会让程序变的更复杂。并且更多的对象会是的差错变得困难，特别是这些对象看上去都很像。

4、装饰者模式demo

在这里插入图片描述

//被装饰者的对象接口
public interface Drink {
    public float cost();
    public String desc();
}

//具体的被装饰者
public class Dounai implements Drink{
    @Override
    public float cost() {
        return 3f;
    }
    @Override
    public String  desc() {
        return "纯豆奶";

    }
}

//装饰者的基类
public abstract class Decroator implements Drink  {
    private Drink drink; //要装饰的对象

    public Decroator(Drink drink) {
        this.drink = drink;
    }

    @Override
    public float cost() {
        return drink.cost();
    }

    @Override
    public String desc() {
      return  drink.desc();
    }
}

//具体的装饰者
public class Blackdou extends Decroator {
    public Blackdou(Drink drink) {
        super(drink);
    }

    @Override
    public float cost() {
        return super.cost()+2f;
    }

    @Override
    public String desc() {
        return super.desc()+"+黑豆";
    }
}

//具体的装饰者类
public class SugarDecroator extends Decroator {
    public SugarDecroator(Drink drink) {
        super(drink);
    }
    @Override
    public float cost() {
        return super.cost()+1f;
    }
    @Override
    public String desc() {
        return super.desc()+"+糖";
    }
}

//具体的装饰者类
public class SugarDecroator extends Decroator {
    public SugarDecroator(Drink drink) {
        super(drink);
    }
    @Override
    public float cost() {
        return super.cost()+1f;
    }
    @Override
    public String desc() {
        return super.desc()+"+糖";
    }
}

实验结果

这杯豆浆价格为：6.0
描述为：纯豆奶+黑豆+糖

rxjava装饰者模式

在这里插入图片描述
在这里插入图片描述

1、rxjava中转换操作符map的简单实现

Observable类

/**
 * 被观察者的核心抽象类
 * 也是使用框架的入口
 * @param <T>
 */
public abstract class Observable<T> implements ObservableSource<T> {
    @Override
    public void subscribe(Observer observer) {
        // 和谁建立订阅？
        // 怎么建立订阅？
        // 为了保证拓展性，交给具体的开发人员实现。这里提供一个抽象的方法
        subscribeActual(observer);
    }
    protected abstract void subscribeActual(Observer<T> observer);
	//creat操作符
    public  static <T> Observable<T> create(ObservableOnSubscribe<T> source){
        return new ObservableCreate<>(source);
    }
    //map操作符
	public <R> ObservableMap<T, R> map(Function<T, R> function) {
        return new ObservableMap<>(this, function);
    }
    //flatmap操作符
    public <R> ObservableFlatMap<T, R> flatMap(Function<T, ObservableSource<R>> function) {
        return new ObservableFlatMap<>(this, function);
    }
}

Observer接口

public interface Observer<T> {
    void onSubscribe();//建立订阅关系时候的回掉方法，什么时候和被观察者建立订阅关系，就会调用该方法
    void onNext(T t);
    void onComplete();
    void onError(Throwable throwable);

}

ObservableCreate类

/**
 * 1、创建一个被观察者
 * 2、被观察者发射事件由具体的either发射器来完成
 * @param <T>
 */
public class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;//创建一个被观察者
    }

    @Override
    protected void subscribeActual(Observer<T> observer) {
        observer.onSubscribe();//建立订阅的时候调用
        CreateEmitter<T> emitter = new CreateEmitter<T>(observer);
        source.subscribe(emitter);
    }

    static class CreateEmitter<T> implements Emitter<T>{
        Observer<T>observer;//这里持有一个观察者，当事件发生时，直接调用该观察者对事件进行调用即可。
        boolean done;//互斥实现

        public  CreateEmitter(Observer<T> observer){
            this.observer = observer;
        }

        public void onNext(T t){
            if(done) return;
            observer.onNext(t);
        }

        public void onError(Throwable throwable){
            if(done) return;
            observer.onError(throwable);
            done = true;
        }

        public void onComplete(){
            if(done) return;
            observer.onComplete();
            done = true;
        }
    }

}

Emitter接口

/**
 * 事件发射器
 * @param <T>
 */
public interface Emitter<T> {
    void onNext(T t);
    void onComplete();
    void onError(Throwable throwable);
}

ObservableOnSubscribe接口

/**
 * 被观察者和事件发射器建立关系
 * 被观察者和事件之间解偶
 * @param <T>
 */
public interface ObservableOnSubscribe<T> {
    void subscribe(Emitter<T> emitter);
}

ObservableSource接口

/**
 * 被观察者的顶层接口
 * @param <T>
 */

public interface ObservableSource<T> {
    void subscribe(Observer<T>observer);
}

Function接口

/**
 * 数据源转换函数
 * @param <T>
 * @param <R>
 */
public interface Function<T,R>{

    R apply(T t);
}

ObservableMap

public class ObservableMap<T, U> extends AbstractObservableWithUpStream<T, U> {
    Function<T, U> function;

    public ObservableMap(ObservableSource<T> source, Function<T, U> function) {
        super(source);
        this.function = function;
    }

    @Override
    protected void subscribeActual(Observer<U> observer) {
        source.subscribe(new MapObserver<>(observer,function));
    }

    static class MapObserver<T, U> implements Observer<T> {
        final Observer<U> downStream;
        final Function<T, U> mapper;

        public MapObserver(Observer<U> downStream, Function<T, U> mapper) {
            this.downStream = downStream;
            this.mapper = mapper;
        }

        @Override
        public void onSubscribe() {
            downStream.onSubscribe();
        }

        @Override
        public void onNext(T t){
        //map操作符的具体实现
            U u = mapper.apply(t);
            downStream.onNext(u);
        }

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

        @Override
        public void onError(Throwable throwable){
            downStream.onError(throwable);
        }
    }

}

AbstractObservableWithUpStream

/**
 * 抽象装饰类
 * @param <T>
 * @param <U>
 */
public abstract class AbstractObservableWithUpStream<T,U> extends Observable<U>{
    protected final ObservableSource<T> source;//在这个基础上进行装饰

    public AbstractObservableWithUpStream(ObservableSource<T>source){
        this.source = source;
    }

}

RxjavaTest

public class RxjavaTest {
    public static void main(String[] args) {
        Observable.create(new ObservableOnSubscribe<Object>() {
                    @Override
                    public void subscribe(Emitter<Object> emitter) {
                        System.out.println("subscribe:.....");
                        emitter.onNext("aaaa");
                        emitter.onNext("CCCC");
                        emitter.onNext("ddddd");
                        emitter.onError(new Throwable());
                        emitter.onComplete();
                    }

                }).map(new Function<Object, Object>() {
                    @Override
                    public Object apply(Object o) {
                        return "处理后的+ " + o;
                    }
                })
                /*.flatMap(new Function<Object, ObservableSource<Object>>() {
                    @Override
                    public ObservableSource<Object> apply(Object o) {
                        return Observable.create(new ObservableOnSubscribe<Object>() {
                            @Override
                            public void subscribe(Emitter<Object> emitter) {
                                emitter.onNext("处理后的" + o);
                            }
                        });
                    }
                })*/
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe() {
                        System.out.println("onSubscribe...");
                    }

                    @Override
                    public void onNext(Object o) {
                        System.out.println("onNext:.... " + o);
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("onComplete:... ");
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        System.out.println("onError :... ");
                    }
                });
    }

}

实验结果

onSubscribe...
subscribe:.....
onNext:.... 处理后的：aaaa
onNext:.... 处理后的：CCCC
onNext:.... 处理后的：ddddd
onError :...

2、rxjava中转换操作符flatmap的简单实现

ObservableFlatMap

public class ObservableFlatMap<T, U> extends AbstractObservableWithUpStream<T, U> {

    Function<T, ObservableSource<U>> function;

    public ObservableFlatMap(ObservableSource<T> source, Function<T, ObservableSource<U>> function) {
        super(source);
        this.function = function;
    }

    @Override
    protected void subscribeActual(Observer<U> observer) {
        source.subscribe(new MergeObserver<>(observer, function));
    }

    static class MergeObserver<T, U> implements Observer<T> {

        final Observer<U> downStream;

        final Function<T, ObservableSource<U>> mapper;

        public MergeObserver(Observer<U> downStream, Function<T, ObservableSource<U>> mapper) {
            this.downStream = downStream;
            this.mapper = mapper;
        }

        @Override
        public void onSubscribe() {
            downStream.onSubscribe();
        }

        @Override
        public void onNext(T t) {
            ObservableSource<U> observable = mapper.apply(t);
            observable.subscribe(new Observer<U>() {
                @Override
                public void onSubscribe() {

                }

                @Override
                public void onNext(U u) {
                    downStream.onNext(u);
                }

                @Override
                public void onComplete() {

                }

                @Override
                public void onError(Throwable throwable) {

                }
            });
        }

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

        @Override
        public void onError(Throwable throwable) {
            downStream.onError(throwable);
        }
    }


}

RxjavaTest

public class RxjavaTest {
    public static void main(String[] args) {
        Observable.create(new ObservableOnSubscribe<Object>() {
                    @Override
                    public void subscribe(Emitter<Object> emitter) {
                        System.out.println("subscribe:.....");
                        emitter.onNext("aaaa");
                        emitter.onNext("CCCC");
                        emitter.onNext("ddddd");
                        emitter.onError(new Throwable());
                        emitter.onComplete();
                    }

                }).flatMap(new Function<Object, ObservableSource<Object>>() {
                    @Override
                    public ObservableSource<Object> apply(Object o) {
                        return Observable.create(new ObservableOnSubscribe<Object>() {
                            @Override
                            public void subscribe(Emitter<Object> emitter) {
                                emitter.onNext("处理后的" + o);
                            }
                        });
                    }
                })
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe() {
                        System.out.println("onSubscribe...");
                    }

                    @Override
                    public void onNext(Object o) {
                        System.out.println("onNext:.... " + o);
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("onComplete:... ");
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        System.out.println("onError :... ");
                    }
                });
    }

}

实验结果

在onSubscribe...
subscribe:.....
onNext:.... 处理后的aaaa
onNext:.... 处理后的CCCC
onNext:.... 处理后的ddddd
onError :... 

Process finished with exit code 0
JMW1407
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava框架时序图-map操作符
01-04
RxJava框架时序图-map操作符,RxJava框架时序图-map操作符
Android + Rxjava + Rxjava操作符
04-23
Rxjava源码剖析 1：Rxjava创建操作符：...2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , subscribeOn() ，observerOn()） 5：过滤操作符：（filter() ）
RxJava2 操作符 map与 flatMap
oneblue123的博客
04-02 4423
(一) map就是变换需要操作的数据内容或者结构的意思使用场景:当原始数据不能满足我们的需求，但我们却需要依赖这一原始数据去获取满足我们需求的数据时，那么就用它原理图如下:举个栗子:结果:(二) flatmap1.解决for循环嵌套private static class Student{ private int id; private String name; priva...
RxJava 中的map与flatMap
Grekit_Sun的博客
02-07 2074
1、map和flatMap都是接受一个函数作为参数(Func1) 2、map函数只有一个参数，参数一般是Func1，Func1的<I,O>I,O模版分别为输入和输出值的类型，实现Func1的call方法对I类型进行处理后返回O类型数据3、flatMap函数也只有一个参数，也是Func1,Func1的<I,O>I,O模版分别为输入和输出值的类型，实现Func1的call方法对I类型进行处理后返回O类型数据，不过这里O为Observable类型 map 先说 map，一个简单的例子 .
RxJava flatmap
05-12 685
RxJava flatmapflatMap() 中返回的是个 Observable 对象，并且这个 Observable 对象并不是被直接发送到了 Subscriber的回调方法中。 flatMap() 的原理是这样的：1. 使用传入的事件对象创建一个 Observable 对象；2. 并不发送这个 Observable, 而是将它激活，于是它开始发送事件；3. 每一个创建出来的 Observabl
map原理 java_RxJava的基本原理以及Map，flatMap的原理
weixin_34696006的博客
02-26 177
前言：RxJava想必很多人都用过了,其实也是一早就接触过这个框架了,但是最近看了下一些关于是否需要使用RxJava的文章，对于RxJava的优点缺点有了更深的理解，然后看了论坛上有朋友提到很难理解Map，flatMap的区别，所以突然兴致来了，想写一点点东西，从源码出发简单的聊一下这两个方法的区别以及使用，通过通俗易懂的方式使大家能轻松简单的理解他们，好的让我们开始吧：首先我看来看看RxJava...
RxJava（三） flatMap 操作符用法详解
热门推荐
Chiclaim
05-29 5万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
Android开发 -- RxJava 操作符 map 和 flatMap 新手理解、新手通俗、通俗解释、通俗、简单讲解
u014093134的博客
01-25 799
全文阅读预计 10 分钟 这可能是你看过的最清晰明了的讲解 写在前面：RxJava 新手可能会对 map、flatMap 等一系列对操作符产生疑问，但有些例子又很难懂，这里通过最通俗易懂的方法为你讲述它们究竟是什么东西，至于以后如何用，你要先知道它们的作用了解它们的用法，用什么是你的需求决定的，所以，当你了解的多了自然知道用那个最合适，关键是了解。 正文 ???? map 先说 map，一个简单的...
【Android】RxJava的使用（三）转换——map、flatMap
linder_qzy的专栏
08-02 653
转自：http://www.jianshu.com/p/52cd2d514528 前两篇Android RxJava的使用（一）基本用法、Android RxJava的使用（二）Action介绍了RxJava的基本用法，对Rxjava还不了解的请先看以上两篇。这篇为大家讲解RxJava中map和flatMap的使用。 参考：给 Android 开发者的 RxJava 详解 （本文部分
Android复习系列④之《Android进阶》
路漫漫其修远兮，吾将上下而求索
02-22 2864
OkHttp、Retrofit、手写图片加载库思路、RxJava、Android IPC机制、组件化、插件化、热修复、JetPack、Bitmap、ANR、LeakCanary等等技术复习。
RxJava（二） map 操作符用法详解
Chiclaim
05-29 2万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
生怕认可java+flatmap,RxJava 操作符flatMap 与 concatMap详解
weixin_34177601的博客
03-27 461
本文独家发布到公众号：Android技术杂货铺封面图－pixabay近两年来，RxJava可以说是异常的火爆，受到众多开发者的追捧与青睐，虽然后入门的门槛较高，学习成本较大，但是还是掀起一场学习Rxjava的狂潮。为什么呢？因为RxJava的特性：轻松的线程切换、流式的API写法和强大的操作符。这使得我们做异步操作变得很简单，不用像以前一样写各种Handler来回调主线程，只需要一个操作符一行代码...
RxBasicsKata:RxJava学习者的实际挑战
03-04
使用JUnit测试作为接受标准来学习RxJava会遇到一系列简单的代码挑战。 侧重于一些基本概念，但尚未涵盖任何Android主题。 当前实施 依存关系： RxJava 2.1.7 JUnit 4.12 涵盖的React类型： 可观察：Rx的心脏，一...
Java 8 Stream Api 中的 map和 flatMap 操作方法
08-25
Java 8提供了非常好用的 Stream API ,可以很方便的操作集合。今天通过这篇文章给大家分享Java 8 Stream Api 中的 map和 flatMap 操作方法,需要的朋友可以参考下
Scala学习第一天（十五）：函数式编程（foreach遍历/map映射/flatMap扁平化映射/filter过滤/sort排序/groupBy分组/reduce聚合/fold折叠）
01-07
学习目标遍历（foreach）使用类型推断简化函数定义使用下划线来简化函数定义映射（map）扁平化映射（flatMap）过滤（filter）排序（sort）默认排序 | sorted指定字段排序 | sortBy自定义排序 | sortWith分组（group...
Android响应式编程开发RxAndroid（4）：flatMap
Zhang Phil
03-02 2031
Android响应式编程开发RxAndroid（4）：flatMapRxAndroid的map通过Function把一个对象转换为另外一个对象，作为结果输出。flatMap则可以通俗的理解为把一个集合元素对象拆分成单个元素对象，然后丢给Observer作为输入。例子：package zhangphil.app; import android.app.Activity; import androi
Android从零开始学习Rxjava2（四）—— Map
DYJALY的专栏
11-26 502
rxjava2变换运算符 Map 将Observable发出的每个项目通过函数应用转换后发出。 上面的图很好的解释了map方法的含义。在工作中也很常遇见这种情况，源Observable发出的项，不是我们直接想要的，这时候就需要对Observable发出的项变换处理。 举个例子： private void doSomeWork() { Observable.just(&amp;amp;quot;0&amp;amp;quot;, &amp;amp;quot
android 定义map,Android进阶学习RxJava(四)map和flatMap等操作符使用从入门到精通
weixin_29557763的博客
05-26 339
先介绍map概念官方文档transform the items emitted by an Observable by applying a function to each item.通过对每个项应用一个函数来转换可观察对象发出的项。(百度翻译)个人理解: Observable 到 Observer 之间传递的数据转换重点: Transformation简单的试试怎么用假设古代钱币加工是先做成圆...
android java map_【Android】RxJava的使用（三）转换——map、flatMap
weixin_29587979的博客
02-22 193
前两篇Android RxJava的使用(一)基本用法、Android RxJava的使用(二)Action介绍了RxJava的基本用法，对Rxjava还不了解的请先看以上两篇。这篇为大家讲解RxJava中map和flatMap的使用。回顾前两篇为大家介绍了使用RxJava打印多个字符串的方法Observable.just("Hellow", "Wrold").subscribe(new Acti...
map/flatMap
最新发布
09-15
map和flatMap是Scala中常用的函数操作，它们可以对集合中的元素进行处理和转换。 map函数接受一个函数作为参数，然后对集合中的每个元素应用该函数，并返回处理后的结果集。例如，对于一个整数集合，我们可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值