RXJava入门01

最新推荐文章于 2024-08-21 13:30:00 发布
最新推荐文章于 2024-08-21 13:30:00 发布
阅读量263 收藏
点赞数
分类专栏： RXJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piziliul/article/details/77530870
版权
1.RXJava概述:Rx是Reactive Extensions的简写，翻译为响应的扩展。也就是通过由⼀一⽅方发出信息，另⼀一⽅方响应信息并 作出处理理的核⼼心框架代码RxJava作为⼀一个流⾏行行的框架，其源码依托在GitHub,除了了⽀支持RxJava，针对安卓系统也除了了⼀一个⽀支持框 架RxAndroid
2.RXJava依赖的框架(这里介绍的是1.0版本的)
compile 'io.reactivex:rxandroid:1.2.1'

compile 'io.reactivex:rxjava:1.1.6

3.RXJava响应的核心(案例:订阅报社)

被观察者:

 // 1.报社 --->被观察者Observable(可观察的)
        final Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("被观察者发送信息1");
                // 每次发送完毕之后 最好调用onCompleted()告诉观察者 发送事件完毕了
                // 注意 : 只要调用subscriber.onCompleted();方法之后,name后面的事件就不会被调用
                subscriber.onNext("被观察者发送信息2");
                subscriber.onNext("被观察者发送信息3");
                subscriber.onNext("被观察者发送信息4");
                subscriber.onCompleted();
                //模拟一个空指针 只要调用onError() 那么后面的事件就不会被接收到了
                subscriber.onError(new NullPointerException("mock exception !"));
                subscriber.onNext("被观察者发送信息5");
            }
        });
观察者: 
// 2.家--->观察者
        Observer<String> observer = new Observer<String>() {

            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

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



订阅:
// 3.关联--->订阅(subscribe)
        // 原理:只要调用了这个subscribe()犯法,系统内部就会被调用被观察者的Observablede call()方法
        // 接着就会让被观察者发送事件 观察者就能够接收对应的事件
        observable.subscribe(observer);
4.特殊的被观察者Single
public static void test2() {
        // 1.报社 --->被观察者Observable(可观察的)
        // single对象只能调用onError(),onSuccess()两个方法,且只能调用一次
        Single<String> singleObservable = Single.create(new Single.OnSubscribe<String>() {
            @Override
            public void call(SingleSubscriber<? super String> singleSubscriber) {
//                singleSubscriber.onSuccess("调用onSuccess()方法");//系统内部就会调用观察者对象的onNext+onComplete()
//                singleSubscriber.onSuccess("调用onSuccess()方法");// 不会执行
                singleSubscriber.onError(new NullPointerException("mock exception !")); //系统内部就会调用观察者对象的onError()
            }
        });
        // 2.家--->观察者
        Observer<String> observer = new Observer<String>() {

            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

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

            @Override
            public void onNext(String s) {
                Log.e("TAG", "onNext: " + s);
            }
        };
        // 3.关联--->订阅(subscribe)
        singleObservable.subscribe(observer);
    }
5.Subscriber该对象本身继承了Observer,对象实现了了onNext()&onCompleted()&onError()事件,我们如果对哪个事件⽐比较关⼼心,只需要实现对应的⽅方法 
public static void test3() {
        // 1.报社 --->被观察者Observable(可观察的)
        final Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("被观察者发送信息1");
                //subscriber.onCompleted();
                subscriber.onError(new NullPointerException("mock exception !"));
            }
        });
        // 2.家--->观察者Subscriber是Observer的子类 他还提供了取消订阅和判断是否订阅的方法
        Subscriber<String> SubscriberObserver = new Subscriber<String>() {

            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

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

            @Override
            public void onNext(String s) {
                Log.e("TAG", "onNext: " + s);
            }
        };
        // 3.关联--->订阅(subscribe)
        observable.subscribe(SubscriberObserver);
    }




针对上述代码,如果我们只关心onNext(),但是却不不得不不实现onCompleted()&onError()事件.这样的代码就显 得很臃肿。鉴于这种需求，RxJava框架在订阅⽅方⾯面做了了特定的调整，代码如下：


