封夕罡
封夕罡

RxJavaAndroid学习笔记

当子线程处理某个逻辑要在主线程显示的时候使用。


   Observable.just(currentBytesCount).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1() {

                                    @Override
                                    public void call(Long aLong) {
                                        tvMsg.setText("提示:上传中");
                                        progressBar.setMax((int) totalBytesCount);
                                        progressBar.setProgress((int) currentBytesCount);
                                    }
                                });

清神咒

! 我感觉吧，也许Rx之所以让人感觉恐惧学习成本高，是因为被一些术语绕来绕去绕晕了，术语太抽象，不接近生活本质、很难理解，或者记忆深刻，什么发射，什么观察者、被观察者、什么onNext，但是我一直被这些文章吓得不轻，也被这单词绕来绕去绕晕了，产生了恐惧中，什么观察啊被观察头都晕了，现在我撸了屡，通熟易懂的来说 来本质无非就是 添加一个回调到一个操作类里面，执行这个操作类的时候的时候会遍历调用这些回调， 只是执行的时候可以设置在主线程回调还是子线程回调 以及自己的任务是在主线程执行还是子线程执行
2、没有学以致用，或者不知道什么时候用，应该把什么东西改成什么。

单词介绍和转换概念加深印象

这里不得不说一个事情，就是记忆的技巧，如果你觉得一个东西太过抽象，但是要想不对他产生恐惧，而且想轻松记下来，不会搞混淆，搞反，你应该把它变成你熟悉的业务，这样方便你一气呵成，而不是扭啊扭的被术语绕晕。

观察者Observer

1、把它理解操作类
2、把它业务逻辑类
3、强加一个印象，他音乐播放器的具体实现类代码类
4、管理这些回调/处理的逻辑回调的类
5、发布事件的 ，上游

被观察者Observable

1、把它理解为一个回调
2、把它理解为业务逻辑最终执行的你想知道的一个方法活多个监听接口
3、把它理解为一个音乐播放器的进度播放回调、暂停回调。
4、 下游、一般用于主线程
5、接受时间的

订阅 Subscribe

就是把Observer添加到Observable中持有，这样有点饶了，那么换通熟易懂一点。
1、把回调添加到这个控制器的回调接口列表，它会在适当的时机回调它。
2、给就是音乐播放器的控制类设置一个回调、可以设置一个或者多个。
示例

import java.util.Arrays;

import io.reactivex.Flowable;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableOperator;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;

/**
 * Created by qssq on 2018/11/14 [email protected]
 */

public class Main {

    public static void print(String str) {
        System.out.println("Main.print:" + str);
    }

    public void print_obj(String str) {
        System.out.println("Main.print_obj:" + str);
    }


    public static void main(String[] args) {
        System.out.println("hllll");
//        testObservableSimple();

     /*   Observable.fromArray(new byte[]{11111})
                .flatMap((Func1) (folder) -> {
                    Observable.from(file.listFiles())
                })
                .filter((Func1) (file) -> {
                    file.getName().endsWith(".png")
                })
                .map((Func1) (file) -> {
                    getBitmapFromFile(file)
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe((Action1) (bitmap) -> {
                    imageCollectorView.addImage(bitmap)
                });*/
//        testObservable1();

  /*      Subscriber subscriber = new Subscriber() {
            @Override
            public void onSubscribe(Subscription s) {

            }

            @Override
            public void onNext(Course course) {
            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onComplete() {

            }
        };*/


//        testOneObjectMultiChild();
//        testLift();
//        testSmiple();


        try {

            Thread.sleep(8000);

        } catch (Exception e) {

        }


    }

