android 知识笔记

Android

在新技术不断涌现的浪潮里，除了学习吸收新的技术，还要学会追根溯源，深入底层，才能更加了解这门技术，而不仅仅站在象牙塔之外，只能看到事物的表象，仅仅皮毛而已。

学无止境！不进则退！

架构图

引用Google官网

Rxjava2

对其馋涎已久，却一直没有机会完全的了解，皆因各种原因中断，着实可惜。近来也是需要多学多看，所以将其重新拾起。

实例演示：

		//test1:支持java1.8的lambdas   
        Disposable hell_tom = Flowable.just("hell Tom").subscribe(System.out::println);
        //or
        Disposable hell_tom1 = Flowable.just("hell Tom").subscribe(new Consumer<String>() {
   
            @Override
            public void accept(String s) throws Exception {
   
                System.out.println("or:"+s);
            }
        });

观察者模式

Rxjava是以观察者模式为骨架的。因此有必要熟悉。

观察者模式定义了对象之间的一对多依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。

在这里，发生改变的对象称之为观察目标，而被通知的对象称之为观察者。一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，所以么可以根据需要增加和删除观察者，使得系统更易于扩展。所以观察者提供了一种对象设计，让主题和观察者之间以松耦合的方式结合。

观察者模式包含如下角色：

• Subject: 目标
• ConcreteSubject: 具体目标
• Observer: 观察者
• ConcreteObserver: 具体观察者

实例:

观察目标：

public abstract class Subject {
   
    /**
     * 用来保存注册的观察者对象
     */
    private    List<Observer> list = new ArrayList<Observer>();
    /**
     * 注册观察者对象
     * @param observer    观察者对象
     */
    public void attach(Observer observer){
   
        
        list.add(observer);
        System.out.println("Attached an observer");
    }
    /**
     * 删除观察者对象
     * @param observer    观察者对象
     */
    public void detach(Observer observer){
   
        
        list.remove(observer);
    }
    /**
     * 通知所有注册的观察者对象
     */
    public void nodifyObservers(String newState){
   
        
        for(Observer observer : list){
   
            observer.update(newState);
        }
    }
}

具体观察目标：

public class ConcreteSubject extends Subject{
   
    
    private String state;
    
    public String getState() {
   
        return state;
    }

    public void change(String newState){
   
        state = newState;
        System.out.println("主题状态为：" + state);
        //状态发生改变，通知各个观察者
        this.nodifyObservers(state);
    }
}

观察者:

public interface Observer {
   
    /**
     * 更新接口
     * @param state    更新的状态
     */
    public void update(String state);
}

具体观察者：

public class ConcreteObserver implements Observer {
   
    //观察者的状态
    private String observerState;
    
    @Override
    public void update(String state) {
   
        /**
         * 更新观察者的状态，使其与目标的状态保持一致
         */
        observerState = state;
        System.out.println("状态为："+observerState);
    }

}

客户端类

public class Client {
   

    public static void main(String[] args) {
   
        //创建主题对象
        ConcreteSubject subject = new ConcreteSubject();
        //创建观察者对象
        Observer observer = new ConcreteObserver();
        //将观察者对象登记到主题对象上
        subject.attach(observer);
        //改变主题对象的状态
        subject.change("new state");
    }

}

在运行时，这个客户端首先创建了具体主题类的实例，以及一个观察者对象。然后，它调用主题对象的attach()方法，将这个观察者对象向主题对象登记，也就是将它加入到主题对象的聚集中去。

这时，客户端调用主题的change()方法，改变了主题对象的内部状态。主题对象在状态发生变化时，调用超类的notifyObservers()方法，通知所有登记过的观察者对象。

一个观察目标，对应可以多个的观察者。
1…N的关系。

本段引用

一些术语

1. Upstream, downstream ：上流、下流

2. Objects in motion ：

3. Backpressure ：背压

In RxJava, the dedicated Flowable class is designated to support backpressure and Observable is dedicated for the non-backpressured operations (short sequences, GUI interactions, etc.). The other types, Single, Maybe and Completable don’t support backpressure nor should they; there is always room to store one item temporarily.

在RxJava中，专用的Flowable类被指定为支持反压力，Observable则用于非反压力操作(短序列、GUI交互等)。其他类型，单管、可能和可完井不支持反压力，也不应该支持;总有空间暂时存放一件物品。

4. Assembly time ：装配

5. Subscription time ：订阅

6. Runtime：运行时

		//术语说明
		//--Assembly time : 装配时
        Flowable<Integer> integerFlowable  = Flowable.range(1,5)
                .map(v -> v * v)
                .filter(v -> v % 3 == 0);
        //--Subscription time ：订阅时
        Disposable subscribe = integerFlowable.subscribe(System.out::println);
        
        //--Runtime : 运行时
        Disposable subscribe1 = Observable.create(emitter -> {
   
            while (!emitter.isDisposed()) {
   
                long time = System.currentTimeMillis();
                emitter.onNext(time);
                if (time % 2 != 0) {
   
                    //主动发出异常错误，不影响后面的数据处理
                    emitter.onError(new IllegalStateException("Odd millisecond!"));
                }

            }

        }).subscribe(System.out::println, Throwable::printStackTrace);

Simple background computation：简化的后台操作

RxJava的一个常见用例是在后台线程上运行一些计算、网络请求，并在UI线程上显示结果(或错误)

实例：

		//--Simple background computation:简化的后台操作
        Disposable subscribe2 = Flowable.fromCallable(() -> {
   
            Thread.