public static void test4() {
        final Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("test4   被观察者发送信息1");
                subscriber.onCompleted();
                //subscriber.onError(new NullPointerException("mock exception !"));
            }
        });
        // 如果只关心onNext()事件,而不关心onCompleted()/onError()
        //如果只关心onNext事件 那么被观察者发送了异常而没人处理 就会抛给系统
        //---->创建的异常会被抛出
        Action1<String> onNextAction = new Action1<String>() {

            @Override
            public void call(String s) {
                Log.e("TAG", "call: " + s);
            }
        };
        // 关心Error事件
        Action1<Throwable> onErrorAction = new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.e("TAG", "call: " + throwable.getLocalizedMessage());
            }
        };
        Action0 onCompletedAction = new Action0() {
            @Override
            public void call() {
                Log.e("TAG", "call: " + "onCompletedAction");
            }
        };
        // 关心onComplete事件
        // 3.关联--->订阅(subscribe)
        observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

        // 对Action的总结:
        // 所谓的Action就是只有一个内部方法的Action类,而且都没有返回值
        // Action0:没有参数,Action1: 有一个参数,Action2有两个参数
        // Action最对有九个参数--->Action9
        // ActionN : 一般不用,这个类,是由我们自己去创建的

        // 对应的技术还有Func
        //所谓的Func 内部只有一个方法 并且方法都是有返回值  返回值的类型就是最后一个泛型指定的数据类型。
        //Func是从Func0---->Func9(只有8个参数 最后一个参数给了返回值)
        new Func0<String>() {

            @Override
            public String call() {
                return null;
            }
        };





6.Subject既可以作为被观察者又可以作为观察者,这一点查看源码就可以发现
Subject<T, R> extends Observable<R> implements Observer<T>
1.AsyncSubject作为被观察者在创建之后就可以直接发送数据(不用订阅之后擦发送数据),它只接受最后一个onNext()事件
public static void test5() {
        //Subject<T, R> extends Observable<R> implements Observer<T>
        // 创建一个被观察者
        //AsyncSubject他在创建之后就可以发送数据（不用订阅之后再发送数据）它只接收最后一个onNext()事件(在onComplete调用之前)
        //只要没有onComplete被发送 那么观察者就接收不到任何信息
        AsyncSubject<String> asyncObservable = AsyncSubject.create();
        asyncObservable.onNext("Subject AsyncSubject1");
        asyncObservable.onNext("Subject AsyncSubject2");
        asyncObservable.onNext("Subject AsyncSubject3");
        asyncObservable.onNext("Subject AsyncSubject4");
        //asyncObservable.onCompleted();
        asyncObservable.onError(new NullPointerException("mock exception !"));
        // 直接蹦,报错

        // 创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "test5 call: " + s);
            }
        };
        // 实现订阅
        asyncObservable.subscribe(onNextAction);
    }
2.behaviorSubject是以订阅方法



 public static void test6() {
        // 1.创建一个被观察者 BehaviorSubject是以订阅方法作为分界线的
        //只发送订阅前最后一个onNext事件和订阅后的所有onNext事件
        //如果订阅前没有发送数据 那么就会接收构造器里面默认的事件和订阅后的事件。
        BehaviorSubject<String> behaviorObservable = BehaviorSubject.create("DEFAULT");
//        behaviorObservable.onNext("1-Subject BehaviorSubject");
//        behaviorObservable.onNext("2-Subject BehaviorSubject");
//        behaviorObservable.onNext("3-Subject BehaviorSubject");
//        behaviorObservable.onNext("4-Subject BehaviorSubject");

        // 创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "test6 call: " + s);
            }
        };
        // 实现订阅
        behaviorObservable.subscribe(onNextAction);
        behaviorObservable.onNext("Subject BehaviorSubject1");
        behaviorObservable.onNext("Subject BehaviorSubject2");
        behaviorObservable.onNext("Subject BehaviorSubject3");
        behaviorObservable.onNext("Subject BehaviorSubject4");
    }
 
3.PublishSubject 作为观察者只能接收订阅之后的消息
public static void test7() {
        // 1.创建一个被观察者 PublishSubject
        // 它是在创建之后就可以发送事件
        // 作为观察者 只能接收到订阅后的所有事件
        PublishSubject<String> publishObservable = PublishSubject.create();
        publishObservable.onNext("1-Subject PublishSubject");
        publishObservable.onNext("2-Subject PublishSubject");
        publishObservable.onNext("3-Subject PublishSubject");
        publishObservable.onNext("4-Subject PublishSubject");

        // 创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "test6 call: " + s);
            }
        };
        // 实现订阅
        publishObservable.subscribe(onNextAction);
        publishObservable.onNext("Subject PublishSubject1");
        publishObservable.onNext("Subject PublishSubject2");
        publishObservable.onNext("Subject PublishSubject3");
        publishObservable.onNext("Subject PublishSubject4");
    }