    private static void testLift() {//据说也属于变黄。
        Observable.just(1, 2, 3, 50, 60)//打印 1 2 3 4，
                .lift(new ObservableOperator() { //lift 举起 鼓舞 如果没有使用list,那么 这interger 最后接受的也只能是int,而用这个就实现了变换。  泛型 左边 为 要转换的类型，右边则表示之前的类型 这里必须写成integer,因为之前fajust返回的以及是integer了。

                    @Override
                    public Observer apply(Observer observer) throws Exception {
                        return new Observer() {
                            @Override
                            public void onSubscribe(Disposable d) {
                                observer.onSubscribe(d);
                            }

                            @Override
                            public void onNext(Integer integer) {

                                observer.onNext("数字10" + integer + "的16进制为;" + Integer.toHexString(integer));
                            }

                            @Override
                            public void onError(Throwable e) {

                                observer.onError(e);
                            }

                            @Override
                            public void onComplete() {

                                observer.onComplete();
                            }
                        };
                    }
                })
                .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程 导致不打印
                .observeOn(Schedulers.newThread()) // 指定 Subscriber 的回调发生在主线程
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String o) throws Exception {
                        System.out.println("lift结果：" + o);
                    }
                });
    }

    private static void testOneObjectMultiChild() {
        //遍历 一对多  所有学生的所学的课程 ，默认是 英语  数学， 张三除外。一对多关系。   map和 flatMap的区别。
        Student[] students = new Student[]{Student.newInstance("张三").setCourses(new Course[]{Course.newInstance("德语"), Course.newInstance("日语")}), Student.newInstance("李四"), Student.newInstance("王老五"), Student.newInstance("某某")};


        Observable.fromArray(students)
                .flatMap(new Function>() {
                    @Override
                    public ObservableSource apply(Student student) throws Exception {
                        return Observable.fromArray(student.getCourses());//flatMap是1对多， 而map只能1对1 返回。
                    }
                })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Course course) throws Exception {
                        System.out.println("课程:" + course.getName());
                    }
                });
    }

    public static class Course {
        public String getName() {
            return name;
        }

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

        public Course() {
        }

        public void setName(String name) {
            this.name = name;
        }

        public static Course newInstance(String name) {
            return new Course(name);
        }

        String name;
    }

    public static class Student {
        private Course[] courses = new Course[]{Course.newInstance("英语"), Course.newInstance("数学")};

        public String getName() {
            return name;
        }

        public Student() {
        }

        private String name;

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

        public static Student newInstance(String name) {
            return new Student(name);
        }

        public static Student newInstance(String name, Course[] courses) {
            return new Student(name).setCourses(courses);
        }

        public Student setCourses(Course[] courses) {
            this.courses = courses;
            return this;
        }

        public Course[] getCourses() {

            return courses;
        }

    }

    private static void testSmiple() {
        Flowable.just("Hello world").subscribe(System.out::println);//表示调用System.out.println来接受字符串 ()
        Flowable.just("Hello world").subscribe(new Main()::print_obj);//自己定义的方法 非静态
        Flowable.just("Hello world").subscribe(Main::print);//自己定义的方法，为静态
        Flowable.just("Hello world").subscribe(new Consumer() {//这种写法等价。
            @Override
            public void accept(String s) throws Exception {
                System.out.println("" + s);
            }
        });


        Flowable.just("Hello world").subscribe(new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println("" + s);
            }
        });
/*
        Flowable.fromCallable(new Callable() {
            @Override
            public Object call() throws Exception {
                return null;
            }
        });*/
        //lamba  貌似度一样的执行，模拟背压了？？


        Flowable.fromCallable(() -> {
            Thread.sleep(5320); //  imitate expensive computation 模拟耗时 昂贵的计算。
            return "耗时不啊 ，啊啊啊啊啊啊";
        })
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.single())
                .subscribe(System.out::println, Throwable::printStackTrace);

        //范围打印 也可以实现，学生一对多？
        Flowable.range(1, 10)
                .parallel()//自动推导 int
                .runOn(Schedulers.computation())
                .map(v -> v * v)
                .sequential()//顺序执行
                .blockingSubscribe(System.out::println);

