Rxjava

最新推荐文章于 2022-04-30 03:22:59 发布
最新推荐文章于 2022-04-30 03:22:59 发布
阅读量306 收藏
点赞数
分类专栏： android开发 rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carpe_diem_vv/article/details/77575196
版权

Rxjava使用

Gradle配置

compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

一个简单的Rx

//创建 Observable：
    Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onComplete();
        }
    });
    //创建 Observer
    Observer<Integer> observer = new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.d(TAG, "subscribe");
        }

        @Override
        public void onNext(Integer value) {
            Log.d(TAG, "" + value);
        }

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

        @Override
        public void onComplete() {
            Log.d(TAG, "complete");
        }
    };
    //建立连接
    observable.subscribe(observer);

参数解释

Observable

翻译过来是被观察者，翻译成英文有点拗口，通俗点来说他就是事件发送者

Observer

观察者，他是接受发送的事件

ObservableEmitter

Emitter是发射器的意思，它可以发出三种类型的事件。

  • onNext(T value)
  • onComplete()
  • onError(Throwable error)

发送的事件的规则

  • Emitter可以发送无限个onNext, observer也可以接收无限个onNext.
  • 当Emitter发送了一个onComplete后, onComplete之后的事件将会继续发送, 而observer收到onComplete事件之后将不再继续接收事件.
  • 当Emitter发送了一个onError后, onError之后的事件将继续发送, 而observer收到onError事件之后将不再继续接收事件.

  • Emitter可以不发送onComplete或onError.

  • onComplete和onError，同时只能使用一个，onComplete多发（第一个发完，后面多发的没用），onError多发（后面再发会报错）

Disposable
  • 他是被观察者和观察者之间的开关，它开启了之后，被观察者的事件将不会被观察者所接受到。
  • 被观察者的所有事件都会发送出去，即使发送了onComplete，它之后的事件依然能被发送出去（正常是不会在onComplete之后再发送事件）。

subscribe构造参数

    //不管被观察者发送的事件
    public final Disposable subscribe() {}
    //只接受被观察者发送的onNext事件
    public final Disposable subscribe(Consumer<? super T> onNext) {}
    //类似上面
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
    //类似上面
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
    //类似上面
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
    //接受被观察者所有的事件类型
    public final void subscribe(Observer<? super T> observer) {}

线程切换

.subscribeOn(Schedulers.newThread())//被观察者线程                                              
.observeOn(AndroidSchedulers.mainThread()) //观察者线程
  • 多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略
  • 每调用一次observeOn() , 观察者的线程就会切换一次.
内置线程
  • Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
  • Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
  • Schedulers.newThread() 代表一个常规的新线程
  • AndroidSchedulers.mainThread() 代表Android的主线程

操作符

Map

对数据进一步加工

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
        }
    }).map(new Function<Integer, String>() {
        @Override
        public String apply(Integer integer) throws Exception {
            return "This is result " + integer;
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            Log.d(TAG, s);
        }
    });

FlatMap

FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里.

    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
        }
    }).flatMap(new Function<Integer, ObservableSource<String>>() {
        @Override
        public ObservableSource<String> apply(Integer integer) throws Exception {
            final List<String> list = new ArrayList<>();
            for (int i = 0; i < 3; i++) {
                list.add("I am value " + integer);
            }
            return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            Log.d(TAG, s);
        }
    });

android的一个使用场景：用户注册完成自动登陆。

api.register(new RegisterRequest())            //发起注册请求
            .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
            .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求注册结果
            .doOnNext(new Consumer<RegisterResponse>() {
                @Override
                public void accept(RegisterResponse registerResponse) throws Exception {
                    //先根据注册的响应结果去做一些操作
                }
            })
            .observeOn(Schedulers.io())                 //回到IO线程去发起登录请求
            .flatMap(new Function<RegisterResponse, ObservableSource<LoginResponse>>() {
                @Override
                public ObservableSource<LoginResponse> apply(RegisterResponse registerResponse) throws Exception {
                    return api.login(new LoginRequest());
                }
            })
            .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求登录的结果
            .subscribe(new Consumer<LoginResponse>() {
                @Override
                public void accept(LoginResponse loginResponse) throws Exception {
                    Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
                }
            }, new Consumer<Throwable>() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
                }
            });