4.ReplaySubject:创建完毕的时候就可以发送数据
public static void test8() {
        //1.创建一个被观察者ReplaySubject:
        //ReplaySubject刚创建完毕的时候就开始发送数据了
        //不管观察者是什么时候订阅 它都会接收ReplaySubject对象发出的任何事件。
        ReplaySubject<String> replayObservable = ReplaySubject.create();
        replayObservable.onNext("1-Subject replayObservable");
        replayObservable.onNext("2-Subject replayObservable");
        replayObservable.onNext("3-Subject replayObservable");
        replayObservable.onNext("4-Subject replayObservable");

        //2.创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "call: " + s);
            }
        };

        //3.实现订阅
        replayObservable.subscribe(onNextAction);
        replayObservable.onNext("Subject replayObservable1");
        replayObservable.onNext("Subject replayObservable2");
        replayObservable.onNext("Subject replayObservable3");
        replayObservable.onNext("Subject replayObservable4");
    }
5.总结:



AsyncSubject⽆无论何时订阅 只会接收后⼀一次onNext()事件，如果后出现异常，则不不会打印任何 onNext() 


BehaviorSubject会从订阅前后⼀一次oNext()开始打印直⾄至结束。如果订阅前⽆无调⽤用onNext(),则调⽤用默 认creat(T)传⼊入的对象。如果异常后才调⽤用，则不不打印onNext() 


PublishSubject只会打印订阅后的任何事件。 


ReplaySubject⽆无论订阅在何时都会调⽤用发送的事件。




7.ConntectableObservable:中可连接的被观察者,可连接的被观察者与普通的被观察者差不多,区别在于可连接的Observable在被订阅的时候并不开始发送消息,只有在connect()被调用的时候才开始,使用该方法,可以实现其他订阅者都订阅了这个被观察者之后才开始发送消息

1.publish,RefCount:该操作符可以将普通的Observable转化成可连接的Observable


 public static void test9() {
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //相当于发报纸
                subscriber.onNext("ConnectableObservable1");
                subscriber.onNext("ConnectableObservable2");
                subscriber.onNext("ConnectableObservable3");
                subscriber.onNext("ConnectableObservable4");
            }
        });
        //observable.publish()--->将普通的被观察者 变成可连接的观察者
        ConnectableObservable<String> connectableObservable = observable.publish();
        //refCount--->将可连接的观察者转换成普通的观察者
        //Observable<String> stringObservable = connectableObservable.refCount();
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("TAG", "onError: " + e.getLocalizedMessage());
            }
            //接受处理事件的方法
            @Override
            public void onNext(String s) {
                Log.e("TAG", "onNext: " + s);
            }
        };
        connectableObservable.subscribe(observer);
        //connect-->让可连接的被观察者调用内部的call方法(相当于发送了事件)
        connectableObservable.connect();
    }
public static void test10() {
        //创建一个普通的被观察者
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //相当于发报纸
                subscriber.onNext("ConnectableObservable1");
                subscriber.onNext("ConnectableObservable2");
                subscriber.onNext("ConnectableObservable3");
                subscriber.onNext("ConnectableObservable4");
            }
        });

        //2.将普通的被观察者变成可连接的被观察者
        //publish()创建的被观察者之后在connect()之前订阅的观察者才能接收事件 如果在connect()之后订阅的观察者 是无法获取被观察者发送的事件
        //有没办法可以让 只要是观察者订阅了可连接的被观察者 都能打印出被观察者发送出来的数据 而不管订阅在connect()的前后顺序。-->replay()
        ConnectableObservable<String> connectableObservable = observable.replay();

        //3.实现订阅
        connectableObservable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "call==1===: " + s);
            }
        });

        //4.让被观察者主动发送事件
        connectableObservable.connect();

        //5.再次订阅一个新的观察者
        connectableObservable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "call==2===: " + s);
            }
        });
    }








8.冷Observable&热Observable