//            Flowable.


        //遍历数组。
        String[] names = new String[]{"333", "555", "6666"};
        Observable.fromArray(names)
                .subscribe(new Consumer() {//消费者，也就是 观察者
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println(" arr:" + s);
                    }
                });
        //有问题，不能指定 订阅线程， 是因为过早退出了
        Observable.just(1, 2, 3, 4)
                .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程 导致不打印
                .observeOn(Schedulers.newThread()) // 指定 Subscriber 的回调发生在主线程
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("," + integer);
                    }
                });
    }

    private static void testObservableSimple() {
        Observable.create(new ObservableOnSubscribe() {//这里的泛型代表开始发布的泛型。
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                //
                System.out.println("1、有人订阅了，我要发布，" + "," + Thread.currentThread().getName());
                emitter.onNext(new StringBuffer("很好爱爱"));
                emitter.onComplete(); // 如果调用了，这个，那么下面的方法都不会继续调用了， 这个应该放到最后面，另外不调用的话也不影响逻辑正常执行，只是不会回调onComplete
//                emitter.onError(new Throwable("测试异常onError"));
            }
        }).map(new Function() {
            @Override
            public StringBuffer apply(StringBuffer stringBuffer) throws Exception {
                System.out.println("1.1、AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA,收到" + stringBuffer + "," + Thread.currentThread().getName());
                return new StringBuffer("map---------->");
            }
        })
                .subscribeOn(Schedulers.newThread())//不能插入这个，否则不会走 ,1.2.3
                .observeOn(Schedulers.newThread())//监听着执行在什么线程
                .subscribe(new Consumer() {
                    @Override
                    public void accept(StringBuffer stringBuffer) throws Exception {
                        System.out.println("2、处理结果:收到字符串:" + stringBuffer + "," + Thread.currentThread().getName());
                    }
                }, new Consumer() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        System.err.println("2、处理结果:收到异常:" + throwable + "," + Thread.currentThread().getName());
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        System.out.println("3、收到onCompletion:" + "," + Thread.currentThread().getName());

                    }
                });
    }

    private static void testObservable1() {
        //执行完毕自动执行 作用是从1-4 不断地发布，总共发布2次，都会走1 ，2 ，3， 4
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                System.out.println("subscribe 方法调用，我发布一个时间 onNext 传递 你好 " + e + "," + Thread.currentThread().getName());
                e.onNext("你好"); //发送事件
                System.out.println("subscribe 方法调用，我继续发布一个时间 onNext 传递 你好 " + e + "," + Thread.currentThread().getName());
                e.onNext("你到底好不好"); //发送事件
//                e.onComplete();//某些文章说要调用，感觉没作用
//                e.onComplete();
//                e.onComplete();
                System.out.println("subscribe 任务下发完毕");
            }
        }).map(new Function() { // 左边为接受的参数，右边为返回值
            @Override
            public byte[] apply(String str) throws Exception {
                System.out.println("1、apply 收到字符串" + str + ",我返回结果数组:  " + str + "," + Thread.currentThread().getName());
                return new byte[]{};
            }
        }).map(new Function() { // 输入字节码数组，保存文件，输出文件路径


            @Override
            public String apply(byte[] byteArray) throws Exception {

                System.out.println("2、apply arr 收到刚刚传递的数组 " + Arrays.toString(byteArray) + "我再次返回字符串: 哈哈哈 " + Thread.currentThread().getName());
                return "哈哈哈哈";
            }
        }).map(new Function() { //输入class路径，jar uvf命令替换jar
            @Override
            public Integer apply(String s) throws Exception {
                System.out.println("3、apply  收到字符串" + s + "iinteger 我返回结果标记为1 " + Thread.currentThread().getName());
               /* if (s != "a") {
                    throw new RuntimeException("走 错误标记吧少年..");
                }*/
                return 1;
            }
        }).map(new Function() {

            @Override
            public Float apply(Integer integer) {
                System.out.println("3.1、apply  收到int " + integer + " iinteger 我返回结果标记为 5 " + Thread.currentThread().getName());
                return 5.0f;//如果这里第二个泛型 为float,那么 订阅 也应该是泛型。
            }
        }).subscribe(new Consumer() {//这里是订阅，订阅有一个成功和失败的回调。链式编程看习惯了就好了 e subscribe(Consumer onNext, Consumer onError)
            @Override
            public void accept(Float status) throws Exception {//表示一个onNext onMap 等执行完毕但是
                System.out.println("4、result：accept  收到int值:" + status + "," + Thread.currentThread().getName());
            }
        }, new Consumer() {//表示的是上下发布了错误或者 抛出了错误。
            @Override
            public void accept(Throwable throwable) throws Exception {

                System.err.println("4、accept error:" + throwable.toString() + " ," + Thread.currentThread().getName());
            }
        });


    }

}

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJavaAndroid学习笔记)

        

            

                
    
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • Rxjava2你应该懂的源码，其实并不难（二）
                        kwbsky

                        
    接上篇继续。一、线程切换observeOnObservable.just("1").subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer)我们知道，当调用observeOn之后，后面执行的代码都将切换到他指定的线程，除非再次调用observeOn切换其他线程。上源码：@Ch
    
                    
    • 
                    
  • Android视频开发进阶-关于视频的那些术语，android软件开发计算器
                        wa32saa