concatMap

作用同上，区别是顺序的处理数据

Zip

android 使用场景：获取多个接口中的数据，同时展示。

顺序合并

将两个被观察者合并成一个观察者

Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {            
    @Override                                                                                         
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                      
        Log.d(TAG, "emit 1");                                                                         
        emitter.onNext(1);                                                                            
        Log.d(TAG, "emit 2");                                                                         
        emitter.onNext(2);                                                                            
        Log.d(TAG, "emit 3");                                                                         
        emitter.onNext(3);                                                                            
        Log.d(TAG, "emit 4");                                                                         
        emitter.onNext(4);                                                                            
        Log.d(TAG, "emit complete1");                                                                 
        emitter.onComplete();                                                                         
    }                                                                                                 
});                                                                   

Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {              
    @Override                                                                                         
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {                       
        Log.d(TAG, "emit A");                                                                         
        emitter.onNext("A");                                                                          
        Log.d(TAG, "emit B");                                                                         
        emitter.onNext("B");                                                                          
        Log.d(TAG, "emit C");                                                                         
        emitter.onNext("C");                                                                          
        Log.d(TAG, "emit complete2");                                                                 
        emitter.onComplete();                                                                         
    }                                                                                                 
});                                                                     

Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {                  
    @Override                                                                                         
    public String apply(Integer integer, String s) throws Exception {                                 
        return integer + s;                                                                           
    }                                                                                                 
}).subscribe(new Observer<String>() {                       
    @Override                                                                                         
    public void onSubscribe(Disposable d) {                                                           
        Log.d(TAG, "onSubscribe");                                                                    
    }                                                                                                 

    @Override                                                                                         
    public void onNext(String value) {                                                                
        Log.d(TAG, "onNext: " + value);                                                               
    }                                                                                                 

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

    @Override                                                                                         
    public void onComplete() {                                                                        
        Log.d(TAG, "onComplete");                                                                     
    }                                                                                                 
});
Zip异步合并

开启两个线程同步合并数据

Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {         
    @Override                                                                                      
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                   
        Log.d(TAG, "emit 1");                                                                      
        emitter.onNext(1);                                                                         
        Thread.sleep(1000);                                                                        

        Log.d(TAG, "emit 2");                                                                      
        emitter.onNext(2);                                                                         
        Thread.sleep(1000);                                                                        

        Log.d(TAG, "emit 3");                                                                      
        emitter.onNext(3);                                                                         
        Thread.sleep(1000);                                                                        

        Log.d(TAG, "emit 4");                                                                      
        emitter.onNext(4);                                                                         
        Thread.sleep(1000);                                                                        

        Log.d(TAG, "emit complete1");                                                              
        emitter.onComplete();                                                                      
    }                                                                                              
}).subscribeOn(Schedulers.io());                                                                   

Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {           
    @Override                                                                                      
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {                    
        Log.d(TAG, "emit A");                                                                      
        emitter.onNext("A");                                                                       
        Thread.sleep(1000);                                                                        

        Log.d(TAG, "emit B");                                                                      
        emitter.onNext("B");                                                                       
        Thread.sleep(1000);                                                                        

        Log.d(TAG, "emit C");                                                                      
        emitter.onNext("C");                                                                       
        Thread.sleep(1000);                                                                        

        Log.d(TAG, "emit complete2");                                                              
        emitter.onComplete();                                                                      
    }                                                                                              
}).subscribeOn(Schedulers.io());                                                                   

Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {               
    @Override                                                                                      
    public String apply(Integer integer, String s) throws Exception {                              
        return integer + s;                                                                        
    }                                                                                              
}).subscribe(new Observer<String>() {                    
    @Override                                                                                      
    public void onSubscribe(Disposable d) {                                                        
        Log.d(TAG, "onSubscribe");                                                                 
    }                                                                                              

    @Override                                                                                      
    public void onNext(String value) {                                                             
        Log.d(TAG, "onNext: " + value);                                                            
    }                                                                                              

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

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

Flowable

当被观察者发送的事件太多的时候，观察者就会处理不过来。具体来说就是：当Observable中发送一万个 emitter.onNext(1);事件，Observer执行的时候，也得按照这个数量和速度去接受和处理事件。Observer如果可以跟上Observable的数量和速度也就没有什么问题。但是Observer如果没有那个能力，就会出现问题。例如内存暴涨。

如何解决这个问题：根据原因，我们可以控制Observable发送的速度和数量。

filter

这个操作符是过滤数据，取部分数据。这样是控制发送的数量，但是会造成数据的丢失。 

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; ; i++) {
                emitter.onNext(i);
            }
        }
    }).subscribeOn(Schedulers.io())
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) throws Exception {
                    return integer % 10 == 0;
                }
            })
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.d(TAG, "" + integer);
                }
            });