//有的被观察者 在创建之后就马上发送了数据-----》“热”Observable----》Subject的子类//有的被观察者 在订阅的时候才发送的数据------->"冷"Observable---》普通的Observable//还有一种特殊的被观察者 他可以在我们指定的时间点发送数据----->"冷"Observable---->可连接的Observable








 


                

        

        

    

  


    

      

        

            

              
                
                  piziliul
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
RxJava 入门详解

				
			

			

				

					一名互联网时代苟且偷生的 Android码农
				

				

					05-13
					
					467
					
				

			

		

		

			
				
RxJava——入门篇一、ReactiveX简介二、RxJava的使用1、RxJava的优势2、RxJava的配置三、RxJava的不完整回调1、不完整回调的代码示例2、不完整回调的原理分析四、RxJava的线程切换1、Scheduler线程调度器2、线程控制五、总结
一、ReactiveX简介
在学习RxJava前首先需要了解ReactiveX，因为RxJava是ReactiveX的一种Java的实现形式。
ReactiveX的官网地址为：ReactiveX的官网
ReactiveX官网对于自身的介绍是：

			
		

	



                

              
                



	

		

			

				
					
RxJava入门之介绍与基本运用

				
			

			

				

					01-20
				

			

		

		

			
				
RxJava入门之介绍与基本运用  RxJava是一个在Java虚拟机(JVM)上运行的库，它采用响应式编程范式来处理异步和基于事件的程序。响应式编程是一种编程模型，它允许程序员以声明式的方式处理数据流和变换，使得代码能够...

			
		

	



                


  
              

                


	

		

			

				
					
Java RxJava 入门指南

				
			

			

				

					java专栏
				

				

					08-21
					
					328
					
				

			

		

		

			
				
通过以上的步骤，我们已经了解了如何使用RxJava来执行基本的异步操作。RxJava是一个非常强大的工具，支持多种复杂的异步场景。你可以根据需要添加更多的功能，以满足各种并发需求。希望这篇俏皮可爱的指南对你有所帮助，如果你还有任何疑问，欢迎随时留言哦！😊注意：上面的代码示例是为了教学目的而编写的，实际使用时请根据你的项目环境进行适当的调整。为了给这次的学习之旅增添一点趣味，这里有一张俏皮可爱的程序员正在编写RxJava。

			
		

	





	

		

			

				
					
RxJava入门

				
			

			

				

					不止于代码
				

				

					06-29
					
					690
					
				

			

		

		

			
				
参考文档RxJava-Android开发_Essentials中文翻译版_官方中文版-Android文档类资源-CSDN下载包含：Android开发-RxJava详解.pdf（偏向于Android开发的指导）RxJava Essentials_中文翻译版.pdf（国外大牛Ivan.Morgillo编写的RxJava教程）RxJava官方中文文档.pdf（比较全面，包含所有操作符的说明）1 RxJava基本介绍1.1 概念        RxJava是采用响应式编程思想的异步操作框架，设计初衷是让异步编程变得

			
		

	



		

			
		



	

		

			

				
					
RxJava快速入门

				
			

			

				

					weixin_44049823的博客
				

				

					06-29
					
					359
					
				

			

		

		

			
				
Rxlava是基于观察者模式实现的，分别有观察者和被观察者两个角色，被观察者会实时传输数据流，观察者可以观测到这些数据流。基于传输和观察的过程，用户可以通过一些操作方法对数据进行转换或其他处理。在RxJava中，观察者就是Observer，被观察者是Observable和Flowable。

			
		

	





	

		

			

				
					
RXJAVA从入门到精通

				
			

			

				

					qq_50709355的博客
				

				

					10-05
					
					4447
					
				

			

		

		

			
				
一文帮你读懂rxjava

			
		

	





	

		

			

				
					
RxJava简单入门

				
			

			

				

					Goals1989的博客
				

				

					08-18
					
					6438
					
				

			

		

		

			
				
前言之前

 首先来认识一下，接下来我们将要接触的关键单词，Observeable,Observer,subscrib国内基本都翻译成，被观察者，观察者，订阅。如果你按照这样的中文意思来理解，是怎么也理解不了的，普遍认为是观察者订阅了被观察者，但是你怎么理解observable.subscribe(observer);按照上边的名词翻译，被观察者订阅了观察者？！理解不了！报纸订阅了你？

    我粗浅的认为，able是表示能力的意思，er表示xx样的对象，xx者。而仔细观察：订阅和被订阅者，存...

			
		

	





	

		

			

				
					