程序员架构移动开发android
                        
    原文出处：jianshu正文说到安卓的视频开发，大多数朋友们都是用着开源的播放器，或者安卓自带的nativemediaplayer，拿来主义居多，我曾经也是。。。最近这半年因为开始着手重构公司的播放器,也开始学习了很多视频音频开发的相关知识，抱着独乐乐不如众乐乐的想法，开始写一些值得分享的东西。这次的连载和之前的RxJava分享一样，会分开不容的章节。第一次我打算分享一下视频开发中常见的一些知识点
    
                    
    • 
                    
  • 2024最新Android大厂面试真题大全（附答案）
                        imtokenmax合约众筹
2024年程序员面试android面试职场和发展
                        
    五、架构设计和设计模式1.谈谈你对Android设计模式的理解2.MVCMVPMVVM原理和区别3.你所知道的设计模式有哪些？4.项目中常用的设计模式5.手写生产者/消费者模式6.写出观察者模式的代码7.适配器模式，装饰者模式，外观模式的异同？8.用到的一些开源框架，介绍一个看过源码的，内部实现过程。9.谈谈对RxJava的理解10.Rxjava发送事件步骤11.RxJava的作用，与平时使用的异
    
                    
    • 
                    
  • Android-Jetpack架构组件（二）带你了解Lifecycle，给2021的移动开发一些建议
                        flutter架构师