sample

这个操作符是控制发送的速度，让Observable和Observer保持一个相对稳定的速度。但是他的缺点是性能的浪费。

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; ; i++) {
                emitter.onNext(i);
            }
        }
    }).subscribeOn(Schedulers.io())
            .sample(2, TimeUnit.SECONDS)  //sample取样
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.d(TAG, "" + integer);
                }
            });
Flowable

Flowable操作符可以综合上面的那个操作符的优点，它可以在默认线程缓存数据（大小是128事件），在异步线程中，可以根据Observer中的要求，Observable发送指定数量的事件mSubscription.request(n);
它比Observable多了个参数BackpressureStrategy.ERROR，主要是这个参数在帮我们控制发送事件的数量和速度。

它和Disposable有个类似的参数Subscription，还有个类似的方法Disposable.dispose()对比Subscription.cancel()。request(n)是Disposable不具有的。

public static void request(long n) {
    mSubscription.request(n); //在外部调用request请求上游
}

public static void demo3() {
    Flowable.create(new FlowableOnSubscribe<Integer>() {
        @Override
        public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
            Log.d(TAG, "emit 1");
            emitter.onNext(1);
            Log.d(TAG, "emit 2");
            emitter.onNext(2);
            Log.d(TAG, "emit 3");
            emitter.onNext(3);
            Log.d(TAG, "emit complete");
            emitter.onComplete();
        }
    }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber<Integer>() {

                @Override
                public void onSubscribe(Subscription s) {
                    Log.d(TAG, "onSubscribe");
                    mSubscription = s;  //把Subscription保存起来
                }

                @Override
                public void onNext(Integer integer) {
                    Log.d(TAG, "onNext: " + integer);
                }

                @Override
                public void onError(Throwable t) {
                    Log.w(TAG, "onError: ", t);
                }

                @Override
                public void onComplete() {
                    Log.d(TAG, "onComplete");
                }
            });
}
  • BackpressureStrategy.ERROR（默认存储128个事件）
  • BackpressureStrategy.BUFFER（存储所有）

  • BackpressureStrategy.DROP

    FLowable内部的默认的水缸大小为128, 因此, 它刚开始肯定会把0-127这128个事件保存起来, 然后丢弃掉其余的事件, 当我们request(128)的时候,下游便会处理掉这128个事件, 那么上游水缸中又会重新装进新的128个事件, 以此类推（如果发送10000个事件，第一次会存储0-127，Observer重新获取mSubscription.request(128)，就会从正在发送的事件中随机取连续128个事件）其他的丢弃。

  • BackpressureStrategy.LATEST

    同上，区别就是它总会获取到最后一个事件9999，另外127个是随机获取的一段连续事件，其他的丢弃。

参考

http://www.jianshu.com/u/c50b715ccaeb

