spilledyear
spilledyear

RxJava

观察者模式和回调机制

基本使用

@Test
public void test01() {
    Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter observableEmitter) throws Exception {
            log.info("可以在这里触发消费者的方法");

            observableEmitter.onNext("onNext方法被调用");
            observableEmitter.onComplete();
        }
    }).subscribe(new Observer() {

        @Override
        public void onSubscribe(Disposable disposable) {
            log.info("Observable调用subscribe方法时会触发这个onSubscribe方法");
        }

        @Override
        public void onNext(Object o) {
            log.info(o.toString());
        }

        @Override
        public void onError(Throwable throwable) {
            log.info("onError");
        }

        @Override
        public void onComplete() {
            log.info("onComplete方法被调用");
        }
    });
}
 
 
输出结果如下
 
 
Observable调用subscribe方法时会触发这个onSubscribe方法
可以在这里触发消费者的方法
onNext方法被调用
onComplete方法被调用

 
 
源码分析
 
 
Observable#create
 
 
public static  Observable create(ObservableOnSubscribe source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}

 
 
ObservableOnSubscribe
 
 
为订阅的每个观察者调用
 
 
public interface ObservableOnSubscribe {

    /**
     * Called for each Observer that subscribes.
     * @param emitter the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(@NonNull ObservableEmitter emitter) throws Exception;
}

 
 
ObservableCreate
 
 
实现了Observable接口
 
 
public final class ObservableCreate extends Observable {
    final ObservableOnSubscribe source;

    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }

    ......
}

 
 
RxJavaPlugins.onAssembly
 
 
这里的source就是ObservableCreate，先不分析 f != null的情况， 直接返回source
 
 
public static  Observable onAssembly(@NonNull Observable source) {
    Function f = onObservableAssembly;
    if (f != null) {
        return apply(f, source);
    }
    return source;
}

 
 
Observable的create方法，返回了一个ObservableCreate对象，ObservableCreate内部持有ObservableOnSubscribe实例
 
 
 
 
上面分析的是create方法，接下分析Observable的subscribe方法
 接收一个Observer对象，这里指的是代码中的匿名内部类
 
 
public final void subscribe(Observer observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        // 返回observer
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

        // 调用ObservableCreate的subscribeActual方法
        subscribeActual(observer);
    } catch (NullPointerException e) {
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}

 
 
RxJavaPlugins.onSubscribe
 
 
不分享f != null情况，直接返回Observer
 
 
public static  Observer onSubscribe(@NonNull Observable source, @NonNull Observer observer) {
    BiFunction f = onObservableSubscribe;
    if (f != null) {
        return apply(f, source, observer);
    }
    return observer;
}

 
 
ObservableCreate#subscribeActual
 
 
@Override
protected void subscribeActual(Observer observer) {
    // 将 observer 包装成 CreateEmitter
    CreateEmitter parent = new CreateEmitter(observer);

    // 调用 observer的 onSubscribe方法
    observer.onSubscribe(parent);

    try {
        // 调用ObservableOnSubscribe的subscribe方法，前面说过 ObservableCreate 持有一个ObservableOnSubscribe实例，就是create方法传进来的匿名类
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

 
 
CreateEmitter
 
 
ObservableOnSubscribe的subscribe方法，调用CreateEmitter的相关方法，本质上是调用 Observer 的相关方法
 
 
static final class CreateEmitter extends AtomicReference implements ObservableEmitter, Disposable {
    private static final long serialVersionUID = -3434801548987643227L;

    final Observer observer;

    CreateEmitter(Observer observer) {
        this.observer = observer;
    }

    @Override
    public void onNext(T t) {
        if (t == null) {
            onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
            return;
        }
        if (!isDisposed()) {
            observer.onNext(t);
        }
    }

    @Override
    public void onError(Throwable t) {
        if (!tryOnError(t)) {
            RxJavaPlugins.onError(t);
        }
    }

    @Override
    public boolean tryOnError(Throwable t) {
        if (t == null) {
            t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
        }
        if (!isDisposed()) {
            try {
                observer.onError(t);
            } finally {
                dispose();
            }
            return true;
        }
        return false;
    }

    @Override
    public void onComplete() {
        if (!isDisposed()) {
            try {
                observer.onComplete();
            } finally {
                dispose();
            }
        }
    }
}

 
 
上面是基本版的，下面来一个简便快捷版的
 
 
@Test
public void test02(){
    Observable.just("呵呵").subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(String s) {
            log.info(s);
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    });
}

 
 
输出结果
 
 
呵呵

 
 
Observable#just
 
 
本质上并没有变化，只不过ObservableCreate换成了ObservableJust
 
 
public static  Observable just(T item) {
    ObjectHelper.requireNonNull(item, "The item is null");
    return RxJavaPlugins.onAssembly(new ObservableJust(item));
}

 
 
ObservableJust
 
 
这个地方好像是有一些区别，之前是触发ObservableOnSubscribe的subscribe方法，然后调用CreateEmitter的相关方法，本质上是调用 Observer 的相关方法。不过这里
 并没有ObservableOnSubscribe相关概念，而是多了一个ScalarDisposable
 
 
public final class ObservableJust extends Observable implements ScalarCallable {

    private final T value;
    public ObservableJust(final T value) {
        this.value = value;
    }

    @Override
    protected void subscribeActual(Observer observer) {
        ScalarDisposable sd = new ScalarDisposable(observer, value);
        // 先调用调用Observer的onSubscribe方法
        observer.onSubscribe(sd);
        sd.run();
    }
    ......
}

 
 
ScalarDisposable
 
 
继承了AtomicInteger，run方法中调用了observer的onNext和onComplete方法
 
 
public static final class ScalarDisposable extends AtomicInteger implements QueueDisposable, Runnable {
    static final int START = 0;
    static final int FUSED = 1;
    static final int ON_NEXT = 2;
    static final int ON_COMPLETE = 3;

    public ScalarDisposable(Observer observer, T value) {
        this.observer = observer;
        this.value = value;
    }

    @Override
    public void run() {
        if (get() == START && compareAndSet(START, ON_NEXT)) {
            observer.onNext(value);
            if (get() == ON_NEXT) {
                lazySet(ON_COMPLETE);
                observer.onComplete();
            }
        }
    }
}


 
 
背压
 
 
@Test
public void test03() {
    Flowable.create(new FlowableOnSubscribe() {
        @Override
        public void subscribe(FlowableEmitter emitter) throws Exception {
            if (!emitter.isCancelled()) {
                emitter.onNext("onNext 1");
                emitter.onNext("onNext 2");
                emitter.onNext("onNext 3");
                emitter.onComplete();
            }
        }
    }, DROP).subscribe(new Subscriber() {
        @Override
        public void onSubscribe(Subscription subscription) {
            subscription.request(2L);
            log.info("背压订阅");
        }

        @Override
        public void onNext(String s) {
            log.info(s);
        }

        @Override
        public void onError(Throwable e) {
        }

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

 
 
输出结果
 
 
背压订阅
onNext 1
onNext 2

 
 
在subscribe方法里面调用了三次onNext方法，但是控制台只打印了两次，说明被限制了。注意onSubscribe方法中的subscription.request(2L)
 
 
原理分析
 
 
基本上和无背压版本的类似，不过这里的create方法传入了两个参数，一个是FlowableOnSubscribe，另一个是一个枚举类型，暂将它理解成背压策略
 
 
Flowable#create
 
 
public static  Flowable create(FlowableOnSubscribe source, BackpressureStrategy mode) {
    ObjectHelper.requireNonNull(source, "source is null");
    ObjectHelper.requireNonNull(mode, "mode is null");
    return RxJavaPlugins.onAssembly(new FlowableCreate(source, mode));
}

 
 
FlowableCreate
 
 
public final class FlowableCreate extends Flowable {

    final FlowableOnSubscribe source;

    final BackpressureStrategy backpressure;

    public FlowableCreate(FlowableOnSubscribe source, BackpressureStrategy backpressure) {
        this.source = source;
        this.backpressure = backpressure;
    }

    @Override
    public void subscribeActual(Subscriber t) {
        BaseEmitter emitter;

        switch (backpressure) {
            case MISSING: {
                emitter = new MissingEmitter(t);
                break;
            }
            case ERROR: {
                emitter = new ErrorAsyncEmitter(t);
                break;
            }
            case DROP: {
                emitter = new DropAsyncEmitter(t);
                break;
            }
            case LATEST: {
                emitter = new LatestAsyncEmitter(t);
                break;
            }
            default: {
                emitter = new BufferAsyncEmitter(t, bufferSize());
                break;
            }
        }

        t.onSubscribe(emitter);
        try {
            source.subscribe(emitter);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            emitter.onError(ex);
        }
    }
}

 
 
根据传进来的参数，这里会使用的DropAsyncEmitter
 
 
DropAsyncEmitter
 
 
继承关系如下
 
 
 
 
 
  
 
   
 
    RxJava_第1张图片 
   
 
  
 
  
 
 
 
 
t.onSubscribe(emitter)也就是匿名内部类的onSubscribe方法
 
 
public void onSubscribe(Subscription subscription) {
   subscription.request(2L);
   log.info("背压订阅");
}

 
 
然后调用BaseEmitter的request方法，BaseEmitter实现了Subscription接口
 
 
BaseEmitter#request
 
 
@Override
public final void request(long n) {
    // 校验n是否大于0，大于0返回true，小于0返回false
    if (SubscriptionHelper.validate(n)) {
        // 设置 Emitter的值 = Emitter的值 + n
        BackpressureHelper.add(this, n);
        // 空实现
        onRequested();
    }
}

 
 
接下来调用FlowableOnSubscribe的subscrib方法，FlowableOnSubscribe中的subscribe即匿名内部类中的subscribe方法会，
 先调用调用BaseEmitter中的相关方法，BaseEmitter会根据value值选择是否调用Subscriber的相关方法(onNext、onComplete、onError)
 
 
操作符原理
 
 
操作符的核心原理就是包一层，类似于代理，这里以map为例
 
 
@Test
public void test04() {
    Flowable.create(emitter -> emitter.onNext("onNext 1"), DROP)
            .map(v -> v + " MAP")
            .subscribe(System.out::println);
}

 
 
Flowable#map
 
 
这里返回的是FlowableMap， 创建FlowableMap时以 当前Flowable实例 和 map操作符对应的逻辑函数Function 为参数。即 FlowableMap 持有上一层的Flowable实例
 
 
public final  Flowable map(Function mapper) {
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new FlowableMap(this, mapper));
}

 
 
FlowableMap
 
 
public final class FlowableMap extends AbstractFlowableWithUpstream {
    final Function mapper;
    public FlowableMap(Flowable source, Function mapper) {
        super(source);
        this.mapper = mapper;
    }

    @Override
    protected void subscribeActual(Subscriber s) {
        if (s instanceof ConditionalSubscriber) {
            source.subscribe(new MapConditionalSubscriber((ConditionalSubscriber)s, mapper));
        } else {
            source.subscribe(new MapSubscriber(s, mapper));
        }
    }

    static final class MapSubscriber extends BasicFuseableSubscriber {
        final Function mapper;

        MapSubscriber(Subscriber actual, Function mapper) {
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                downstream.onNext(null);
                return;
            }
            U v;
            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }

            // 调用上一层的 onNext 方法， 这里指的是 匿名函数 Subscriber 的onNext方法，如果连接了多个操作符，就是指向上一个操作符的onNext方法
            downstream.onNext(v);
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public U poll() throws Exception {
            T t = qs.poll();
            return t != null ? ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
        }
    }
}

 
 
总结一下
 
 
Flowable.create  =>     传入 FlowableOnSubscribe， 返回 FlowableCreate
.map =>       以create返回的FlowableCreate为参数，构建一个FlowableMap并返回
.subscribe =>     以原生的Subscriber作为参数调用Flowable的subscribe方法，然后再对原生的Subscriber做一层包装作为参数，调用FlowableMap的subscribeActual，
然后再调用FlowableCreate的subscribe方法(即lowable的subscribe方法)，然后再以上一层包装的Subscriber作为参数调用FlowableCreate的subscribeActual方法，
更加背压策略，以包装的Subscriber的作为参数创建BaseEmitter对象，调用包装的Subscriber的onSubscribe方法。以BaseEmitter为参数调用FlowableOnSubscribe的subscribe
方法，即调用BaseEmitter的相关方法(onNext......)，但这个其实本质上还是调用包装的Subscriber的相关方法(onNext......)。在包装的Subscriber内部，执行map中的相关
逻辑修改值，然后再以新值作为参数，调用原生的Subscriber的相关方法。

也就是说，有多个个操作符，就会包装多少层

 
 
线程切换
 
 
subscribeOn
 
 
 
  
指定在哪个线程上发射数据
 
 
 
 
@Test
public void test05() throws InterruptedException {
    Flowable.create(emitter -> {
        log.info("发射数据的线程 => {}", Thread.currentThread().getName());
        emitter.onNext("DD");
    }, BUFFER)

            // 指定在哪个线程上发射数据
            .subscribeOn(Schedulers.io())
            // 指定接收数据后在哪个线程上执行
            .observeOn(Schedulers.newThread())

            .subscribe(new Subscriber() {
                           @Override
                           public void onSubscribe(Subscription subscription) {
                               log.info("onSubscribe  Thread => {}", Thread.currentThread().getName());
                           }

                           @Override
                           public void onNext(Object s) {
                               log.info("onNext  Data => {},  Thread => {}", s, Thread.currentThread().getName());
                           }

                           @Override
                           public void onError(Throwable throwable) {
                               log.info("onError  Thread => {}", Thread.currentThread().getName());
                           }

                           @Override
                           public void onComplete() {
                               log.info("onComplete  Thread => {}", Thread.currentThread().getName());
                           }
                       }
            );

    Thread.sleep(3000);
}
 
 
     
  
  1. subscribeOn方法返回一个 FlowableSubscribeOn 对象，创建 FlowableSubscribeOn 的时候以 FlowableCreate 和 scheduler 作为入参；
    2.  
  
  2. 在 FlowableSubscribeOn.subscribe 方法内部，先创建一个 Scheduler.Worker 对象，也就是实际的线程调度者，这里的Scheduler为IoScheduler，所以对应的Worker为 EventLoopWorker；然后将入参 Subscriber 封装成一个 SubscribeOnSubscriber 对象；然后在主线程上调用 Subscriber.onSubscribe 方法；最后以 SubscribeOnSubscriber 为入参，调用 Worker.schedule 方法；
    3.  
  
  3. 在 EventLoopWorker.schedule 方法内部调用 NewThreadWorker.scheduleActual 方法；
    4.  
  
  4. 在 NewThreadWorker.scheduleActual 方法内部将入参 SubscribeOnSubscriber 转换成 ScheduledRunnable ，然后以 ScheduledRunnable 为入参，调用 ScheduledExecutorService.submit 方法；
     最终 ScheduledExecutorService.submit 方法调用顺序如下
    5.  
 
 
 
ScheduledRunnable.call => 
ScheduledRunnable.run =>
SubscribeOnSubscriber.run =>
Flowable.subscribe 这里指 FlowableCreate

 
 
observeOn
 
 
 
  
指定接收数据后在哪个线程上执行
 
 
 
 
     
  
  1. observeOn方法返回一个 FlowableObserveOn 对象，创建 FlowableObserveOn 的时候以 FlowableCreate 和 scheduler 作为入参；
    2.  
  
  2. 在 FlowableObserveOn.subscribeActual 方法内部，先创建一个 Scheduler.Worker 对象，也就是实际的线程调度者，这里的Scheduler为NewThreadScheduler，所以对应的Worker为 NewThreadWorker；然后将入参 Subscriber 封装成一个 ObserveOnSubscriber 对象；
    3.  
  
  3. Subscriber.onSubscribe 方法在主线程上执行；
    4.  
  
  4. 在调用 Subscriber.onNext 等相关方法的时候，通过 worker 进行调度；
    5.  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava)

        

            

                
    
                    
  • 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从零开始搭建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
    
                    
    • 
                    
  • 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
    
                    
    • 
                    
  • 关于 RxJava2CallAdapterFactory
                        Gubr

                        
    今天在看谷歌最新的框架的时候发现有一段有些疑问的代码publicLiveData>loadUser(Stringlogin){returnnewNetworkBoundResource(appExecutors){//...@NonNull@OverrideprotectedLiveData>createCall(){//这里直接返回并没有像我们常写的那样需要拼接以下代码//subscribeOn
    
                    
    • 
                    
  • Rxjava3文档级教程链接
                        logan.gan
android
                        
    许进进的博客地址：https://blog.csdn.net/LucasXu01Rxjava3文档级教程一：介绍和基本使用https://blog.csdn.net/LucasXu01/article/details/105279367Rxjava3文档级教程二：操作符全解https://blog.csdn.net/LucasXu01/article/details/105312731Rxjava
    
                    
    • 
                                
  • 关于旗正规则引擎规则中的上传和下载问题
                                    何必如此
文件下载压缩jsp文件上传
                                    
    文件的上传下载都是数据流的输入输出，大致流程都是一样的。 
一、文件打包下载 
1.文件写入压缩包 
string mainPath="D:\upload\";     下载路径 
 
string tmpfileName=jar.zip;        &n
    
                                
    • 
                                
  • 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析
                                    bit1129
Stream
                                    
      
以如下代码为例（SocketInputDStream）： 
Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
    
                                
    • 
                                
  • spark master web ui 端口8080被占用解决方法
                                    daizj
8080端口占用sparkmaster web ui
                                    
    spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法： 
  
1、cd SPARK_HOME/sbin 
  
2、vi start-master.sh 
  
  
3、定位到下面部分
    
                                
    • 
                                
  • oracle_执行计划_谓词信息和数据获取
                                    周凡杨
oracle执行计划
                                    
      
oracle_执行计划_谓词信息和数据获取(上) 
一：简要说明  
在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 
简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
    
                                
    • 
                                
  • spring中datasource配置
                                    g21121
dataSource
                                    
    datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： 
http://baike.baidu.com/view/920062.htm 
  
	<!-- spring加载资源文件 -->
	<bean name="propertiesConfig"
		class="org.springframework.b
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（三）
                                    老A不折腾
finereportFAQ报表软件
                                    
    这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
1、repeated column width is largerthan paper width： 
这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
    
                                
    • 
                                
  • mysql 用户管理
                                    墙头上一根草
linuxmysqluser
                                    
    1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
    
                                
    • 
                                
  • 关于使用Spring导致c3p0数据库死锁问题
                                    aijuans
springSpring 入门Spring 实例Spring3Spring 教程
                                    
    这个问题我实在是为整个 springsource 的员工蒙羞  
如果大家使用 spring 控制事务，使用 Open Session In View 模式，  
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
    
                                
    • 
                                
  • 百度词库联想
                                    annan211
百度
                                    
    

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>RunJS</title&g
    
                                
    • 
                                
  • int数据与byte之间的相互转换实现代码
                                    百合不是茶
位移int转bytebyte转int基本数据类型的实现
                                    
    在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来; 
  
主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029 
  
int转byte; 
  
byte转int; 
  
/**
 * 字节转成int,int转成字节
 * @author Administrator
 *

    
                                
    • 
                                
  • 简单模拟实现数据库连接池
                                    bijian1013
javathreadjava多线程简单模拟实现数据库连接池
                                    
    简单模拟实现数据库连接池 
实例1： 
package com.bijian.thread;

public class DB {

	//private static final int MAX_COUNT = 10;
	private static final DB instance = new DB();

	private int count = 0;
	private i
    
                                
    • 
                                
  • 一种基于Weblogic容器的鉴权设计
                                    bijian1013
javaweblogic
                                    
            服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： 
String  vuser_id = "weblogic";
String  vuse
    
                                
    • 
                                
  • 【RPC框架Hessian二】Hessian 对象序列化和反序列化
                                    bit1129
hessian
                                    
     任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。 
  1. 定义三个POJO 
   Person类 
package com.tom.hes
    
                                
    • 
                                
  • 【Hadoop十四】Hadoop提供的脚本的功能
                                    bit1129
hadoop
                                    
    1. hadoop-daemon.sh 
1.1 启动HDFS 
./hadoop-daemon.sh start namenode
./hadoop-daemon.sh start datanode 
 通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
    
                                
    • 
                                
  • 中国互联网走在“灰度”上
                                    ronin47
管理 灰度
                                    
    中国互联网走在“灰度”上（转） 
文/孕峰 
  
第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。 
  
灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
    
                                
    • 
                                
  • java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
                                    bylijinnan
java
                                    
    

public class PrintMatrixClockwisely {

	/**
	 * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
例如：如果输入如下矩阵：

1              2             3            4
5              6             7            8
9 
    
                                
    • 
                                
  • mongoDB 用户管理
                                    开窍的石头
mongoDB用户管理
                                    
      1:添加用户 
   第一次设置用户需要进入admin数据库下设置超级用户（use admin） 
  
   db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]}); 
   第一个参数用户的名字 
   第二个参数
    
                                
    • 
                                
  • [游戏与生活]玩暗黑破坏神3的一些问题
                                    comsci
生活
                                    
        暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意 
 
 
     玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天 
 
     结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气 
 
  &nb
    
                                
    • 
                                
  • java 二维数组如何存入数据库
                                    cuiyadll
java
                                    
    using System;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
 
namespace WindowsFormsApplication1
{
    
    
                                
    • 
                                
  • 本地事务和全局事务Local Transaction and Global Transaction(JTA)
                                    darrenzhu
javaspringlocalglobaltransaction
                                    
    Configuring Spring and JTA without full Java EE 
 
http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ 
 
Spring doc -Transaction Management 
 
http://docs.spring.io/spri
    
                                
    • 
                                
  • Linux命令之alias - 设置命令的别名，让 Linux 命令更简练
                                    dcj3sjt126com
linuxalias
                                    
    用途说明 
设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。 
  常用参数 
格式：alias 
格式：ali
    
                                
    • 
                                
  • yii2 restful web服务[格式响应]
                                    dcj3sjt126com
PHPyii2
                                    
    响应格式 
当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 
 
 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 
 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
    
                                
    • 
                                
  • MongoDB索引调优（2）——[十]
                                    eksliang
mongodbMongoDB索引优化
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述 
      上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档 
    可以在嵌套文档的键上建立索引，方式与正常
    
                                
    • 
                                
  • 当滑动到顶部和底部时，实现Item的分离效果的ListView
                                    gundumw100
android
                                    
    拉动ListView，Item之间的间距会变大，释放后恢复原样； 
 

package cn.tangdada.tangbang.widget;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import andr
    
                                
    • 
                                
  • 程序员用HTML5制作的爱心树表白动画
                                    ini
JavaScriptjqueryWebhtml5css
                                    
    体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" >
<ti
    
                                
    • 
                                
  • 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版
                                    kakajw
ThinkPad预装改装windows 7windows 8
                                    
      
该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 
该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！ 
  
缘由 
小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
    
                                
    • 
                                
  • Nginx学习笔记
                                    mcj8089
nginx
                                    
    一、安装nginx                      1、在nginx官方网站下载一个包，下载地址是：  
http://nginx.org/download/nginx-1.4.2.tar.gz  
     2、WinSCP(ftp上传工
    
                                
    • 
                                
  • mongodb 聚合查询每天论坛链接点击次数
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    /* 18 */
{
    "_id" : ObjectId("5596414cbe4d73a327e50274"),
    "msgType" : "text",
    "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
    
                                
    • 
                                
  • java术语（PO/POJO/VO/BO/DAO/DTO）
                                    Luob.
DAOPOJODTOpoVO BO
                                    
    
PO(persistant object) 持久对象
在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作.

VO(value object) 值对象
通
    
                                
    • 
                                
  • 算法复杂度
                                    Wuaner
Algorithm
                                    
    Time Complexity & Big-O： 
 
http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o 
 
http://bigocheatsheet.com/ 
 
http://www.sitepoint.com/time-complexity-algorithms/ 
 
 

    
                                
    •