程序员面试移动开发android
                        
    @OverrideprotectedvoidonResume(){super.onResume();myPresenter.onResume();}@OverrideprotectedvoidonPause(){super.onPause();myPresenter.onPause();}}classMyPresenter{《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战
    
                    
    • 
                    
  • Android从零开始搭建MVVM架构（6）
                        m0_66070459
程序员面试移动开发android
                        
    //加载项目build.gradle的anroid标签下dataBinding{enabled=true}添加相关依赖//okhttp、retrofit、rxjavaimplementation‘com.squareup.okhttp3:okhttp:3.8.0’implementation‘com.squareup.retrofit2:retrofit:2.3.0’implementation‘
    
                    
    • 
                    
  • okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
                        追梦的鱼儿
okhttpretrofitrxjava
                        
    目录OkHttp作用基本使用Retrofit作用基本使用RxJava作用优势基本使用三者的配合工作OkHttp、Retrofit和RxJava是Android开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。OkHttp作用OkHttp是一个高效的HTTP客户端，用于发起网络请求和处理响应。它支持同步和异步请求、连接池、缓存、重定向、超时设置等功能。基本使
    
                    
    • 
                    
  • Retrofit+Rxjava-以自己的方式重头开始-入门篇
                        MonkeyLei

                        
    之前小萌新直接上项目，然后立马就用上了Rretrofit和Rxjava来做，没有特别去学习，然后直接就干了。看了看别人的用法。后面也根据个人请求数据结果进行了封装，总共封装了两两次，基本实现了通用请求，一个请求方法就搞定所有请求，返回不同的对象或者对象列表MonkeyLei：Android-Retrofit2+Rxjava2之网络通用请求-初步封装-相关关键类MonkeyLei：Android-R
    
                    
    • 
                    
  • idea: 基于 http 的双向通信
                        weixin_33939380
开发工具java前端ViewUI
                        
    纯http上的双向通信最近大概看了下rxJava的订阅者模式，然后突发奇想有没有可能用类似的思路实现纯http上的双向通信A是传统的http服务器B是普通的客户端，假设我们能够在B上启动一个简易的httpserver并且有办法实现公网访问然后通过类似事件订阅的方式实现双向通信。例：要实现的功能：B是美团外卖商家端，当有用户下单时，B能够收到推送A是美团服务器，当用户下单时，给B发请求通知B实现思路
    
                    
    • 
                    
  • RxJava2+Retrofit2+RxLifecycle3+OkHttp3网络请求封装（动态演示）
                        2301_82241819
程序员网络php开发语言
                        
    ArrayMapmap=newArrayMap{NbaService.getInstance().getNBAInfo(“6949e822e6844ae6453fca0cf83379d3”).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).compose(this.bindToLifecycle()).s
    
                    
    • 
                    
  • Android学习笔记
                        孙小小白
androidandroidandroidstudioide
                        
    Android是一种廉价而又灵活的智能手机操作系统，它的普及使得人们可以拥有一款更加便捷的智能手机。Android系统的普及，提升了智能手机的使用价值，让人们的生活更加便捷。那么，如何学习Android呢？下面是一篇关于学习Android的文章，希望对初学者有所帮助。一、了解Android的基础知识在学习Android之前，我们需要了解Android系统的特点，包括其组件、运行机制、UI、API等
    
                    
    • 
                    
  • RxJava学习笔记
                        ztzt123

                        
    之前有过一次学习笔记，发现长时间不经常用Rx的一些操作已经忘得差不多了，经常的复习是多么的重要啊，这次会在上一次不足的部分补充一下。上一次的学习笔记：http://wiki.sankuai.com/pages/viewpage.action?pageId=405485429Rx操作符补充flatMap使用flatMap时将原本发送的数据进行转换，再返回转换后数据的Observable，flatMa
    
                    
    • 
                    
  • Rxjava Transtorming Observables
                        shiyuzhe

                        
    OperatorsthattransformitemsthatareemittedbyanObservable.Buffer—periodicallygatheritemsfromanObservableintobundlesandemitthesebundlesratherthanemittingtheitemsoneatatimeFlatMap—transformtheitemsemitted
    
                    
    • 
                    
  • LiveData 迁移到 Kotlin Flow详解
                        
kotlin
                        
    LiveData，是Android2017推出的一个东西，配合MVVM使用。观察者模式，的确简化了我们的工作方式，但RxJava等选项，对于当时的初学者来说实在是太复杂了。因此ArchitectureComponents团队创建了LiveData：这是个非常“有主见的”可观察数据持有者类，并且是专门为Android设计的。它保持简单明了，这让它易于上手，建议是将RxJava用于更复杂的响应流案例，
    
                    
    • 
                    
  • retrofit+rxjava+okhttp网络框架之二次封装
                        nade_s

                        
    retrofit+rxjava的是这几年很流行的一种网络框架，开发者也提供了丰富的方法。之所以进行二次封装，就是因为retrofit+rxjava的链式调用太方便了，不符合单一性原则，管理起来比较麻烦。主要目的是二次封装后，和项目有很高的契合度更高。说一下封装思路，由于其本身调用方便，具体方法就不做封装了。第一retrofit对象封装。第二封装okhttp拦截器，用于添加头参数，拦截错误日志。第三
    
                    
    • 
                    
  • RxJava常用的操作符
                        emmmmsuperdan
rxjavaandroidjava
                        
    ZipZip:把两个流返回结果一起调用；Zip(a,b,newFunction(b的类型，结合结果的返回类型));
    
                    
    • 
                    
  • Android混淆-基本混淆模板+自定义混淆类NotProguard
                        MonkeyLei

                        
    proguard-rules.pro-第三方就增加了一个glide+rxjava+retrofit，别的按需添加即可#AddprojectspecificProGuardruleshere.#Youcancontrolthesetofappliedconfigurationfilesusingthe#proguardFilessettinginbuild.gradle.##Formoredetai
    
                    
    • 
                    
  • RxJava-使用详解与背压原理2
                        Laughing_G

                        
    一、RxJava1与RxJava2的区别前提：RxJava是响应式编程，基于事件流开发。区别：1.RxJava2不再支持null值，如果传入一个null会抛出NullPointerException；2.Observable.just(null)不支持；3.RxJava2所有的函数接口（Function、Action、Consumer）均设计为可抛出Exception，同时支持自己去解决编译异常需
    
                    
    • 
                    
  • MVP步骤
                        I_Am_Legend

                        
    T-MVP步骤：1.添加依赖implementation'com.squareup.okhttp3:okhttp:3.8.1'implementation'com.squareup.okhttp3:logging-interceptor:3.4.1'implementation'io.reactivex:rxjava:1.1.6'//Retrofit的rx解析库implementation'com
    
                    
    • 
                    
  • 手把手带你入门神秘的RxJava
                        可以写但没有必要

                        
    近两年来国内的技术圈子中越来越多的开始提及RxJava，越来越多的应用和面试中都会有RxJava，而就目前的情况，Android的网络库基本被Retrofit+OkHttp一统天下了，而配合上响应式编程RxJava可谓如鱼得水。什么是RxJava•Rx是ReactiveExtensions的简写，翻译为响应的扩展。也就是通过由一方发出信息，另一方响应信息并作出处理的核心框架代码。•该框架由微软的架
    
                    
    • 
                    
  • Hystrix系列之执行原理分析
                        美团Java

                        
    上文中介绍了Hystrix的由来，本文会深入分析Hystrix的执行过程。Hystrix的大部分逻辑基于RxJava，其实现让很热多人望而却步，停留在了仅仅使用的地步，从一个简单的HelloWorld开始。publicclassCommandHelloWorldextendsHystrixCommand{privatefinalStringname;publicCommandHelloWorld(
    
                    
    • 
                    
  • RxJava之concatMap系列转换操作符源码介绍
                        103style

                        
    转载请以链接形式标明出处：本文出自:103style的博客转换相关的操作符以及官方介绍RxJava之concatMap系列转换操作符官方介绍：TransformingObservablesconcatMapconcatMapCompletableconcatMapCompletableDelayErrorconcatMapDelayErrorconcatMapEagerconcatMapEager
    
                    
    • 
                    
  • Coroutines和Rxjava异步编程对比之二
                        小菜鸟程序媛

                        
    原文地址：https://medium.com/@manuelvicnt/coroutines-and-rxjava-an-asynchronicity-comparison-part-2-cancelling-execution-199485cdf068在Android开发中，取消RxJava或Coroutines的执行时很重要的，因为在View即将被销毁的时候，取消网络请求或者对象的创建是必须
    
                    
    • 
                    
  • Rxjava2019-03-26
                        NullPointe_8e82

                        
    每隔一秒执行list集合中的一条数据//ObservablelistObservable=Observable.fromIterable(Catetorys);////interval定时器，间隔1秒发射一次//ObservabletimerObservable=Observable.interval(1000,TimeUnit.MILLISECONDS);////使用zip操作符合并两个Obse
    
                    
    • 
                    
  • 【Android】RxJava系列01-基本概述和基本用法
                        Rose J
RxJavaandroidrxjava
                        
    少年啊，要永远相信美好的事情即将发生【Android】RxJava系列01-基本概述和基本用法1.RxJava的概述2.RxJava的作用3.观察者和被观察者4.背压5.RxJava的基本用法步骤一，创建Observer（观察者）步骤二，创建Observable（被观察者）步骤三，Subscribe（订阅）1.RxJava的概述RxJava是什么？是ReactiveX的一种Java实现。那，Rea
    
                    
    • 
                    
  • RxSwift的使用详解
                        adaodao3056

                        
    RxSwift的使用详解一.RxSwift简介推荐:RxSwift官方文档中文:RxSwift官方文档的中文翻译RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发、维护其他语言像C#,Java和JS也有，Rx.Net、RxJava、rxjsRxSwift的目的是让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程1.RxSw
    
                    
    • 
                    
  • Retrofit2
                        穷极_d8f1

                        
    Retrofit2的好处超级解耦解耦？解什么耦？我们在请求接口数据的时候，API接口定义和API接口使用总是相互影响，什么传参、回调等，耦合在一块。有时候我们会考虑一下怎么封装我们的代码让这两个东西不那么耦合，这个就是Retrofit的解耦目标，也是它的最大的特点。可以配置不同HttpClient来实现网络请求，如OkHttp、HttpClient...支持同步、异步和RxJava可以配置不同的反
    
                    
    • 
                    
  • Android应用开发进阶，flutter页面跳转防止页面重复刷新
                        m0_64604842
程序员面试android移动开发
                        
    第三章通过Google官方的架构示例项目To-Do，详细介绍了Android的应用架构，包括MVP，MVP-Clean，MVP-Dagger，MVP-RxJava，MVVM-DataBinding，MVVM-Live。第四章介绍了实战项目AndroidPlus，AndroidPlus是一个专注于Andriod领域的知识问答与分享平台，遵循MaterialDesign，使用了MVP-Dagger架构
    
                    
    • 
                    
  • LiveData 迁移到 Kotlin Flow详解
                        xiangzhihong8
深入Android应用开发kotlin开发语言android
                        
    LiveData，是Android2017推出的一个东西，配合MVVM使用。观察者模式，的确简化了我们的工作方式，但RxJava等选项，对于当时的初学者来说实在是太复杂了。因此ArchitectureComponents团队创建了LiveData：这是个非常“有主见的”可观察数据持有者类，并且是专门为Android设计的。它保持简单明了，这让它易于上手，建议是将RxJava用于更复杂的响应流案例，
    
                    
    • 
                    
  • Android Kotlin 基于RxJava的简单封装
                        水天滑稽天照八野滑稽石

                        
    前言使用RxJava无非就是为了开异步任务，所以这儿简单按照个人使用习惯封装了下使用方法单个任务的异步valtask=Task.singleTask{//需要异步进行的任务}.success{//成功回调（这里是UI线程了）}.error{//失败回调（这里是UI线程了）}.interrupted{//被打断回调（这里是UI线程了）}.start()task.cancel()带有进度条的异步val
    
                    
    • 
                                
  • web前段跨域nginx代理配置
                                    刘正强
nginxcmsWeb
                                    
    nginx代理配置可参考server部分 
 
server { 
        listen       80; 
        server_name  localhost; 
 

    
                                
    • 
                                
  • spring学习笔记
                                    caoyong
spring
                                    
    一、概述 
    a>、核心技术 : IOC与AOP 
 b>、开发为什么需要面向接口而不是实现 
     接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 
 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式) 
    
                                
    • 
                                
  • Eclipse打开workspace提示工作空间不可用
                                    0624chenhong
eclipse
                                    
    做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 
1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。 
解决办法，删掉.fileTableLock文件，重
    
                                
    • 
                                
  • Javascript 面向对面写法的必要性？
                                    一炮送你回车库
JavaScript
                                    
    现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 
这是javascript层的mvc框架哦,不是j2ee的mvc框架 
  
我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
    
                                
    • 
                                
  • js array对象的迭代方法
                                    换个号韩国红果果
array
                                    
    1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素 
使用该函数  return 语句失效 
 

function square(num) {
print(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);
 
2.every 该方法接受一个返回值为布尔类型
    
                                
    • 
                                
  • 对Hibernate缓存机制的理解
                                    归来朝歌
session一级缓存对象持久化
                                    
    在hibernate中session一级缓存机制中，有这么一种情况： 
问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 
session.save()方法，在提交事务后，会出现这样的情况： 
1：在数据库中有默认属性的字段的值为空 
2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？ 
通过调试后解决方案如下： 
对于问题一，如你在数据库里设置了
    
                                
    • 
                                
  • WebService调用错误合集
                                    darkranger
webservice
                                    
     Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton   
调用接口出错， 
一个简单的WebService 
import org.apache.axis.client.Call;import org.apache.axis.client.Service; 
首先必不可
    
                                
    • 
                                
  • JSP和Servlet的中文乱码处理
                                    aijuans
Java Web
                                    
    JSP和Servlet的中文乱码处理 
前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。 
一、表单提交时出现乱码： 
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
    
                                
    • 
                                
  • 面试经典六问
                                    atongyeye
工作面试
                                    
    题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。 
 
以下是人事了解应聘者情况的最典型的六个问题： 
 
 
1 简单自我介绍  
 
关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。 
 
我的回答：(针对技术面试回答，如果是人事面试，可以就掌
    
                                
    • 
                                
  • contentResolver.query()参数详解
                                    百合不是茶
androidquery()详解
                                    
    收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名 
一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。    
[java]  
view plain 
copy       
 
 public void fetchAllContacts() {   
    
    
                                
    • 
                                
  • ora-00054:resource busy and acquire with nowait specified解决方法
                                    bijian1013
oracle数据库killnowait
                                    
            当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 
1.下面的语句
    
                                
    • 
                                
  • web 开发乱码
                                    征客丶
springWeb
                                    
    以下前端都是 utf-8 字符集编码 
 
一、后台接收 
1.1、 get 请求乱码 
get 请求中，请求参数在请求头中； 
乱码解决方法： 
a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 
 
1.2、post 请求乱码 
post 请求中，请求参数分两部份， 
1.2.1、url？参数，
    
                                
    • 
                                
  • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式
                                    bit1129
spark
                                    
    Spark SQL数据源和表的Schema 
 
  case class  
  apply schema  
  parquet  
  json  
 JSON数据源 准备源数据 
{"name":"Jack", "age": 12, "addr":{"city":"beijing&
    
                                
    • 
                                
  • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss
                                    BlueSkator
-Xss-Xmn-Xms-Xmx
                                    
      
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： 
 
 java -Xmx355
    
                                
    • 
                                
  • jqGrid 各种参数 详解(转帖)
                                    BreakingBad
jqGrid
                                    
      
jqGrid 各种参数 详解   分类： 
源代码分享 
个人随笔请勿参考 
解决开发问题 2012-05-09 20:29   84282人阅读   
评论(22)   
收藏   
举报   
jquery 
服务器 
parameters 
function 
ajax 
string      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-代理模式-Proxy
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 下面
    
                                
    • 
                                
  • 应用升级iOS8中遇到的一些问题
                                    chenhbc
ios8升级iOS8
                                    
    1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 
-(void)viewWillAppear:(BOOL)animated 
 中写的，最终的解决办法是把判断写在 
-(void
    
                                
    • 
                                
  • 工作流与自组织的关系？
                                    comsci
设计模式工作
                                    
      目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？ 
 
  这里有篇论文，摘要是：“针对网格中的服务
    
                                
    • 
                                
  • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX
                                    daizj
oracle
                                    
    insert提示IGNORE_ROW_ON_DUPKEY_INDEX 
 
转自：http://space.itpub.net/18922393/viewspace-752123 
 
在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
    
                                
    • 
                                
  • 二叉树:堆
                                    dieslrae
二叉树
                                    
        这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单: 
    一个节点的父节点下标为: (当前下标 - 1)/2 
    一个节点的左节点下标为: 当前下标 * 2 + 1 
  &
    
                                
    • 
                                
  • C语言学习八结构体
                                    dcj3sjt126com
c
                                    
    为什么需要结构体，看代码 
# include <stdio.h>

struct Student	//定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量
{
	int age;
	float score;
	char sex;
}

int main(void)
{
	struct Student st = {80, 66.6,
    
                                
    • 
                                
  • centos安装golang
                                    dcj3sjt126com
centos
                                    
    #在国内镜像下载二进制包 
wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz 
tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz 
  
#把golang的bin目录加入全局环境变量 
cat >>/etc/profile<
    
                                
    • 
                                
  • 10.性能优化-监控-MySQL慢查询
                                    frank1234
性能优化MySQL慢查询
                                    
    1.记录慢查询配置 
show variables where variable_name like 'slow%' ; --查看默认日志路径 
查询结果：--不用的机器可能不同 
slow_query_log_file=/var/lib/mysql/centos-slow.log 
 
修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
    
                                
    • 
                                
  • Java父类取得子类类名
                                    happyqing
javathis父类子类类名
                                    
      
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！ 
  
package com.urthinker.module.test;

import org.junit.Test;

abstract class BaseDao<T> {
	public void 
    
                                
    • 
                                
  • Spring3.2新注解@ControllerAdvice
                                    jinnianshilongnian
@Controller
                                    
    @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现： 
  
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Co
    
                                
    • 
                                
  • Java spring mvc多数据源配置
                                    liuxihope
spring
                                    
    转自：http://www.itpub.net/thread-1906608-1-1.html 
 
 
1、首先配置两个数据库 
 
<bean id="dataSourceA"         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
    
                                
    • 
                                
  • 第12章 Ajax（下）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BW / Universe Mappings
                                    blueoxygen
BO
                                    
          
BW Element    
OLAP Universe Element      
Cube  Dimension    
Class      
Charateristic    
A class with dimension and detail objects (Detail objects for key and desription)      
Hi
    
                                
    • 
                                
  • Java开发熟手该当心的11个错误
                                    tomcat_oracle
java多线程工作单元测试
                                    
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    
                                
    • 
                                
  • 推行国产操作系统的优劣
                                    yananay
windowslinux国产操作系统
                                    
    最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？ 
 
先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
    
                                
    •