未未
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava原理探究
u012366540的博客
01-02 398
前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 本文主要： 面向 刚接触Rxjava的初学者 提供了一份 清晰、简洁、易懂的Rxjava入门教程 涵盖 基本介绍、原理 & 具体使用等 解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题 希望你们会喜欢。 本文主要基于Rxjava 2.0 如果读...
Rxjava使用
qq_41675150的博客
12-06 263
依赖  /*RxAndroid所依赖的库*/ implementation 'io.reactivex:rxandroid:1.2.1' implementation 'io.reactivex:rxjava:1.1.6' package com.sn.rxandroid; import android.content.Intent; import android.os....
RxJava系列_01ObservableEmitter
az44yao的专栏
07-28 1529
RxJava源码打算花一周看看, 时间太少了, 不知道一周可以看几个操作符; 按以下的demo来学习一个RxJava的思路; demo: Observable .create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(ObservableEmitter<Integer> e) throws Exception.
RxJava之create方法 以及ObservableOnSubscribe和ObservableEmitter
ScottePerk的博客
04-30 1851
我们知道RxJava有非常多的方式创建数据源。其中就有一个create方法。 这个方法需要传一个ObservableOnSubscribe接口。里面有一个subscribe方法。 ObservableOnSubscribe直接翻译就是在订阅时可观察。这样就比较好理解了，这个接口就是用来创建可观察对象的，订阅就体现在subscribe方法，这个单词的意思就是订阅。 subscribe方法里面有一个ObservableEmitter类，这个类直接翻译就是可观察发射源，这个类就是用来发射数据的。怎么发射呢？emi
java 2.0-1.1_RxJava学习之旅二 2.0.1版本和1.0简单实用的对比讲解
weixin_30616309的博客
02-27 145
第一篇用了1.0版本的RxJava 从现在开始来使用2.0.1，还是使用新的好一些compile 'io.reactivex.rxjava2:rxjava:2.0.1'compile 'io.reactivex.rxjava2:rxandroid:2.0.1'解释一下其中两个陌生的玩意：ObservableEmitter和Disposable.ObservableEmitter： Emitter是...
RxJava2初探
fuyboy的专栏
05-10 308
RxJava：Java上的异步和基于事件响应式编程库； RxJava基于观察者模式，主要有四个部分：观察者，被观察者，订阅，事件。 基本写法： 1、Observable与Observer //被观察者 Observable&lt;Integer&gt; observable = Observable.create(new ObservableOnSubscribe&lt;Integer&...
RxJava学习
zuimeirensheng的博客
11-02 1014
Google 无人车之父带你进入无人驾驶之域http://cn.udacity.com/course/intro-to-self-driving-cars--nd113 前言 最近学习了一下RxJava，发现是个好东西，有点相见恨晚的感觉，一开始学习了RxJava 1.x，看了很多国内的博客，有点理解了，后来发现现在都 2.x 了，于是各种搜索，最后发现Season_zlc写的系列教程通俗易懂
RxJava使用
12-05
**RxJava**是一种在Java虚拟机上运行的反应式编程库，它被广泛应用于Android开发中，以提供异步操作和事件驱动编程的能力。在Android应用中，RxJava可以帮助开发者处理复杂的异步流程，简化代码结构，提高代码的...
rxjava-3.0.0.rar
02-21
RxJava是一款广泛应用于Android和Java开发中的响应式编程库，它允许开发者以声明式的方式处理异步数据流。在3.0.0版本中，这个库进行了大量的优化和改进，以适应现代编程需求。"rxjava-3.0.0.jar"是RxJava的核心库，...
Learning RxJava
07-14
### 学习RxJava：构建高并发、可维护与响应迅速的Java应用 #### 引言 《Learning RxJava》是一本专注于介绍RxJava库及其在构建高效、可维护及响应迅速的Java应用程序中的应用的专业书籍。作者Thomas Nield不仅是一...
你用不惯 RxJava，只因缺了这把钥匙(推荐)
08-26
主要介绍了RxJava操作符，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
RxJava 教程 PDF
02-14
**RxJava 教程概述** RxJava 是一个用于 Java VM 的反应式编程库，它将观察者模式和函数式编程的概念结合在一起，提供了一种处理异步数据流和事件序列的强大方式。在 Android 和 Java 开发中，RxJava 已经成为处理...
RXJava
03-16
RXJava，全称为Reactive Extensions for Java，是一个在Java虚拟机上运行的反应式编程库。它引入了一种新的编程范式，将事件处理和数据流管理结合在一起，使得开发者能够以声明性的方式处理异步数据。RXJava的核心...
RxJava初探
guozhao265的专栏
06-07 212
目录 一、预备知识 1.观察者模式(发布订阅模式) 一、预备知识 1.观察者模式(发布订阅模式)
RxJava2（一）完整生命周期
android开发笔记
06-20 598
简介： 1.RxJava用于通过使用被观察者Obverserable/Flowable序列来构建异步和基于事件的库。 2.RxJava支持Java5之后版本，还支持跑在JVM上的各种语言。 3.RxJava可以用在Android开发的任何地方，包括App所依赖的底层框架。 4.导入依赖： implementation "io.reactivex.rxjava2:rxjava:2.2.3" im...
Android主流三方库源码分析（五、深入理解RxJava源码，相关资料参考
m0_64383081的博客
12-09 360
} … } 这里仅仅是把ObservableOnSubscribe这个对象保存在ObservableCreate中了。然后看看RxJavaPlugins.onAssembly()这个方法的处理。 1.3、RxJavaPlugins#onAssembly() public static Observable onAssembly(@NonNull Observable source) { // 应用hook函数的一些处理，一般用到不到 … return source; } 最终仅仅是把我们的Observab
android第三方库好处,Android主流三方库源码分析（五、深入理解RxJava源码）
weixin_42553471的博客
05-26 101
前言一、RxJava到底是什么？RxJava是基于Java虚拟机上的响应式扩展库，它通过使用可观察的序列将异步和基于事件的程序组合起来。与此同时，它扩展了观察者模式来支持数据/事件序列，并且添加了操作符，这些操作符允许你声明性地组合序列，同时抽象出要关注的问题：比如低级线程、同步、线程安全和并发数据结构等。从RxJava的官方定义来看，我们如果要想真正地理解RxJava，就必须对它以下两个部分进行...
我为什么不再推荐RxJava
weixin_34280237的博客
05-06 1356
距离上一次更新也有一段时间了，其实这篇文章我早就想写，碍于一直没来得及总结（懒）。所以一直没有成文。来总结一下我RxJava遇到的坑，或者说我为什么不在推荐使用RxJava。 相信熟悉或者关注我的朋友，绝大多数都是因为RxJava。所以看到这个标题你已经会惊讶。 作为RxJava坚定的拥护者，或者说自干五？为什么突然不再支持RxJava了呢？ 先讲讲历史 在我的文章中已经讲过很多次RxJava诞生...
加载长图问题与解决方案
carpe_diem_vv的专栏
11-13 1532
# 长图加载问题总结 # ## 前言 ## 如果RecycleView或者listview的item中有IamgeView。小图片还好，如果图片过长或者过大就会出现加载不出、OOM这样的问题。 解决的方法也很简单： - 压缩图片 - 自定义控件支持大图显示 ## 压缩图片 ## 这个原理都写过了，但是一般不会让前段去压缩。将图片上传到后台，进行压缩显示。前段显示的时候一般也会再次进行压缩显示的。一般Glid
RxJava入门精要
"RxJava Essentials 是一本适合RxJava初学者的英文书籍，由Ivan Morgillo撰写，并已有了中文版的翻译。这本书主要涵盖了RxJava的核心概念和实践应用。" RxJava是Java平台上的一个库，它引入了反应式编程的概念，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值