├── .gitignore ├── .idea ├── compiler.xml ├── copyright │ └── profiles_settings.xml ├── gradle.xml ├── misc.xml ├── modules.xml ├── runConfigurations.xml └── vcs.xml ├── README.md ├── app ├── .gitignore ├── build.gradle ├── proguard-rules.pro └── src │ ├── androidTest │ └── java │ │ └── scut │ │ └── carson_ho │ │ └── rxjava_operators │ │ └── ExampleInstrumentedTest.java │ ├── main │ ├── AndroidManifest.xml │ ├── java │ │ └── scut │ │ │ └── carson_ho │ │ │ └── rxjava_operators │ │ │ ├── CombineOperator │ │ │ ├── UsageDemo1.java │ │ │ ├── UsageDemo2.java │ │ │ └── UsageDemo3.java │ │ │ ├── EstablishOperator │ │ │ ├── Demo │ │ │ │ ├── GetRequest_Interface.java │ │ │ │ ├── RxJavafixRxjava.java │ │ │ │ └── Translation.java │ │ │ └── establishUsage.java │ │ │ ├── FilterUsage.java │ │ │ ├── FunctionOperator │ │ │ ├── RxJavafixRetrofit.java │ │ │ ├── RxJavafixRetrofit1.java │ │ │ └── RxJavafixRetrofit2.java │ │ │ ├── MainActivity.java │ │ │ └── SwitchOperator │ │ │ ├── Demo │ │ │ ├── GetRequest_Interface2.java │ │ │ ├── RxJavaxRxtrofit3.java │ │ │ ├── Translation1.java │ │ │ └── Translation2.java │ │ │ └── SwitchUsage.java │ └── res │ │ ├── layout │ │ ├── activity_combine.xml │ │ ├── activity_filter.xml │ │ └── activity_main.xml │ │ ├── mipmap-hdpi │ │ ├── ic_launcher.png │ │ └── ic_launcher_round.png │ │ ├── mipmap-mdpi │ │ ├── ic_launcher.png │ │ └── ic_launcher_round.png │ │ ├── mipmap-xhdpi │ │ ├── ic_launcher.png │ │ └── ic_launcher_round.png │ │ ├── mipmap-xxhdpi │ │ ├── ic_launcher.png │ │ └── ic_launcher_round.png │ │ ├── mipmap-xxxhdpi │ │ ├── ic_launcher.png │ │ └── ic_launcher_round.png │ │ └── values │ │ ├── colors.xml │ │ ├── strings.xml │ │ └── styles.xml │ └── test │ └── java │ └── scut │ └── carson_ho │ └── rxjava_operators │ └── ExampleUnitTest.java ├── build.gradle ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle /.gitignore: -------------------------------------------------------------------------------- 1 | *.iml 2 | .gradle 3 | /local.properties 4 | /.idea/workspace.xml 5 | /.idea/libraries 6 | .DS_Store 7 | /build 8 | /captures 9 | .externalNativeBuild 10 | -------------------------------------------------------------------------------- /.idea/compiler.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /.idea/copyright/profiles_settings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /.idea/gradle.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 17 | 18 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 19 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | Android 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 62 | 63 | 64 | 65 | 66 | 1.8 67 | 68 | 73 | 74 | 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /.idea/runConfigurations.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 11 | 12 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # RxJava_LearningMaterial 2 | 这是 一份全面介绍Android RxJava的学习资料，内容包括如下： 3 | 4 | ![示意图](https://upload-images.jianshu.io/upload_images/944365-87720d60a23e704d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 5 | 6 | # 1. 入门教程 7 | [这是一篇 清晰 & 易懂的Rxjava 入门教程](http://blog.csdn.net/carson_ho/article/details/78179340) 8 | 9 | [Android ：RxJava2.0到底更新了什么？（含使用建议）](http://blog.csdn.net/carson_ho/article/details/79157408) 10 | 11 | [这是一份面向初学者的RxJava使用指南](http://blog.csdn.net/carson_ho/article/details/79168602) 12 | 13 | 14 | # 2. 原理 15 | 16 | [手把手带你源码分析 RxJava](http://blog.csdn.net/carson_ho/article/details/79168523) 17 | 18 | 19 | 20 | # 3. 操作符详解 系列 21 | `RxJava`如此受欢迎的原因，在于其**提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求** 22 | 23 | [ RxJava操作符 详细使用手册](http://blog.csdn.net/carson_ho/article/details/79191327) 24 | 25 | [ 创建操作符](http://blog.csdn.net/carson_ho/article/details/78246732) 26 | 27 | [功能性操作符](http://blog.csdn.net/carson_ho/article/details/78537277) 28 | 29 | [过滤操作符](http://blog.csdn.net/carson_ho/article/details/78683064) 30 | 31 | [组合 / 合并操作符](http://blog.csdn.net/carson_ho/article/details/78455349) 32 | 33 | [ 变换操作符](http://blog.csdn.net/carson_ho/article/details/78315437) 34 | 35 | [条件 / 布尔操作符](http://blog.csdn.net/carson_ho/article/details/78949306) 36 | 37 | # 4. 实际应用场景（含开发实例讲解） 38 | 39 | [RxJava的最佳开发场景汇总](http://blog.csdn.net/carson_ho/article/details/79168723) 40 | 41 | [细说 线程控制（切换 / 调度 ）](https://www.jianshu.com/p/5225b2baaecd) 42 | 43 | [一文带你全面了解 背压策略](http://blog.csdn.net/carson_ho/article/details/79081407) 44 | 45 | [网络请求嵌套回调](http://blog.csdn.net/carson_ho/article/details/78315696) 46 | 47 | [网络请求出错重连](http://blog.csdn.net/carson_ho/article/details/78651602) 48 | 49 | [网络请求轮询（有条件）](http://blog.csdn.net/carson_ho/article/details/78558790) 50 | 51 | [网络请求轮询（无条件）](http://blog.csdn.net/carson_ho/article/details/78256466) 52 | 53 | [联想搜索优化](http://blog.csdn.net/carson_ho/article/details/78849661) 54 | 55 | [功能防抖](http://blog.csdn.net/carson_ho/article/details/78849689) 56 | 57 | [从磁盘 / 内存缓存中 获取缓存数据](http://blog.csdn.net/carson_ho/article/details/78455449) 58 | 59 | [合并数据源 & 同时展示数据](http://blog.csdn.net/carson_ho/article/details/78455544) 60 | 61 | [联合判断](http://blog.csdn.net/carson_ho/article/details/78455624) 62 | 63 | # 5. 结合开源库使用：网络请求库Rerofit 64 | 65 | [Retrofit 与 RxJava联合使用汇总（含实例教程）](http://blog.csdn.net/carson_ho/article/details/79125101) 66 | 67 | [优雅实现 网络请求嵌套回调](http://blog.csdn.net/carson_ho/article/details/78315696) 68 | 69 | [网络请求轮询（有条件）](http://blog.csdn.net/carson_ho/article/details/78558790) 70 | 71 | [网络请求轮询（无条件）](http://blog.csdn.net/carson_ho/article/details/78256466) 72 | 73 | [网络请求出错重连](http://blog.csdn.net/carson_ho/article/details/78651602) 74 | [合并数据源 & 同时展示数据](http://blog.csdn.net/carson_ho/article/details/78455544) 75 | 76 | # 关于作者 77 | - ID：Carson_Ho 78 | - 简介：CSDN签约作者、简书推荐作者、稀土掘金专栏作者 79 | - E - mail：carson.ho@foxmail.com 80 | - Github：https://github.com/Carson-Ho 81 | - CSDN：http://blog.csdn.net/carson_ho 82 | - 简书：http://www.jianshu.com/u/383970bef0a0 83 | - 稀土掘金：https://juejin.im/user/58d4d9781b69e6006ba65edc 84 | -------------------------------------------------------------------------------- /app/.gitignore: -------------------------------------------------------------------------------- 1 | /build 2 | -------------------------------------------------------------------------------- /app/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.android.application' 2 | 3 | android { 4 | compileSdkVersion 25 5 | buildToolsVersion "25.0.2" 6 | defaultConfig { 7 | applicationId "scut.carson_ho.rxjava_operators" 8 | minSdkVersion 19 9 | targetSdkVersion 25 10 | versionCode 1 11 | versionName "1.0" 12 | testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" 13 | } 14 | buildTypes { 15 | release { 16 | minifyEnabled false 17 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' 18 | } 19 | } 20 | } 21 | 22 | dependencies { 23 | compile fileTree(dir: 'libs', include: ['*.jar']) 24 | androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', { 25 | exclude group: 'com.android.support', module: 'support-annotations' 26 | }) 27 | compile 'com.android.support:appcompat-v7:25.3.1' 28 | compile 'com.android.support.constraint:constraint-layout:1.0.2' 29 | // compile 'io.reactivex:rxandroid:1.2.0' 30 | // compile 'io.reactivex:rxjava:1.1.5' 31 | compile 'io.reactivex.rxjava2:rxandroid:2.0.1' 32 | compile 'io.reactivex.rxjava2:rxjava:2.0.7' 33 | 34 | compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0' 35 | 36 | compile 'com.squareup.retrofit2:retrofit:2.1.0' 37 | compile 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0' 38 | compile 'com.squareup.retrofit2:converter-gson:2.1.0' 39 | testCompile 'junit:junit:4.12' 40 | } 41 | -------------------------------------------------------------------------------- /app/proguard-rules.pro: -------------------------------------------------------------------------------- 1 | # Add project specific ProGuard rules here. 2 | # By default, the flags in this file are appended to flags specified 3 | # in /Users/Carson_Ho/Library/Android/sdk/tools/proguard/proguard-android.txt 4 | # You can edit the include path and order by changing the proguardFiles 5 | # directive in build.gradle. 6 | # 7 | # For more details, see 8 | # http://developer.android.com/guide/developing/tools/proguard.html 9 | 10 | # Add any project specific keep options here: 11 | 12 | # If your project uses WebView with JS, uncomment the following 13 | # and specify the fully qualified class name to the JavaScript interface 14 | # class: 15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview { 16 | # public *; 17 | #} 18 | 19 | # Uncomment this to preserve the line number information for 20 | # debugging stack traces. 21 | #-keepattributes SourceFile,LineNumberTable 22 | 23 | # If you keep the line number information, uncomment this to 24 | # hide the original source file name. 25 | #-renamesourcefileattribute SourceFile 26 | -------------------------------------------------------------------------------- /app/src/androidTest/java/scut/carson_ho/rxjava_operators/ExampleInstrumentedTest.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators; 2 | 3 | import android.content.Context; 4 | import android.support.test.InstrumentationRegistry; 5 | import android.support.test.runner.AndroidJUnit4; 6 | 7 | import org.junit.Test; 8 | import org.junit.runner.RunWith; 9 | 10 | import static org.junit.Assert.*; 11 | 12 | /** 13 | * Instrumentation test, which will execute on an Android device. 14 | * 15 | * @see Testing documentation 16 | */ 17 | @RunWith(AndroidJUnit4.class) 18 | public class ExampleInstrumentedTest { 19 | @Test 20 | public void useAppContext() throws Exception { 21 | // Context of the app under test. 22 | Context appContext = InstrumentationRegistry.getTargetContext(); 23 | 24 | assertEquals("scut.carson_ho.rxjava_operators", appContext.getPackageName()); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /app/src/main/AndroidManifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 4 | 5 | 6 | 7 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/CombineOperator/UsageDemo1.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.CombineOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import io.reactivex.Observable; 8 | import io.reactivex.ObservableEmitter; 9 | import io.reactivex.ObservableOnSubscribe; 10 | import io.reactivex.functions.Consumer; 11 | import scut.carson_ho.rxjava_operators.R; 12 | 13 | /** 14 | * Created by Carson_Ho on 17/9/12. 15 | * 从磁盘 / 内存缓存中 获取缓存数据 16 | */ 17 | 18 | public class UsageDemo1 extends AppCompatActivity { 19 | // 该2变量用于模拟内存缓存 & 磁盘缓存中的数据 20 | String memoryCache = null; 21 | String diskCache = "从磁盘缓存中获取数据"; 22 | 23 | private String TAG = "RxJava"; 24 | 25 | @Override 26 | protected void onCreate(Bundle savedInstanceState) { 27 | super.onCreate(savedInstanceState); 28 | setContentView(R.layout.activity_combine); 29 | 30 | 31 | /* 32 | * 设置第1个Observable：检查内存缓存是否有该数据的缓存 33 | **/ 34 | Observable memory = Observable.create(new ObservableOnSubscribe() { 35 | @Override 36 | public void subscribe(ObservableEmitter emitter) throws Exception { 37 | 38 | // 先判断内存缓存有无数据 39 | if (memoryCache != null) { 40 | // 若有该数据，则发送 41 | emitter.onNext(memoryCache); 42 | } else { 43 | // 若无该数据，则直接发送结束事件 44 | emitter.onComplete(); 45 | } 46 | 47 | } 48 | }); 49 | 50 | /* 51 | * 设置第2个Observable：检查磁盘缓存是否有该数据的缓存 52 | **/ 53 | Observable disk = Observable.create(new ObservableOnSubscribe() { 54 | @Override 55 | public void subscribe(ObservableEmitter emitter) throws Exception { 56 | 57 | // 先判断磁盘缓存有无数据 58 | if (diskCache != null) { 59 | // 若有该数据，则发送 60 | emitter.onNext(diskCache); 61 | } else { 62 | // 若无该数据，则直接发送结束事件 63 | emitter.onComplete(); 64 | } 65 | 66 | } 67 | }); 68 | 69 | /* 70 | * 设置第3个Observable：通过网络获取数据 71 | **/ 72 | Observable network = Observable.just("从网络中获取数据"); 73 | // 此处仅作网络请求的模拟 74 | 75 | 76 | /* 77 | * 通过concat（） 和 firstElement（）操作符实现缓存功能 78 | **/ 79 | 80 | // 1. 通过concat（）合并memory、disk、network 3个被观察者的事件（即检查内存缓存、磁盘缓存 & 发送网络请求） 81 | // 并将它们按顺序串联成队列 82 | Observable.concat(memory, disk, network) 83 | // 2. 通过firstElement()，从串联队列中取出并发送第1个有效事件（Next事件），即依次判断检查memory、disk、network 84 | .firstElement() 85 | // 即本例的逻辑为： 86 | // a. firstElement()取出第1个事件 = memory，即先判断内存缓存中有无数据缓存；由于memoryCache = null，即内存缓存中无数据，所以发送结束事件（视为无效事件） 87 | // b. firstElement()继续取出第2个事件 = disk，即判断磁盘缓存中有无数据缓存：由于diskCache ≠ null，即磁盘缓存中有数据，所以发送Next事件（有效事件） 88 | // c. 即firstElement()已发出第1个有效事件（disk事件），所以停止判断。 89 | 90 | // 3. 观察者订阅 91 | .subscribe(new Consumer() { 92 | @Override 93 | public void accept( String s) throws Exception { 94 | Log.d(TAG,"最终获取的数据来源 = "+ s); 95 | } 96 | }); 97 | } 98 | } 99 | 100 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/CombineOperator/UsageDemo2.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.CombineOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import io.reactivex.Observable; 8 | import io.reactivex.Observer; 9 | import io.reactivex.disposables.Disposable; 10 | import scut.carson_ho.rxjava_operators.R; 11 | 12 | /** 13 | * Created by Carson_Ho on 17/9/12. 14 | * 合并数据源 & 统一展示 15 | */ 16 | 17 | public class UsageDemo2 extends AppCompatActivity { 18 | 19 | private String TAG = "RxJava"; 20 | // 用于存放最终展示的数据 21 | private String result = "数据源来自 = " ; 22 | 23 | 24 | @Override 25 | protected void onCreate(Bundle savedInstanceState) { 26 | super.onCreate(savedInstanceState); 27 | setContentView(R.layout.activity_combine); 28 | 29 | /* 30 | * 设置第1个Observable：通过网络获取数据 31 | * 此处仅作网络请求的模拟 32 | **/ 33 | Observable network = Observable.just("网络"); 34 | 35 | /* 36 | * 设置第2个Observable：通过本地文件获取数据 37 | * 此处仅作本地文件请求的模拟 38 | **/ 39 | Observable file = Observable.just("本地文件"); 40 | 41 | /* 42 | * 通过merge（）合并事件 & 同时发送事件 43 | **/ 44 | Observable.merge(network, file) 45 | .subscribe(new Observer() { 46 | @Override 47 | public void onSubscribe(Disposable d) { 48 | 49 | } 50 | 51 | @Override 52 | public void onNext(String value) { 53 | Log.d(TAG, "数据源有： "+ value ); 54 | result += value + "+"; 55 | } 56 | 57 | @Override 58 | public void onError(Throwable e) { 59 | Log.d(TAG, "对Error事件作出响应"); 60 | } 61 | 62 | // 接收合并事件后，统一展示 63 | @Override 64 | public void onComplete() { 65 | Log.d(TAG, "获取数据完成"); 66 | Log.d(TAG, result ); 67 | } 68 | }); 69 | } 70 | } -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/CombineOperator/UsageDemo3.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.CombineOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.text.TextUtils; 6 | import android.util.Log; 7 | import android.widget.Button; 8 | import android.widget.EditText; 9 | 10 | import com.jakewharton.rxbinding2.widget.RxTextView; 11 | 12 | import io.reactivex.Observable; 13 | import io.reactivex.annotations.NonNull; 14 | import io.reactivex.functions.Consumer; 15 | import io.reactivex.functions.Function3; 16 | import scut.carson_ho.rxjava_operators.R; 17 | 18 | /** 19 | * Created by Carson_Ho on 17/9/12. 20 | * 联合判断 21 | */ 22 | 23 | public class UsageDemo3 extends AppCompatActivity { 24 | 25 | private String TAG = "RxJava"; 26 | 27 | 28 | /* 29 | * 步骤1：设置控件变量 & 绑定 30 | **/ 31 | EditText name,age,job; 32 | Button list; 33 | 34 | 35 | 36 | @Override 37 | protected void onCreate(Bundle savedInstanceState) { 38 | super.onCreate(savedInstanceState); 39 | setContentView(R.layout.activity_combine); 40 | 41 | 42 | name = (EditText) findViewById(R.id.name); 43 | age = (EditText) findViewById(R.id.age); 44 | job = (EditText) findViewById(R.id.job); 45 | list = (Button) findViewById(R.id.list); 46 | 47 | /* 48 | * 步骤2：为每个EditText设置被观察者，用于发送监听事件 49 | * 说明： 50 | * 1. 此处采用了RxBinding，需要引入依赖：compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0' 51 | * 2. 传入EditText控件，点击任1个EditText撰写时，都会发送数据事件 = Function3（）的返回值（下面会详细说明） 52 | * 3. 采用skip(1)原因：跳过 一开始EditText无任何输入时的空值 53 | **/ 54 | Observable nameObservable = RxTextView.textChanges(name).skip(1); 55 | Observable ageObservable = RxTextView.textChanges(age).skip(1); 56 | Observable jobObservable = RxTextView.textChanges(job).skip(1); 57 | 58 | /* 59 | * 步骤3：通过combineLatest（）合并事件 & 联合判断 60 | **/ 61 | Observable.combineLatest(nameObservable,ageObservable,jobObservable,new Function3() { 62 | @Override 63 | public Boolean apply(@NonNull CharSequence charSequence, @NonNull CharSequence charSequence2, @NonNull CharSequence charSequence3) throws Exception { 64 | 65 | /* 66 | * 步骤4：规定表单信息输入不能为空 67 | **/ 68 | // 1. 姓名信息 69 | boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) ; 70 | // 除了设置为空，也可设置长度限制 71 | // boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) && (name.getText().toString().length() > 2 && name.getText().toString().length() < 9); 72 | 73 | // 2. 年龄信息 74 | boolean isUserAgeValid = !TextUtils.isEmpty(age.getText()); 75 | // 3. 职业信息 76 | boolean isUserJobValid = !TextUtils.isEmpty(job.getText()) ; 77 | 78 | /* 79 | * 步骤5：返回信息 = 联合判断，即3个信息同时已填写，"提交按钮"才可点击 80 | **/ 81 | return isUserNameValid && isUserAgeValid && isUserJobValid; 82 | } 83 | 84 | }).subscribe(new Consumer() { 85 | @Override 86 | public void accept(Boolean s) throws Exception { 87 | /* 88 | * 步骤6：返回结果 & 设置按钮可点击样式 89 | **/ 90 | Log.e(TAG, "提交按钮是否可点击： "+s); 91 | list.setEnabled(s); 92 | } 93 | }); 94 | 95 | 96 | 97 | 98 | 99 | } 100 | } 101 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/EstablishOperator/Demo/GetRequest_Interface.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.EstablishOperator.Demo; 2 | 3 | import io.reactivex.Observable; 4 | import retrofit2.http.GET; 5 | 6 | /** 7 | * Created by Carson_Ho on 17/9/8. 8 | */ 9 | 10 | public interface GetRequest_Interface { 11 | 12 | @GET("ajax.php?a=fy&f=auto&t=auto&w=hi%20world") 13 | Observable getCall(); 14 | // 注解里传入 网络请求 的部分URL地址 15 | // Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里 16 | // 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略 17 | // 采用Observable<...>接口 18 | // getCall()是接受网络请求数据的方法 19 | } 20 | 21 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/EstablishOperator/Demo/RxJavafixRxjava.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.EstablishOperator.Demo; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory; 8 | 9 | import java.util.concurrent.TimeUnit; 10 | 11 | import io.reactivex.Observable; 12 | import io.reactivex.Observer; 13 | import io.reactivex.android.schedulers.AndroidSchedulers; 14 | import io.reactivex.disposables.Disposable; 15 | import io.reactivex.functions.Consumer; 16 | import io.reactivex.schedulers.Schedulers; 17 | import retrofit2.Retrofit; 18 | import retrofit2.converter.gson.GsonConverterFactory; 19 | import scut.carson_ho.rxjava_operators.R; 20 | 21 | /** 22 | * Created by Carson_Ho on 17/9/8. 23 | * 实战系列：无条件轮询 24 | */ 25 | 26 | public class RxJavafixRxjava extends AppCompatActivity { 27 | 28 | private static final String TAG = "Rxjava"; 29 | 30 | @Override 31 | protected void onCreate(Bundle savedInstanceState) { 32 | super.onCreate(savedInstanceState); 33 | setContentView(R.layout.activity_main); 34 | 35 | /* 36 | * 步骤1：采用interval（）延迟发送 37 | **/ 38 | Observable.interval(2,1, TimeUnit.SECONDS) 39 | // 参数说明： 40 | // 参数1 = 第1次延迟时间； 41 | // 参数2 = 间隔时间数字； 42 | // 参数3 = 时间单位； 43 | // 该例子发送的事件特点：延迟2s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个） 44 | 45 | /* 46 | * 步骤2：每次发送数字前发送1次网络请求（doOnNext（）在执行Next事件前调用） 47 | * 即每隔1秒产生1个数字前，就发送1次网络请求，从而实现轮询需求 48 | **/ 49 | .doOnNext(new Consumer() { 50 | @Override 51 | public void accept(Long integer) throws Exception { 52 | Log.d(TAG, "第 " + integer + " 次轮询" ); 53 | 54 | /* 55 | * 步骤3：通过Retrofit发送网络请求 56 | **/ 57 | // a. 创建Retrofit对象 58 | Retrofit retrofit = new Retrofit.Builder() 59 | .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url 60 | .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖) 61 | .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava 62 | .build(); 63 | 64 | // b. 创建 网络请求接口 的实例 65 | GetRequest_Interface request = retrofit.create(GetRequest_Interface.class); 66 | 67 | // c. 采用Observable<...>形式 对 网络请求 进行封装 68 | Observable observable = request.getCall(); 69 | // d. 通过线程切换发送网络请求 70 | observable.subscribeOn(Schedulers.io()) // 切换到IO线程进行网络请求 71 | .observeOn(AndroidSchedulers.mainThread()) // 切换回到主线程 处理请求结果 72 | .subscribe(new Observer() { 73 | @Override 74 | public void onSubscribe(Disposable d) { 75 | } 76 | 77 | @Override 78 | public void onNext(Translation result) { 79 | // e.接收服务器返回的数据 80 | result.show() ; 81 | } 82 | 83 | @Override 84 | public void onError(Throwable e) { 85 | Log.d(TAG, "请求失败"); 86 | } 87 | 88 | @Override 89 | public void onComplete() { 90 | 91 | } 92 | }); 93 | 94 | } 95 | }).subscribe(new Observer() { 96 | @Override 97 | public void onSubscribe(Disposable d) { 98 | 99 | } 100 | @Override 101 | public void onNext(Long value) { 102 | 103 | } 104 | 105 | @Override 106 | public void onError(Throwable e) { 107 | Log.d(TAG, "对Error事件作出响应"); 108 | } 109 | 110 | @Override 111 | public void onComplete() { 112 | Log.d(TAG, "对Complete事件作出响应"); 113 | } 114 | }); 115 | 116 | 117 | } 118 | } 119 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/EstablishOperator/Demo/Translation.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.EstablishOperator.Demo; 2 | 3 | import android.util.Log; 4 | 5 | /** 6 | * Created by Carson_Ho on 17/9/8. 7 | */ 8 | 9 | public class Translation { 10 | 11 | 12 | private int status; 13 | 14 | private content content; 15 | private static class content { 16 | private String from; 17 | private String to; 18 | private String vendor; 19 | private String out; 20 | private int errNo; 21 | } 22 | 23 | //定义 输出返回数据 的方法 24 | public void show() { 25 | Log.d("RxJava", content.out ); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/EstablishOperator/establishUsage.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.EstablishOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import java.util.ArrayList; 8 | import java.util.List; 9 | import java.util.concurrent.TimeUnit; 10 | 11 | import io.reactivex.Observable; 12 | import io.reactivex.ObservableEmitter; 13 | import io.reactivex.ObservableOnSubscribe; 14 | import io.reactivex.ObservableSource; 15 | import io.reactivex.Observer; 16 | import io.reactivex.annotations.NonNull; 17 | import io.reactivex.disposables.Disposable; 18 | import io.reactivex.functions.Function; 19 | import scut.carson_ho.rxjava_operators.R; 20 | 21 | /** 22 | * Created by Carson_Ho on 17/9/6. 23 | * 应用场景 & 对应操作符介绍 24 | */ 25 | 26 | public class establishUsage extends AppCompatActivity { 27 | 28 | private String TAG = "RxJava"; 29 | Integer i = 10; 30 | 31 | @Override 32 | protected void onCreate(Bundle savedInstanceState) { 33 | super.onCreate(savedInstanceState); 34 | setContentView(R.layout.activity_main); 35 | 36 | 37 | 38 | Observable.just(1,2,4).repeatWhen(new Function, ObservableSource>() { 39 | @Override 40 | public ObservableSource apply(@NonNull Observable objectObservable) throws Exception { 41 | // 将原始 Observable 停止发送事件的标识（Complete（） / Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable） 42 | // 以此决定是否重新订阅 & 发送原来的 Observable 43 | // 此处有2种情况： 44 | // 1. 若新被观察者（Observable）返回1个Complete事件，则不重新订阅 & 发送原来的 Observable 45 | // 2. 若新被观察者（Observable）返回1个Next事件，则重新订阅 & 发送原来的 Observable 46 | return objectObservable.flatMap(new Function>() { 47 | @Override 48 | public ObservableSource apply(@NonNull Object throwable) throws Exception { 49 | 50 | // 情况1：若新被观察者（Observable）返回1个Complete事件，则不重新订阅 & 发送原来的 Observable 51 | return Observable.empty(); 52 | // 返回Error 53 | // return Observable.error(new Throwable("不再重新订阅事件")); 54 | 55 | // 情况2：若新被观察者（Observable）返回1个Next事件，则重新订阅 & 发送原来的 Observable 56 | // return Observable.just(1); 57 | } 58 | }); 59 | 60 | } 61 | }) 62 | .subscribe(new Observer() { 63 | @Override 64 | public void onSubscribe(Disposable d) { 65 | Log.d(TAG, "开始采用subscribe连接"); 66 | } 67 | 68 | @Override 69 | public void onNext(Integer value) { 70 | Log.d(TAG, "接收到了事件" + value); 71 | } 72 | 73 | @Override 74 | public void onError(Throwable e) { 75 | 76 | Log.d(TAG, "对Error事件作出响应：" + e.toString()); 77 | } 78 | 79 | @Override 80 | public void onComplete() { 81 | Log.d(TAG, "对Complete事件作出响应"); 82 | } 83 | 84 | }); 85 | 86 | 87 | // // 具体使用 88 | 89 | Observable.just(1,2,4).repeatWhen(new Function, ObservableSource>() { 90 | @Override 91 | public ObservableSource apply(@NonNull Observable objectObservable) throws Exception { 92 | return Observable.just(1); 93 | // return objectObservable; 94 | // return Observable.empty().delay(3, TimeUnit.SECONDS); 95 | } 96 | }) 97 | .subscribe(new Observer() { 98 | @Override 99 | public void onSubscribe(Disposable d) { 100 | Log.d(TAG, "开始采用subscribe连接"); 101 | } 102 | 103 | @Override 104 | public void onNext(Integer value) { 105 | Log.d(TAG, "接收到了事件" + value); 106 | } 107 | 108 | @Override 109 | public void onError(Throwable e) { 110 | Log.d(TAG, "对Error事件作出响应"); 111 | } 112 | 113 | @Override 114 | public void onComplete() { 115 | Log.d(TAG, "对Complete事件作出响应"); 116 | } 117 | 118 | }); 119 | 120 | 121 | /* 122 | * 数组遍历 123 | **/ 124 | 125 | // 1. 设置需要传入的数组 126 | Integer[] items = { 0, 1, 2, 3, 4 }; 127 | 128 | // 2. 创建被观察者对象（Observable）时传入数组 129 | // 在创建后就会将该数组转换成Observable & 发送该对象中的所有数据 130 | Observable.fromArray(items) 131 | .subscribe(new Observer() { 132 | @Override 133 | public void onSubscribe(Disposable d) { 134 | Log.d(TAG, "数组遍历"); 135 | } 136 | 137 | @Override 138 | public void onNext(Integer value) { 139 | Log.d(TAG, "数组中的元素 = "+ value ); 140 | } 141 | 142 | @Override 143 | public void onError(Throwable e) { 144 | Log.d(TAG, "对Error事件作出响应"); 145 | } 146 | 147 | @Override 148 | public void onComplete() { 149 | Log.d(TAG, "遍历结束"); 150 | } 151 | 152 | }); 153 | // 154 | // 155 | // /* 156 | // * 集合遍历 157 | // **/ 158 | // 1. 设置一个集合 159 | List list = new ArrayList<>(); 160 | list.add(1); 161 | list.add(2); 162 | list.add(3); 163 | 164 | // 2. 通过fromIterable()将集合中的对象 / 数据发送出去 165 | Observable.fromIterable(list) 166 | .subscribe(new Observer() { 167 | @Override 168 | public void onSubscribe(Disposable d) { 169 | Log.d(TAG, "集合遍历"); 170 | } 171 | 172 | @Override 173 | public void onNext(Integer value) { 174 | Log.d(TAG, "集合中的数据元素 = "+ value ); 175 | } 176 | 177 | @Override 178 | public void onError(Throwable e) { 179 | Log.d(TAG, "对Error事件作出响应"); 180 | } 181 | 182 | @Override 183 | public void onComplete() { 184 | Log.d(TAG, "遍历结束"); 185 | } 186 | }); 187 | 188 | 189 | 190 | 191 | /* 192 | * 周期性操作 193 | **/ 194 | // 该例子发送的事件序列特点：延迟2s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个） = 每隔1s进行1次操作 195 | Observable.interval(2,1, TimeUnit.SECONDS) 196 | .subscribe(new Observer() { 197 | @Override 198 | public void onSubscribe(Disposable d) { 199 | Log.d(TAG, "开始采用subscribe连接"); 200 | } 201 | 202 | @Override 203 | public void onNext(Long value) { 204 | Log.d(TAG, "每隔1s进行1次操作" ); 205 | } 206 | 207 | @Override 208 | public void onError(Throwable e) { 209 | Log.d(TAG, "对Error事件作出响应"); 210 | } 211 | 212 | @Override 213 | public void onComplete() { 214 | Log.d(TAG, "对Complete事件作出响应"); 215 | } 216 | 217 | }); 218 | 219 | // 注：interval默认在computation调度器上执行 220 | // 也可自定义指定线程调度器（第3个参数）：interval(long,TimeUnit,Scheduler) 221 | 222 | 223 | 224 | /* 225 | * 定时操作 226 | **/ 227 | 228 | // 该例子 = 延迟2s后，进行日志输出操作 229 | Observable.timer(2, TimeUnit.SECONDS) 230 | .subscribe(new Observer() { 231 | @Override 232 | public void onSubscribe(Disposable d) { 233 | Log.d(TAG, "开始采用subscribe连接"); 234 | } 235 | 236 | @Override 237 | public void onNext(Long value) { 238 | } 239 | 240 | @Override 241 | public void onError(Throwable e) { 242 | Log.d(TAG, "对Error事件作出响应"); 243 | } 244 | 245 | @Override 246 | public void onComplete() { 247 | Log.d(TAG, "在2s后进行了该操作"); 248 | } 249 | 250 | }); 251 | 252 | // 注：timer操作符默认运行在一个新线程上 253 | // 也可自定义线程调度器（第3个参数）：timer(long,TimeUnit,Scheduler) 254 | 255 | 256 | /* 257 | * 完整创建被观察者 258 | **/ 259 | 260 | // 步骤1：通过create（）创建完整的被观察者对象 261 | Observable observable = Observable.create(new ObservableOnSubscribe() { 262 | // 2. 在复写的subscribe（）里定义需要发送的事件 263 | @Override 264 | public void subscribe(ObservableEmitter emitter) throws Exception { 265 | emitter.onNext(1); 266 | emitter.onNext(2); 267 | emitter.onNext(3); 268 | emitter.onComplete(); 269 | } 270 | }); // 至此，一个完整的被观察者对象创建完毕。 271 | 272 | // 步骤2：创建观察者 Observer 并 定义响应事件行为 273 | Observer observer = new Observer() { 274 | @Override 275 | public void onSubscribe(Disposable d) { 276 | Log.d(TAG, "开始采用subscribe连接"); 277 | } 278 | 279 | @Override 280 | public void onNext(Integer value) { 281 | Log.d(TAG, "接收到了事件 = "+ value ); 282 | } 283 | 284 | @Override 285 | public void onError(Throwable e) { 286 | Log.d(TAG, "对Error事件作出响应"); 287 | } 288 | 289 | @Override 290 | public void onComplete() { 291 | Log.d(TAG, "对Complete事件作出响应"); 292 | } 293 | }; 294 | 295 | 296 | // 步骤3：通过订阅（subscribe）连接观察者和被观察者 297 | observable.subscribe(observer); 298 | 299 | } 300 | } 301 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/FilterUsage.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | import android.widget.Button; 7 | import android.widget.EditText; 8 | import android.widget.TextView; 9 | 10 | import com.jakewharton.rxbinding2.widget.RxTextView; 11 | 12 | import java.util.concurrent.TimeUnit; 13 | 14 | import io.reactivex.Observer; 15 | import io.reactivex.android.schedulers.AndroidSchedulers; 16 | import io.reactivex.disposables.Disposable; 17 | 18 | /** 19 | * Created by Carson_Ho on 17/9/7. 20 | */ 21 | 22 | public class FilterUsage extends AppCompatActivity { 23 | 24 | private String TAG = "RxJava"; 25 | 26 | 27 | /* 28 | * 联想搜索优化 29 | **/ 30 | 31 | 32 | /* 33 | * 步骤1：设置控件变量 & 绑定 34 | **/ 35 | EditText ed; 36 | TextView tv; 37 | Button button; 38 | 39 | 40 | 41 | @Override 42 | protected void onCreate(Bundle savedInstanceState) { 43 | super.onCreate(savedInstanceState); 44 | setContentView(R.layout.activity_filter); 45 | 46 | // 控件绑定 47 | ed = (EditText) findViewById(R.id.ed); 48 | tv = (TextView) findViewById(R.id.tv); 49 | 50 | /* 51 | * 说明 52 | * 1. 此处采用了RxBinding：RxTextView.textChanges(name) = 对对控件数据变更进行监听（功能类似TextWatcher），需要引入依赖：compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0' 53 | * 2. 传入EditText控件，输入字符时都会发送数据事件（此处不会马上发送，因为使用了debounce（）） 54 | * 3. 采用skip(1)原因：跳过 第1次请求 = 初始输入框的空字符状态 55 | **/ 56 | RxTextView.textChanges(ed) 57 | .debounce(1, TimeUnit.SECONDS).skip(1) 58 | .observeOn(AndroidSchedulers.mainThread()) 59 | .subscribe(new Observer() { 60 | @Override 61 | public void onSubscribe(Disposable d) { 62 | 63 | } 64 | @Override 65 | public void onNext(CharSequence charSequence) { 66 | tv.setText("发送给服务器的字符 = " + charSequence.toString()); 67 | } 68 | 69 | @Override 70 | public void onError(Throwable e) { 71 | Log.d(TAG, "对Error事件作出响应" ); 72 | 73 | } 74 | 75 | @Override 76 | public void onComplete() { 77 | Log.d(TAG, "对Complete事件作出响应"); 78 | } 79 | }); 80 | 81 | 82 | 83 | 84 | /* 85 | * 功能防抖 86 | **/ 87 | 88 | // // 注册控件 89 | // button = (Button)findViewById(R.id.button); 90 | // 91 | // /* 92 | // * 1. 此处采用了RxBinding：RxView.clicks(button) = 对控件点击进行监听，需要引入依赖：compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0' 93 | // * 2. 传入Button控件，点击时，都会发送数据事件（但由于使用了throttleFirst（）操作符，所以只会发送该段时间内的第1次点击事件） 94 | // **/ 95 | // RxView.clicks(button) 96 | // .throttleFirst(2, TimeUnit.SECONDS) // 才发送 2s内第1次点击按钮的事件 97 | // .subscribe(new Observer() { 98 | // @Override 99 | // public void onSubscribe(Disposable d) { 100 | // 101 | // } 102 | // @Override 103 | // public void onNext(Object value) { 104 | // Log.d(TAG, "发送了网络请求" ); 105 | // } 106 | // 107 | // @Override 108 | // public void onError(Throwable e) { 109 | // Log.d(TAG, "对Error事件作出响应" + e.toString()); 110 | // // 获取异常错误信息 111 | // } 112 | // 113 | // @Override 114 | // public void onComplete() { 115 | // Log.d(TAG, "对Complete事件作出响应"); 116 | // } 117 | // }); 118 | 119 | 120 | 121 | } 122 | } 123 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/FunctionOperator/RxJavafixRetrofit.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.FunctionOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory; 8 | 9 | import java.util.concurrent.TimeUnit; 10 | 11 | import io.reactivex.Observable; 12 | import io.reactivex.ObservableSource; 13 | import io.reactivex.Observer; 14 | import io.reactivex.android.schedulers.AndroidSchedulers; 15 | import io.reactivex.annotations.NonNull; 16 | import io.reactivex.disposables.Disposable; 17 | import io.reactivex.functions.Function; 18 | import io.reactivex.schedulers.Schedulers; 19 | import retrofit2.Retrofit; 20 | import retrofit2.converter.gson.GsonConverterFactory; 21 | import scut.carson_ho.rxjava_operators.R; 22 | import scut.carson_ho.rxjava_operators.EstablishOperator.Demo.GetRequest_Interface; 23 | import scut.carson_ho.rxjava_operators.EstablishOperator.Demo.Translation; 24 | 25 | /** 26 | * Created by Carson_Ho on 17/9/9. 27 | * Demo for 有条件轮询 28 | */ 29 | 30 | public class RxJavafixRetrofit extends AppCompatActivity { 31 | 32 | private static final String TAG = "Rxjava"; 33 | 34 | // 设置变量 = 模拟轮询服务器次数 35 | private int i = 0 ; 36 | 37 | @Override 38 | protected void onCreate(Bundle savedInstanceState) { 39 | super.onCreate(savedInstanceState); 40 | setContentView(R.layout.activity_main); 41 | 42 | // 步骤1：创建Retrofit对象 43 | Retrofit retrofit = new Retrofit.Builder() 44 | .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url 45 | .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖) 46 | .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava 47 | .build(); 48 | 49 | // 步骤2：创建 网络请求接口 的实例 50 | GetRequest_Interface request = retrofit.create(GetRequest_Interface.class); 51 | 52 | // 步骤3：采用Observable<...>形式 对 网络请求 进行封装 53 | Observable observable = request.getCall(); 54 | 55 | // 步骤4：发送网络请求 & 通过repeatWhen（）进行轮询 56 | observable.repeatWhen(new Function, ObservableSource>() { 57 | @Override 58 | // 在Function函数中，必须对输入的 Observable进行处理，此处使用flatMap操作符接收上游的数据 59 | public ObservableSource apply(@NonNull Observable objectObservable) throws Exception { 60 | // 将原始 Observable 停止发送事件的标识（Complete（） / Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable） 61 | // 以此决定是否重新订阅 & 发送原来的 Observable，即轮询 62 | // 此处有2种情况： 63 | // 1. 若返回1个Complete（） / Error（）事件，则不重新订阅 & 发送原来的 Observable，即轮询结束 64 | // 2. 若返回其余事件，则重新订阅 & 发送原来的 Observable，即继续轮询 65 | return objectObservable.flatMap(new Function>() { 66 | @Override 67 | public ObservableSource apply(@NonNull Object throwable) throws Exception { 68 | 69 | // 加入判断条件：当轮询次数 = 5次后，就停止轮询 70 | if (i > 3) { 71 | // 此处选择发送onError事件以结束轮询，因为可触发下游观察者的onError（）方法回调 72 | return Observable.error(new Throwable("轮询结束")); 73 | } 74 | // 若轮询次数＜4次，则发送1Next事件以继续轮询 75 | // 注：此处加入了delay操作符，作用 = 延迟一段时间发送（此处设置 = 2s），以实现轮询间间隔设置 76 | return Observable.just(1).delay(2000, TimeUnit.MILLISECONDS); 77 | } 78 | }); 79 | 80 | } 81 | }).subscribeOn(Schedulers.io()) // 切换到IO线程进行网络请求 82 | .observeOn(AndroidSchedulers.mainThread()) // 切换回到主线程 处理请求结果 83 | .subscribe(new Observer() { 84 | @Override 85 | public void onSubscribe(Disposable d) { 86 | } 87 | 88 | @Override 89 | public void onNext(Translation result) { 90 | // e.接收服务器返回的数据 91 | result.show() ; 92 | i++; 93 | } 94 | 95 | @Override 96 | public void onError(Throwable e) { 97 | // 获取轮询结束信息 98 | Log.d(TAG, e.toString()); 99 | } 100 | 101 | @Override 102 | public void onComplete() { 103 | 104 | } 105 | }); 106 | 107 | } 108 | } 109 | 110 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/FunctionOperator/RxJavafixRetrofit1.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.FunctionOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory; 8 | 9 | import io.reactivex.Observable; 10 | import io.reactivex.Observer; 11 | import io.reactivex.android.schedulers.AndroidSchedulers; 12 | import io.reactivex.disposables.Disposable; 13 | import io.reactivex.schedulers.Schedulers; 14 | import retrofit2.Retrofit; 15 | import retrofit2.converter.gson.GsonConverterFactory; 16 | import scut.carson_ho.rxjava_operators.EstablishOperator.Demo.GetRequest_Interface; 17 | import scut.carson_ho.rxjava_operators.EstablishOperator.Demo.Translation; 18 | import scut.carson_ho.rxjava_operators.R; 19 | 20 | /** 21 | * Created by Carson_Ho on 17/9/12. 22 | * Demo for 线程调度 23 | */ 24 | 25 | public class RxJavafixRetrofit1 extends AppCompatActivity { 26 | 27 | private static final String TAG = "Rxjava"; 28 | 29 | @Override 30 | protected void onCreate(Bundle savedInstanceState) { 31 | super.onCreate(savedInstanceState); 32 | setContentView(R.layout.activity_main); 33 | 34 | //步骤4：创建Retrofit对象 35 | Retrofit retrofit = new Retrofit.Builder() 36 | .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url 37 | .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖) 38 | .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava 39 | .build(); 40 | 41 | // 步骤5：创建 网络请求接口 的实例 42 | GetRequest_Interface request = retrofit.create(GetRequest_Interface.class); 43 | 44 | // 步骤6：采用Observable<...>形式 对 网络请求 进行封装 45 | Observable observable = request.getCall(); 46 | 47 | // 步骤7：发送网络请求 48 | observable.subscribeOn(Schedulers.io()) // 在IO线程进行网络请求 49 | .observeOn(AndroidSchedulers.mainThread()) // 回到主线程 处理请求结果 50 | .subscribe(new Observer() { 51 | @Override 52 | public void onSubscribe(Disposable d) { 53 | Log.d(TAG, "开始采用subscribe连接"); 54 | } 55 | 56 | @Override 57 | public void onNext(Translation result) { 58 | // 步骤8：对返回的数据进行处理 59 | result.show() ; 60 | } 61 | 62 | @Override 63 | public void onError(Throwable e) { 64 | Log.d(TAG, "请求失败"); 65 | } 66 | 67 | @Override 68 | public void onComplete() { 69 | Log.d(TAG, "请求成功"); 70 | } 71 | }); 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/FunctionOperator/RxJavafixRetrofit2.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.FunctionOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory; 8 | 9 | import java.io.IOException; 10 | import java.util.concurrent.TimeUnit; 11 | 12 | import io.reactivex.Observable; 13 | import io.reactivex.ObservableSource; 14 | import io.reactivex.Observer; 15 | import io.reactivex.android.schedulers.AndroidSchedulers; 16 | import io.reactivex.annotations.NonNull; 17 | import io.reactivex.disposables.Disposable; 18 | import io.reactivex.functions.Function; 19 | import io.reactivex.schedulers.Schedulers; 20 | import retrofit2.Retrofit; 21 | import retrofit2.converter.gson.GsonConverterFactory; 22 | import scut.carson_ho.rxjava_operators.R; 23 | import scut.carson_ho.rxjava_operators.EstablishOperator.Demo.GetRequest_Interface; 24 | import scut.carson_ho.rxjava_operators.EstablishOperator.Demo.Translation; 25 | 26 | /** 27 | * Created by Carson_Ho on 17/9/11. 28 | * Demo for 出错重试 29 | */ 30 | 31 | public class RxJavafixRetrofit2 extends AppCompatActivity { 32 | 33 | private static final String TAG = "RxJava"; 34 | 35 | // 设置变量 36 | // 可重试次数 37 | private int maxConnectCount = 10; 38 | // 当前已重试次数 39 | private int currentRetryCount = 0; 40 | // 重试等待时间 41 | private int waitRetryTime = 0; 42 | 43 | @Override 44 | protected void onCreate(Bundle savedInstanceState) { 45 | super.onCreate(savedInstanceState); 46 | setContentView(R.layout.activity_main); 47 | 48 | // 步骤1：创建Retrofit对象 49 | Retrofit retrofit = new Retrofit.Builder() 50 | .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url 51 | .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖) 52 | .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava 53 | .build(); 54 | 55 | // 步骤2：创建 网络请求接口 的实例 56 | GetRequest_Interface request = retrofit.create(GetRequest_Interface.class); 57 | 58 | // 步骤3：采用Observable<...>形式 对 网络请求 进行封装 59 | Observable observable = request.getCall(); 60 | 61 | // 步骤4：发送网络请求 & 通过retryWhen（）进行重试 62 | // 注：主要异常才会回调retryWhen（）进行重试 63 | observable.retryWhen(new Function, ObservableSource>() { 64 | @Override 65 | public ObservableSource apply(@NonNull Observable throwableObservable) throws Exception { 66 | // 参数Observable中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型 67 | return throwableObservable.flatMap(new Function>() { 68 | @Override 69 | public ObservableSource apply(@NonNull Throwable throwable) throws Exception { 70 | 71 | // 输出异常信息 72 | Log.d(TAG, "发生异常 = "+ throwable.toString()); 73 | 74 | /** 75 | * 需求1：根据异常类型选择是否重试 76 | * 即，当发生的异常 = 网络异常 = IO异常 才选择重试 77 | */ 78 | if (throwable instanceof IOException){ 79 | 80 | Log.d(TAG, "属于IO异常，需重试" ); 81 | 82 | /** 83 | * 需求2：限制重试次数 84 | * 即，当已重试次数 < 设置的重试次数，才选择重试 85 | */ 86 | if (currentRetryCount < maxConnectCount){ 87 | 88 | // 记录重试次数 89 | currentRetryCount++; 90 | Log.d(TAG, "重试次数 = " + currentRetryCount); 91 | 92 | /** 93 | * 需求2：实现重试 94 | * 通过返回的Observable发送的事件 = Next事件，从而使得retryWhen（）重订阅，最终实现重试功能 95 | * 96 | * 需求3：延迟1段时间再重试 97 | * 采用delay操作符 = 延迟一段时间发送，以实现重试间隔设置 98 | * 99 | * 需求4：遇到的异常越多，时间越长 100 | * 在delay操作符的等待时间内设置 = 每重试1次，增多延迟重试时间1s 101 | */ 102 | // 设置等待时间 103 | waitRetryTime = 1000 + currentRetryCount* 1000; 104 | Log.d(TAG, "等待时间 =" + waitRetryTime); 105 | return Observable.just(1).delay(waitRetryTime, TimeUnit.MILLISECONDS); 106 | 107 | 108 | }else{ 109 | // 若重试次数已 > 设置重试次数，则不重试 110 | // 通过发送error来停止重试（可在观察者的onError（）中获取信息） 111 | return Observable.error(new Throwable("重试次数已超过设置次数 = " +currentRetryCount + "，即 不再重试")); 112 | 113 | } 114 | } 115 | 116 | // 若发生的异常不属于I/O异常，则不重试 117 | // 通过返回的Observable发送的事件 = Error事件 实现（可在观察者的onError（）中获取信息） 118 | else{ 119 | return Observable.error(new Throwable("发生了非网络异常（非I/O异常）")); 120 | } 121 | } 122 | }); 123 | } 124 | }).subscribeOn(Schedulers.io()) // 切换到IO线程进行网络请求 125 | .observeOn(AndroidSchedulers.mainThread()) // 切换回到主线程 处理请求结果 126 | .subscribe(new Observer() { 127 | @Override 128 | public void onSubscribe(Disposable d) { 129 | } 130 | 131 | @Override 132 | public void onNext(Translation result) { 133 | // 接收服务器返回的数据 134 | Log.d(TAG, "发送成功"); 135 | result.show(); 136 | } 137 | 138 | @Override 139 | public void onError(Throwable e) { 140 | // 获取停止重试的信息 141 | Log.d(TAG, e.toString()); 142 | } 143 | 144 | @Override 145 | public void onComplete() { 146 | 147 | } 148 | }); 149 | 150 | } 151 | } 152 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/MainActivity.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import java.util.concurrent.TimeUnit; 8 | 9 | import io.reactivex.Observable; 10 | import io.reactivex.Observer; 11 | import io.reactivex.disposables.Disposable; 12 | import io.reactivex.functions.Predicate; 13 | 14 | 15 | public class MainActivity extends AppCompatActivity { 16 | 17 | private String TAG = "RxJava"; 18 | Integer i = 10; 19 | @Override 20 | protected void onCreate(Bundle savedInstanceState) { 21 | super.onCreate(savedInstanceState); 22 | setContentView(R.layout.activity_main); 23 | 24 | 25 | // 1. 每1s发送1个数据 = 从0开始，递增1，即0、1、2、3 26 | Observable.interval(1, TimeUnit.SECONDS) 27 | // 2. 通过takeUntil的Predicate传入判断条件 28 | .takeUntil(new Predicate(){ 29 | @Override 30 | public boolean test( Long integer) throws Exception { 31 | return (integer>3); 32 | // 返回true时，就停止发送事件 33 | // 当发送的数据满足>3时，就停止发送Observable的数据 34 | } 35 | }).subscribe(new Observer() { 36 | @Override 37 | public void onSubscribe(Disposable d) { 38 | } 39 | 40 | @Override 41 | public void onNext(Long value) { 42 | Log.d(TAG,"发送了事件 "+ value); 43 | } 44 | 45 | @Override 46 | public void onError(Throwable e) { 47 | } 48 | 49 | @Override 50 | public void onComplete() { 51 | } 52 | }); 53 | 54 | 55 | 56 | // // 采用RxJava基于事件流的链式操作 57 | // Observable.create(new ObservableOnSubscribe() { 58 | // @Override 59 | // public void subscribe(ObservableEmitter emitter) throws Exception { 60 | // emitter.onNext(1); 61 | // emitter.onNext(2); 62 | // emitter.onNext(3); 63 | // } 64 | // 65 | // // 采用flatMap（）变换操作符 66 | // }).flatMap(new Function>() { 67 | // @Override 68 | // public ObservableSource apply(Integer integer) throws Exception { 69 | // final List list = new ArrayList<>(); 70 | // for (int i = 0; i < 3; i++) { 71 | // list.add("我是事件 " + integer + "拆分后的子事件" + i); 72 | // // 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件 73 | // // 最终合并，再发送给被观察者 74 | // } 75 | // return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS); 76 | // } 77 | // }).subscribe(new Consumer() { 78 | // @Override 79 | // public void accept(String s) throws Exception { 80 | // Log.d(TAG, s); 81 | // } 82 | // }); 83 | 84 | 85 | 86 | // Observable.create(new ObservableOnSubscribe() { 87 | // @Override 88 | // public void subscribe(ObservableEmitter e) throws Exception { 89 | // e.onNext(1); 90 | // e.onNext(2); 91 | // e.onError(new Exception("发生错误了")); 92 | // e.onNext(3); 93 | // } 94 | // }) 95 | // .retryWhen(new Function, ObservableSource>() { 96 | // @Override 97 | // public ObservableSource apply(@NonNull Observable throwableObservable) throws Exception { 98 | // 99 | // // 返回新的被观察者 Observable 100 | // // 此处有两种情况： 101 | // // 1. 原始的Observable不重新发送事件：新的被观察者 Observable发送的事件 = Error事件 102 | // // 2. 原始的Observable重新发送事件：新的被观察者 Observable发送的事件 = 数据事件 103 | // return throwableObservable.flatMap(new Function>() { 104 | // @Override 105 | // public ObservableSource apply(@NonNull Throwable throwable) throws Exception { 106 | // 107 | // // 1. 若返回的Observable发送的事件 = Error事件，则原始的Observable不重新发送事件 108 | // // 该异常错误信息可在观察者中的onError（）中获得 109 | // // return Observable.error(new Throwable("retryWhen终止啦")); 110 | // 111 | // // 2. 若返回的Observable发送的事件 = 数据事件，则原始的Observable重新发送事件（若持续遇到错误，则持续重试） 112 | // return Observable.just(1); 113 | // } 114 | // }); 115 | // 116 | // } 117 | // }) 118 | // .subscribe(new Observer() { 119 | // @Override 120 | // public void onSubscribe(Disposable d) { 121 | // 122 | // } 123 | // @Override 124 | // public void onNext(Integer value) { 125 | // Log.d(TAG, "接收到了事件"+ value ); 126 | // } 127 | // 128 | // @Override 129 | // public void onError(Throwable e) { 130 | // Log.d(TAG, "对Error事件作出响应" + e.toString()); 131 | // // 获取异常错误信息 132 | // } 133 | // 134 | // @Override 135 | // public void onComplete() { 136 | // Log.d(TAG, "对Complete事件作出响应"); 137 | // } 138 | // }); 139 | 140 | 141 | 142 | // Observable.combineLatest( 143 | // Observable.intervalRange(0, 3, 0, 2, TimeUnit.SECONDS), // 第1个发送数据事件的Observable 144 | // Observable.intervalRange(0, 3, 0, 1, TimeUnit.SECONDS), // 第2个发送数据事件的Observable：从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s 145 | // new BiFunction() { 146 | // @Override 147 | // public Long apply(Long o1, Long o2) throws Exception { 148 | // // o1 = 第1个Observable发送的最新（最后）1个数据 149 | // // o2 = 第2个Observable发送的每1个数据 150 | // Log.e(TAG, "合并的数据是： "+ o1 + " "+ o2); 151 | // return o1 + o2; 152 | // // 合并的逻辑 = 相加 153 | // // 即第1个Observable发送的最后1个数据 与 第2个Observable发送的每1个数据进行相加 154 | // } 155 | // }).subscribe(new Consumer() { 156 | // @Override 157 | // public void accept(Long s) throws Exception { 158 | // Log.e(TAG, "合并的结果是： "+s); 159 | // } 160 | // }); 161 | 162 | // 163 | // Observable.concatArrayDelayError( 164 | // Observable.create(new ObservableOnSubscribe() { 165 | // @Override 166 | // public void subscribe(ObservableEmitter emitter) throws Exception { 167 | // 168 | // emitter.onNext(1); 169 | // emitter.onNext(2); 170 | // emitter.onNext(3); 171 | // emitter.onError(new NullPointerException()); // 发送Error事件，因为使用了concatDelayError，所以第2个Observable将会发送事件，等发送完毕后，再发送错误事件 172 | // emitter.onComplete(); 173 | // } 174 | // }), 175 | // Observable.just(4, 5, 6)) 176 | // .subscribe(new Observer() { 177 | // @Override 178 | // public void onSubscribe(Disposable d) { 179 | // 180 | // } 181 | // @Override 182 | // public void onNext(Integer value) { 183 | // Log.d(TAG, "接收到了事件"+ value ); 184 | // } 185 | // 186 | // @Override 187 | // public void onError(Throwable e) { 188 | // Log.d(TAG, "对Error事件作出响应"); 189 | // } 190 | // 191 | // @Override 192 | // public void onComplete() { 193 | // Log.d(TAG, "对Complete事件作出响应"); 194 | // } 195 | // }); 196 | 197 | // 在一个被观察者发送事件前，追加发送被观察者 & 发送数据 198 | // 注：追加数据顺序 = 后调用先追加 199 | // Observable.just(4, 5, 6) 200 | // .startWith(Observable.just(1, 2, 3)) 201 | // .subscribe(new Observer() { 202 | // @Override 203 | // public void onSubscribe(Disposable d) { 204 | // 205 | // } 206 | // 207 | // @Override 208 | // public void onNext(Integer value) { 209 | // Log.d(TAG, "接收到了事件"+ value ); 210 | // } 211 | // 212 | // @Override 213 | // public void onError(Throwable e) { 214 | // Log.d(TAG, "对Error事件作出响应"); 215 | // } 216 | // 217 | // @Override 218 | // public void onComplete() { 219 | // Log.d(TAG, "对Complete事件作出响应"); 220 | // } 221 | // }); 222 | 223 | 224 | 225 | 226 | 227 | // // 使用2：获取位置索引大于发送事件序列时，设置默认参数 228 | // Observable.just(1, 2, 3, 4, 5) 229 | // .elementAt(6,10) 230 | // .subscribe(new Consumer() { 231 | // @Override 232 | // public void accept( Integer integer) throws Exception { 233 | // Log.d(TAG,"获取到的事件元素是： "+ integer); 234 | // } 235 | // }); 236 | // 237 | // 238 | // // 获取的位置索引 ＞ 发送事件序列长度时，抛出异常 239 | // Observable.just(1, 2, 3, 4, 5) 240 | // .elementAtOrError(6) 241 | // .subscribe(new Consumer() { 242 | // @Override 243 | // public void accept( Integer integer) throws Exception { 244 | // Log.d(TAG,"获取到的事件元素是： "+ integer); 245 | // } 246 | // }); 247 | 248 | 249 | 250 | // // 参数说明： 251 | // // 参数1 = 第1次延迟时间； 252 | // // 参数2 = 间隔时间数字； 253 | // // 参数3 = 时间单位； 254 | // Observable.interval(3,1,TimeUnit.SECONDS) 255 | // // 该例子发送的事件序列特点：延迟3s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个） 256 | // .subscribe(new Observer() { 257 | // @Override 258 | // public void onSubscribe(Disposable d) { 259 | // Log.d(TAG, "开始采用subscribe连接"); 260 | // } 261 | // // 默认最先调用复写的 onSubscribe（） 262 | // 263 | // @Override 264 | // public void onNext(Long value) { 265 | // Log.d(TAG, "接收到了事件"+ value ); 266 | // } 267 | // 268 | // @Override 269 | // public void onError(Throwable e) { 270 | // Log.d(TAG, "对Error事件作出响应"); 271 | // } 272 | // 273 | // @Override 274 | // public void onComplete() { 275 | // Log.d(TAG, "对Complete事件作出响应"); 276 | // } 277 | // 278 | // }); 279 | 280 | 281 | 282 | // // 参数说明： 283 | // // 参数1 = 事件序列起始点； 284 | // // 参数2 = 事件数量； 285 | // // 注：若设置为负数，则会抛出异常 286 | // Observable.range(3,10) 287 | // // 该例子发送的事件序列特点：从3开始发送，每次发送事件递增1，一共发送10个事件 288 | // .subscribe(new Observer() { 289 | // @Override 290 | // public void onSubscribe(Disposable d) { 291 | // Log.d(TAG, "开始采用subscribe连接"); 292 | // } 293 | // // 默认最先调用复写的 onSubscribe（） 294 | // 295 | // @Override 296 | // public void onNext(Integer value) { 297 | // Log.d(TAG, "接收到了事件"+ value ); 298 | // } 299 | // 300 | // @Override 301 | // public void onError(Throwable e) { 302 | // Log.d(TAG, "对Error事件作出响应"); 303 | // } 304 | // 305 | // @Override 306 | // public void onComplete() { 307 | // Log.d(TAG, "对Complete事件作出响应"); 308 | // } 309 | // 310 | // }); 311 | 312 | 313 | // 314 | // Observable.sequenceEqual( 315 | // Observable.just(4,5,6), 316 | // Observable.just(4,5,6) 317 | // ) 318 | // .subscribe(new Consumer() { 319 | // @Override 320 | // public void accept( Boolean aBoolean) throws Exception { 321 | // Log.d(TAG,"2个Observable是否相同："+ aBoolean); 322 | // // 输出返回结果 323 | // } 324 | // }); 325 | 326 | 327 | // // （原始）第1个Observable：每隔1s发送1个数据 = 从0开始，每次递增1 328 | // Observable.interval(1, TimeUnit.SECONDS) 329 | // // 第2个Observable：延迟5s后开始发送1个Long型数据 330 | // .skipUntil(Observable.timer(5, TimeUnit.SECONDS)) 331 | // .subscribe(new Observer() { 332 | // @Override 333 | // public void onSubscribe(Disposable d) { 334 | // Log.d(TAG, "开始采用subscribe连接"); 335 | // } 336 | // 337 | // @Override 338 | // public void onNext(Long value) { 339 | // Log.d(TAG, "接收到了事件"+ value ); 340 | // } 341 | // 342 | // @Override 343 | // public void onError(Throwable e) { 344 | // Log.d(TAG, "对Error事件作出响应"); 345 | // } 346 | // 347 | // @Override 348 | // public void onComplete() { 349 | // Log.d(TAG, "对Complete事件作出响应"); 350 | // } 351 | // 352 | // }); 353 | 354 | 355 | 356 | 357 | 358 | 359 | // 360 | // // 1. 每1s发送1个数据 = 从0开始，递增1，即0、1、2、3 361 | // Observable.interval(1, TimeUnit.SECONDS) 362 | // // 2. 通过takeWhile传入一个判断条件 363 | // .takeWhile(new Predicate(){ 364 | // @Override 365 | // public boolean test( Long integer) throws Exception { 366 | // return (integer<3); 367 | // // 当发送的数据满足<3时，才发送Observable的数据 368 | // } 369 | // }).subscribe(new Observer() { 370 | // @Override 371 | // public void onSubscribe(Disposable d) { 372 | // } 373 | // 374 | // @Override 375 | // public void onNext(Long value) { 376 | // Log.d(TAG,"发送了事件 "+ value); 377 | // } 378 | // 379 | // @Override 380 | // public void onError(Throwable e) { 381 | // } 382 | // 383 | // @Override 384 | // public void onComplete() { 385 | // } 386 | // }); 387 | 388 | 389 | 390 | 391 | 392 | 393 | // Observable.just(1,2,3,4,5,6) 394 | // .map(new Function() { 395 | // @Override 396 | // public String apply(Integer value) throws Exception { 397 | // File file = new File(value); 398 | // file.createNewFile(); 399 | // return "aa"; 400 | // } 401 | // }); 402 | 403 | 404 | 405 | } 406 | 407 | 408 | 409 | 410 | // Observable.just(1,2,3,4,5,6) 411 | // .all(new Func2() { 412 | // @Override 413 | // public Boolean apply(Integer integer, @NonNull Object o2) throws Exception { 414 | // return integer<=10; 415 | // // 该函数用于判断Observable发送的10个数据是否都满足integer<=10 416 | // } 417 | // 418 | // @Override 419 | // public Boolean call(Integer integer) { 420 | // return integer<=10; 421 | // // 该函数用于判断Observable发送的10个数据是否都满足integer<=10 422 | // } 423 | // }).subscribe(new Consumer() { 424 | // @Override 425 | // public void accept(Boolean aBoolean) throws Exception { 426 | // Log.d(TAG,"result is "+ aBoolean); 427 | // // 输出返回结果 428 | // } 429 | // 430 | // }); 431 | 432 | // Observable.create(new Observable.OnSubscribe() { 433 | // @Override 434 | // public void call(Subscriber subscriber) { 435 | // // 不发送任何有效事件 436 | // // subscriber.onNext(1); 437 | // // subscriber.onNext(2); 438 | // // subscriber.onNext(3); 439 | // 440 | // subscriber.onCompleted(); 441 | // // 仅发送Complete事件 442 | // } 443 | // }).defaultIfEmpty(10) // 若仅发送了Complete事件，默认发送 值 = 10 444 | // .subscribe(new Subscriber() { 445 | // @Override 446 | // public void onCompleted() { 447 | // Log.v(TAG, "onCompleted"); 448 | // } 449 | // @Override 450 | // public void onError(Throwable e) { 451 | // Log.v(TAG, "onError:"+e.getMessage()); 452 | // } 453 | // @Override 454 | // public void onNext(Integer integer) { 455 | // Log.v(TAG, "onNext:"+integer); 456 | // } 457 | // }); 458 | 459 | // 460 | //// 1. 通过creat（）创建被观察者对象 461 | // Observable.create(new ObservableOnSubscribe() { 462 | // // 2. 在复写的subscribe（）里定义需要发送的事件 463 | // @Override 464 | // public void subscribe(ObservableEmitter emitter) throws Exception { 465 | // emitter.onNext(1); 466 | // emitter.onNext(2); 467 | // emitter.onNext(3); 468 | // emitter.onNext(4); 469 | // 470 | // emitter.onComplete(); 471 | // } // 至此，一个被观察者对象（Observable）就创建完毕 472 | // }).subscribe(new Observer() { 473 | // // 以下步骤仅为展示一个完整demo，可以忽略 474 | // // 3. 通过通过订阅（subscribe）连接观察者和被观察者 475 | // // 4. 创建观察者 & 定义响应事件的行为 476 | // @Override 477 | // public void onSubscribe(Disposable d) { 478 | // Log.d(TAG, "开始采用subscribe连接"); 479 | // } 480 | // // 默认最先调用复写的 onSubscribe（） 481 | // 482 | // @Override 483 | // public void onNext(Integer value) { 484 | // Log.d(TAG, "接收到了事件"+ value ); 485 | // } 486 | // 487 | // @Override 488 | // public void onError(Throwable e) { 489 | // Log.d(TAG, "对Error事件作出响应"); 490 | // } 491 | // 492 | // @Override 493 | // public void onComplete() { 494 | // Log.d(TAG, "对Complete事件作出响应"); 495 | // } 496 | // 497 | // }); 498 | } 499 | 500 | 501 | 502 | 503 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/SwitchOperator/Demo/GetRequest_Interface2.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.SwitchOperator.Demo; 2 | 3 | import io.reactivex.Observable; 4 | import retrofit2.http.GET; 5 | 6 | /** 7 | * Created by Carson_Ho on 17/9/12. 8 | */ 9 | 10 | public interface GetRequest_Interface2 { 11 | 12 | // 网络请求1 13 | @GET("ajax.php?a=fy&f=auto&t=auto&w=hi%20register") 14 | Observable getCall(); 15 | 16 | // 网络请求2 17 | @GET("ajax.php?a=fy&f=auto&t=auto&w=hi%20login") 18 | Observable getCall_2(); 19 | 20 | // 注解里传入 网络请求 的部分URL地址 21 | // Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里 22 | // 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略 23 | // 采用Observable<...>接口 24 | // getCall()是接受网络请求数据的方法 25 | 26 | } 27 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/SwitchOperator/Demo/RxJavaxRxtrofit3.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.SwitchOperator.Demo; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory; 8 | 9 | import io.reactivex.Observable; 10 | import io.reactivex.ObservableSource; 11 | import io.reactivex.android.schedulers.AndroidSchedulers; 12 | import io.reactivex.functions.Consumer; 13 | import io.reactivex.functions.Function; 14 | import io.reactivex.schedulers.Schedulers; 15 | import retrofit2.Retrofit; 16 | import retrofit2.converter.gson.GsonConverterFactory; 17 | import scut.carson_ho.rxjava_operators.R; 18 | 19 | /** 20 | * Created by Carson_Ho on 17/9/12. 21 | */ 22 | 23 | public class RxJavaxRxtrofit3 extends AppCompatActivity { 24 | 25 | private static final String TAG = "Rxjava"; 26 | 27 | // 定义Observable接口类型的网络请求对象 28 | Observable observable1; 29 | Observable observable2; 30 | 31 | @Override 32 | protected void onCreate(Bundle savedInstanceState) { 33 | super.onCreate(savedInstanceState); 34 | setContentView(R.layout.activity_main); 35 | 36 | // 步骤1：创建Retrofit对象 37 | Retrofit retrofit = new Retrofit.Builder() 38 | .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url 39 | .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖) 40 | .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava 41 | .build(); 42 | 43 | // 步骤2：创建 网络请求接口 的实例 44 | GetRequest_Interface2 request = retrofit.create(GetRequest_Interface2.class); 45 | 46 | // 步骤3：采用Observable<...>形式 对 2个网络请求 进行封装 47 | observable1 = request.getCall(); 48 | observable2 = request.getCall_2(); 49 | 50 | 51 | observable1.subscribeOn(Schedulers.io()) // （初始被观察者）切换到IO线程进行网络请求1 52 | .observeOn(AndroidSchedulers.mainThread()) // （新观察者）切换到主线程 处理网络请求1的结果 53 | .doOnNext(new Consumer() { 54 | @Override 55 | public void accept(Translation1 result) throws Exception { 56 | Log.d(TAG, "第1次网络请求成功"); 57 | result.show(); // 对第1次网络请求返回的结果进行操作 = 显示翻译结果 58 | } 59 | }) 60 | 61 | .observeOn(Schedulers.io()) // （新被观察者，同时也是新观察者）切换到IO线程去发起登录请求 62 | // 特别注意：因为flatMap是对初始被观察者作变换，所以对于旧被观察者，它是新观察者，所以通过observeOn切换线程 63 | // 但对于初始观察者，它则是新的被观察者 64 | .flatMap(new Function>() { // 作变换，即作嵌套网络请求 65 | @Override 66 | public ObservableSource apply(Translation1 result) throws Exception { 67 | // 将网络请求1转换成网络请求2，即发送网络请求2 68 | return observable2; 69 | } 70 | }) 71 | 72 | .observeOn(AndroidSchedulers.mainThread()) // （初始观察者）切换到主线程 处理网络请求2的结果 73 | .subscribe(new Consumer() { 74 | @Override 75 | public void accept(Translation2 result) throws Exception { 76 | Log.d(TAG, "第2次网络请求成功"); 77 | result.show(); // 对第2次网络请求返回的结果进行操作 = 显示翻译结果 78 | } 79 | }, new Consumer() { 80 | @Override 81 | public void accept(Throwable throwable) throws Exception { 82 | System.out.println("登录失败"); 83 | } 84 | }); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/SwitchOperator/Demo/Translation1.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.SwitchOperator.Demo; 2 | 3 | import android.util.Log; 4 | 5 | /** 6 | * Created by Carson_Ho on 17/9/12. 7 | */ 8 | 9 | public class Translation1 { 10 | private int status; 11 | private content content; 12 | private static class content { 13 | private String from; 14 | private String to; 15 | private String vendor; 16 | private String out; 17 | private int errNo; 18 | } 19 | 20 | //定义 输出返回数据 的方法 21 | public void show() { 22 | 23 | Log.d("RxJava", "翻译内容 = " + content.out); 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/SwitchOperator/Demo/Translation2.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.SwitchOperator.Demo; 2 | 3 | import android.util.Log; 4 | 5 | /** 6 | * Created by Carson_Ho on 17/9/12. 7 | */ 8 | 9 | public class Translation2 { 10 | private int status; 11 | private content content; 12 | private static class content { 13 | private String from; 14 | private String to; 15 | private String vendor; 16 | private String out; 17 | private int errNo; 18 | } 19 | 20 | //定义 输出返回数据 的方法 21 | public void show() { 22 | 23 | Log.d("RxJava", "翻译内容 = " + content.out); 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /app/src/main/java/scut/carson_ho/rxjava_operators/SwitchOperator/SwitchUsage.java: -------------------------------------------------------------------------------- 1 | package scut.carson_ho.rxjava_operators.SwitchOperator; 2 | 3 | import android.os.Bundle; 4 | import android.support.v7.app.AppCompatActivity; 5 | import android.util.Log; 6 | 7 | import java.util.ArrayList; 8 | import java.util.List; 9 | 10 | import io.reactivex.Observable; 11 | import io.reactivex.ObservableEmitter; 12 | import io.reactivex.ObservableOnSubscribe; 13 | import io.reactivex.ObservableSource; 14 | import io.reactivex.Observer; 15 | import io.reactivex.disposables.Disposable; 16 | import io.reactivex.functions.Consumer; 17 | import io.reactivex.functions.Function; 18 | import scut.carson_ho.rxjava_operators.R; 19 | 20 | /** 21 | * Created by Carson_Ho on 17/9/12. 22 | */ 23 | 24 | public class SwitchUsage extends AppCompatActivity { 25 | 26 | private String TAG = "RxJava"; 27 | 28 | 29 | @Override 30 | protected void onCreate(Bundle savedInstanceState) { 31 | super.onCreate(savedInstanceState); 32 | setContentView(R.layout.activity_combine); 33 | 34 | 35 | /** 36 | * Buffer（） 37 | */ 38 | 39 | // 被观察者 需要发送5个数字 40 | Observable.just(1, 2, 3, 4, 5) 41 | .buffer(3, 1) // 设置缓存区大小 & 步长 42 | // 缓存区大小 = 每次从被观察者中获取的事件数量 43 | // 步长 = 每次获取新事件的数量 44 | .subscribe(new Observer>() { 45 | @Override 46 | public void onSubscribe(Disposable d) { 47 | 48 | } 49 | @Override 50 | public void onNext(List stringList) { 51 | // 52 | Log.d(TAG, " 缓存区里的事件数量 = " + stringList.size()); 53 | for (Integer value : stringList) { 54 | Log.d(TAG, " 事件 = " + value); 55 | } 56 | } 57 | 58 | @Override 59 | public void onError(Throwable e) { 60 | Log.d(TAG, "对Error事件作出响应" ); 61 | } 62 | 63 | @Override 64 | public void onComplete() { 65 | Log.d(TAG, "对Complete事件作出响应"); 66 | } 67 | }); 68 | 69 | 70 | /** 71 | * ConcatMap（） 72 | */ 73 | 74 | // 采用RxJava基于事件流的链式操作 75 | Observable.create(new ObservableOnSubscribe() { 76 | @Override 77 | public void subscribe(ObservableEmitter emitter) throws Exception { 78 | emitter.onNext(1); 79 | emitter.onNext(2); 80 | emitter.onNext(3); 81 | } 82 | 83 | // 采用concatMap（）变换操作符 84 | }).concatMap(new Function>() { 85 | @Override 86 | public ObservableSource apply(Integer integer) throws Exception { 87 | final List list = new ArrayList<>(); 88 | for (int i = 0; i < 3; i++) { 89 | list.add("我是事件 " + integer + "拆分后的子事件" + i); 90 | // 通过concatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件 91 | // 最终合并，再发送给被观察者 92 | } 93 | return Observable.fromIterable(list); 94 | } 95 | }).subscribe(new Consumer() { 96 | @Override 97 | public void accept(String s) throws Exception { 98 | Log.d(TAG, s); 99 | } 100 | }); 101 | 102 | /** 103 | * FlatMap（） 104 | */ 105 | // 采用RxJava基于事件流的链式操作 106 | Observable.create(new ObservableOnSubscribe() { 107 | @Override 108 | public void subscribe(ObservableEmitter emitter) throws Exception { 109 | emitter.onNext(1); 110 | emitter.onNext(2); 111 | emitter.onNext(3); 112 | } 113 | 114 | // 采用flatMap（）变换操作符 115 | }).flatMap(new Function>() { 116 | @Override 117 | public ObservableSource apply(Integer integer) throws Exception { 118 | final List list = new ArrayList<>(); 119 | for (int i = 0; i < 3; i++) { 120 | list.add("我是事件 " + integer + "拆分后的子事件" + i); 121 | // 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件 122 | // 最终合并，再发送给被观察者 123 | } 124 | return Observable.fromIterable(list); 125 | } 126 | }).subscribe(new Consumer() { 127 | @Override 128 | public void accept(String s) throws Exception { 129 | Log.d(TAG, s); 130 | } 131 | }); 132 | 133 | 134 | /** 135 | * Map（） 136 | */ 137 | 138 | // 采用RxJava基于事件流的链式操作 139 | Observable.create(new ObservableOnSubscribe() { 140 | 141 | // 1. 被观察者发送事件 = 参数为整型 = 1、2、3 142 | @Override 143 | public void subscribe(ObservableEmitter emitter) throws Exception { 144 | emitter.onNext(1); 145 | emitter.onNext(2); 146 | emitter.onNext(3); 147 | 148 | } 149 | // 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型 150 | }).map(new Function() { 151 | @Override 152 | public String apply(Integer integer) throws Exception { 153 | return "使用 Map变换操作符 将事件" + integer +"的参数从 整型"+integer + " 变换成 字符串类型" + integer ; 154 | } 155 | }).subscribe(new Consumer() { 156 | 157 | // 3. 观察者接收事件时，是接收到变换后的事件 = 字符串类型 158 | @Override 159 | public void accept(String s) throws Exception { 160 | Log.d(TAG, s); 161 | } 162 | }); 163 | 164 | } 165 | } 166 | -------------------------------------------------------------------------------- /app/src/main/res/layout/activity_combine.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 13 | 14 | 20 | 21 | 27 | 28 |