RxJava入门到进阶全攻略

				
			

			

				

					路漫漫其修远兮，吾将上下而求索
				

				

					07-08
					
					771
					
				

			

		

		

			
				
RxJava2入门到进阶

			
		

	





	

		

			

				
					
RxJava 入门

				
			

			

				

					无问西东的博客
				

				

					09-10
					
					144
					
				

			

		

		

			
				
RxJava最近两年在Android移动端使用越发的流行起来，但是学习成本稍高。

这一篇博客主要从一个简单的例子开始，设计一下内容：

RxJava类库的导入
	RxJav运用实例
	RxJava简单分析
1、RxJava类库的导入

Android开发中使用RxJava首先需要在gradle文件中导入类库


implementation 'io.reactivex.rxjava2:rxjav...

			
		

	





	

		

			

				
					
Android Rxjava教程：清晰 简洁 易懂的Rxjava入门教程

				
			

			

				

					yzwfeng的专栏
				

				

					03-15
					
					7710
					
				

			

		

		

			
				
前言

Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。




image


	本文主要：

	面向 刚接触Rxjava的初学者
		提供了一份 清晰、简洁、易懂的Rxjava入门教程
	
	涵盖 基本介绍、原理 & 具体使用等
	

	解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题
	
希望你们会喜欢。


本文主要基于Rxjava 2.0
	如果读者还没学习过Rxjava 1.0也没关系，因为Rxja

			
		

	





	

		

			

				
					
essentials中文 - rxjava 入门书籍推荐

				
			

			

				

					02-05
				

			

		

		

			
				
在本文中，我们将深入探讨 RxJava 的基础知识，以及如何通过入门书籍来学习这一强大的工具。  首先，我们要理解什么是反应式编程。这是一种编程范式，它将数据流和变换视为计算的核心。RxJava 将事件、数据或任何...

			
		

	





	

		

			

				
					
RxJava入门教程

				
			

			

				

					09-30
				

			

		

		

			
				
上个月RxJava2正式版发布了，但目前国内的资料还比较少，以前使用过RxJava1只需要看看更新文档就知道怎么使用了，但还有一些以前没用过RxJava的朋友可能就不...所以写下这个教程， 帮助那些没有用过RxJava的朋友入门。

			
		

	





	

		

			

				
					
一个漂亮的毕业设计模板

				
			

			

				

					10-01
				

			

		

		

			
				
一个漂亮的毕业设计模板，供参考学习毕业设计写作技巧

			
		

	





	

		

			

				
					
朴素贝叶斯分类器对THUCNews数据集进行新闻分类_naive_bayes.zip

				
			

			

				

					10-01
				

			

		

		

			
				
朴素贝叶斯分类器对THUCNews数据集进行新闻分类_naive_bayes

			
		

	





	

		

			

				
					
基于Java语言开发的ktapis风控系统设计源码

				
			

			

				

					10-01
				

			

		

		

			
				
本项目为基于Java语言构建的ktapis风控系统设计源码，包含32个文件，涵盖18个Java源文件、6个XML配置文件、3个Markdown文件、1个Git忽略文件、1个属性文件、1个证书文件、1个JSON文件、1个密钥文件，旨在提供全面的风控解决方案。

			
		

	





	

		

			

				
					
基于ssm的旅游网站的设计与实现.zip

				
			

			

				

					10-01
				

			

		

		

			
				
基于ssm的旅游网站的设计与实现

			
		

	





	

		

			

				
					
用MATLAB实现的简单基元检测处理，包括sobel算子边缘检测，SUSAN角点检测（非极大值抑制）_

				
			

			

				

					10-01
				

			

		

		

			
				
用MATLAB实现的简单基元检测处理，包括sobel算子边缘检测，SUSAN角点检测（非极大值抑制）_Primitive-detection-MATLAB

			
		

	





	

		

			

				
					
基于微信小程序的奶茶点餐小程序的开题报告.docx

					
最新发布

				
			

			

				

					10-01
				

			

		

		

			
				
基于微信小程序的奶茶点餐小程序的开题报告.docx

			
		

	





	

		

			

				
					
RxJava入门精要

				
			

			

				

					
				

			

		

		

			
				
"RxJava Essentials 是一本适合RxJava初学者的英文书籍，由Ivan Morgillo撰写，并已有了中文版的翻译。这本书主要涵盖了RxJava的核心概念和实践应用。"  RxJava是Java平台上的一个库，它引入了反应式编程的概念，这...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值