WuXiao_
WuXiao_

Rxjava

以下都是本人收集和总结的内容:

1. 什么是Rxjava

Rx含义

ReactiveX是Reactive Extensions的缩写，一般简写为Rx。微软给的定义是，Rx是一个函数库，让开发者可以利用可观察序列和LINQ风格查询操作符来编写异步和基于事件的程序，使用Rx，开发者可以用Observables表示异步数据流，用LINQ操作符查询异步数据流， 用Schedulers参数化异步数据流的并发处理，Rx可以这样定义：Rx = Observables + LINQ + Schedulers。

Rxjava含义

简单而言：RxJava就是一种用Java语言实现的响应式编程，来创建基于事件的异步程序

2. Rxjava理解与扩展（观察者模式）

简单概括就是，观察者（Observer）需要在被观察者(Observable)变化的一瞬间做出反应。

而两者通过注册（Register）或者订阅(Subscribe)的方式进行绑定。

Rxjava_第1张图片
观察者模式

其中这个Button就是被观察者（Observable），OnClickListener就是观察者（Observer），两者通过setOnClickListener达成订阅（Subscribe）关系，之后当Button产生OnClick事件的时候，会直接发送给OnClickListener，它做出相应的响应处理。

而RxJava的观察者模式呢，跟这个差不多，但是也有几点差别：

  • Observer与Observable是通过 subscribe() 来达成订阅关系。
  • RxJava中事件回调有三种：onNext() 、 onCompleted() 、 onError() 。
  • 如果一个Observerble没有任何的Observer，那么这个Observable是不会发出任何事件的。

关于RxJava的回调事件：

onNext()：基本事件。
onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。
onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
值得注意的是在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。如果在队列中调用了其中一个，就不应该再调用另一个。

好了，那我们也附一张图对比一下吧：


Rxjava_第2张图片
观察者模式

3. 如何实现RxJava

3.1创建Observer

在Java中，一想到要创建一个对象，我们马上就想要new一个。没错，这里我们也是要new一个Observer出来，其实就是实现Observer的接口，注意String是接收参数的类型：

//创建
Observer observer = new Observer() {
@Override 
 public void onNext(String s)  { 
     Log.i("onNext ---> ", "Item: " + s);
   }
 @Override 
public void onCompleted() {
     Log.i("onCompleted ---> ", "完成"); 
  } 
@Override 
public void onError(Throwable e) {
     Log.i("onError ---> ", e.toString()); 
  }
};

当然这里也要提另外一个接口：Subscriber ，它跟Observer接口几乎完全一样，只是多了两个方法，总结：

  • onStart(): 它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。

  • unsubscribe(): 用于取消订阅。在这个方法被调用后，Subscriber 将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed() 先判断一下状态。 要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

虽然多了两个方法，但是基本实现方式跟Observer是一样的，所以暂时可以不考虑两者的区别。不过值得注意的是

实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。

3.2创建Observable

与Observer不同的是，Observable是通过 create() 方法来创建的。注意String是发送参数的类型：

//创建
Observable observable = Observable.create(new  Observable.OnSubscribe() { 
  @Override 
  public void call(Subscriber subscriber) { 
        subscriber.onNext("Hello"); 
        subscriber.onNext("World");
        subscriber.onCompleted();
    }
});

3.3订阅（Subscribe）

在之前，我们创建了 Observable 和 Observer ，现在就需要用 subscribe() 方法来将它们连接起来，形成一种订阅关系：

//订阅
observable.subscribe(observer);

这里其实确实有点奇怪，为什么是Observable（被观察者）订阅了Observer（观察者）呢？其实我们想一想之前Button的点击事件：

Button.setOnClickListener(new View.OnClickListener())

Button是被观察者，OnClickListener是观察者，setOnClickListener是订阅。我们惊讶地发现，也是被观察者订阅了观察者，所以应该是一种流式API的设计吧，也没啥影响。

完整代码如下：

//创建Observable
Observable observable = Observable.create(new  Observable.OnSubscribe() { 
  @Override 
  public void call(Subscriber subscriber) { 
        subscriber.onNext("Hello"); 
        subscriber.onNext("World");
        subscriber.onCompleted();
    }
});

//创建Observe
Observer observer = new Observer() {
@Override 
 public void onNext(String s)  { 
     Log.i("onNext ---> ", "Item: " + s);
   }
 @Override 
public void onCompleted() {
     Log.i("onCompleted ---> ", "完成"); 
  } 
@Override 
public void onError(Throwable e) {
     Log.i("onError ---> ", e.toString()); 
  }
};

//订阅
observable.subscribe(observer);

运行的结果如下，可以看到Observable中发送的String已经被Observer接收并打印了出来：

运行结果

3.4线程控制——Scheduler

Scheduler是RxJava的精髓之一了。

在RxJava中，Scheduler相当于线程控制器，可以通过它来指定每一段代码运行的线程。
RxJava已经内置了几个Scheduler，总结：

  1. Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的Scheduler。

  2. Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。

  3. Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的Scheduler。行为模式和newThread()差不多，区别在于io()的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下io()比newThread()更有效率。不要把计算工作放在io()中，可以避免创建不必要的线程。

  4. Schedulers.computation(): 计算所使用的Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个Scheduler使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在computation()中，否则 I/O 操作的等待时间会浪费 CPU。

  5. AndroidSchedulers.mainThread()，Android专用线程，指定操作在主线程运行。

那我们如何切换线程呢？RxJava中提供了两个方法：subscribeOn() 和 observeOn() ，两者的不同点在于：

subscribeOn(): 指定subscribe()订阅所发生的线程，即 call() 执行的线程。或者叫做事件产生的线程。
observeOn(): 指定Observer所运行在的线程，即onNext()执行的线程。或者叫做事件消费的线程。

这里确实不好理解，没关系，下面我们在具体例子中观察现象。

//创建被观察者
Observable.create(new Observable.OnSubscribe() {
    /**
    * 复写call方法
    *
    * @param subscriber 观察者对象
    */
    @Override
    public void call(Subscriber subscriber) {
        //通过URL得到图片的Bitmap对象
        Bitmap bitmap = GetBitmapForURL.getBitmap(url);
        //回调观察者方法
        subscriber.onNext(bitmap);
        subscriber.onCompleted();
        Log.i(" call ---> ", "运行在 " + Thread.currentThread().getName() + " 线程");
    }
})
.subscribeOn(Schedulers.io()) // 指定subscribe()发生在IO线程
.observeOn(AndroidSchedulers.mainThread()) // 指定Subscriber的回调发生在UI线程
.subscribe(new Observer() {   //订阅观察者（其实是观察者订阅被观察者）

    @Override
    public void onNext(Bitmap bitmap) {
        mainImageView.setImageBitmap(bitmap);
        Log.i(" onNext ---> ", "运行在 " + Thread.currentThread().getName() + " 线程");
    }

    @Override
    public void onCompleted() {
        mainProgressBar.setVisibility(View.GONE);
        Log.i(" onCompleted ---> ", "完成");
    }

    @Override
    public void onError(Throwable e) {
        Log.e(" onError --->", e.toString());
    }
 });

现在来看一下运行的Log日志：

Log

可以看到，call方法（事件产生）执行在IO线程，而onNext方法（事件消费）执行在main线程。说明之前分析的是对的。

3.5操作符

所谓操作符（Operators），简单来说就是一种指令，表示需要执行什么样的操作。Rx中的每种编程语言实现都实现了一组操作符的集合。RxJava也不例外。

RxJava中有大量的操作符，比如创建操作符、变换操作符、过滤操作符等等，这些操作符要全部讲解完几乎是不可能也没必要的事情。所以我们只介绍常见的、有用的、重要的操作符。其他的如果用到直接到文档查找就行了。

下面就针对前篇文章的创建（create）来说明一下另外两种常见的创建操作符。

Observable.just()
首先给出定义：

Just操作符是创建一个将参数依次发送出来的Observable

具体一点来说就是， just() 中会接收1~9个参数，它会返回一个按照传入参数的顺序依次发送这些参数的Observable。

这样说可能还是不够清晰，所以画个图来看：

Rxjava_第3张图片
JUST流程图

从图中可以看出，其实就是依次发送单个数据，它的具体写法是这样的，非常简单：

Observable.just("Hello","world");
//其实就相当于依次调用：
//subscriber.onNext("Hello");
//subscriber.onNext("World");

但是这里要注意一点，如果你传递null给just，它会返回一个发送null值的Observable，而不是返回一个空Observable（完全不发送任何数据的Observable）。后面会讲到，如果需要空Observable应该使用 Empty 操作符。
现在来看完整的代码，代码本身很简单，注意看Log日志：

//创建Observable
Observable.just("Hello", "World", null) .subscribe(new Observer() {
  @Override 
  public void onNext(String s) {
     if (s == null) {
         Log.i("onNext ---> ", "null"); 
     }else {
         Log.i("onNext ---> ", s); 
     }
  } 
  @Override 
  public void onCompleted() { 
    Log.i("onCompleted ---> ", "完成"); 
  }
  @Override 
  public void onError(Throwable e) {
     Log.i("onError ---> ", "出错 --->" + e.toString()); 
  }
});
log

这里因为我们要打印字符串，所以不能为null，我就处理了一下，可以看到当发送 null 的时候，s确实等于null。

Observable.from()
尽管与just一样是创建操作符，但是from操作符稍微强大点。因为from操作符的作用是：

将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。

注意，这里不再是发送单个对象，而是直接发送一组对象。为了与just对比，也来画个图描述一下：

Rxjava_第4张图片
from流程图

它的具体写法是这样的，也非常简单：

String[] str = new String[]{"Hello", "World"};
//创建Observable
Observable.from(str);

4. 结合Rxjava源码深度学习

基础源码

实现RxJava的代码，这里我打上了Log日志，来看一下每个方法执行的顺序。

//创建Observable
Observable.create(new Observable.OnSubscribe() { 
  @Override 
  public void call(Subscriber subscriber) {
    subscriber.onNext("Hello"); 
    subscriber.onNext("World"); 
    subscriber.onCompleted();
    Log.i("执行顺序 ---> ", " call "); 
   }
 }).subscribe(new Observer() {
  @Override 
  public void onNext(String s) { 
    Log.i("onNext ---> ", s); 
    Log.i("执行顺序 ---> ", " subscribe onNext"); 
  } 
  @Override 
  public void onCompleted() {
     Log.i("onCompleted ---> ", "完成"); 
     Log.i("执行顺序 ---> ", " subscribe onCompleted"); 
  } 
  @Override 
  public void onError(Throwable e) { 
    Log.i("onError ---> ", "出错 --->" + e.toString()); 
  }
});

好了，来看一下Log日志：

Rxjava_第5张图片
执行log

从图中可以看到，subscribe方法先执行，等执行完成后再执行call方法。

好了，这就是结论。先在脑子里产生个印象，方便后面追溯。

4.1 create()

进入Observable的create()方法做了些什么：

public class Observable {
  .....省略代码......
 static final RxJavaObservableExecutionHook hook = 
              RxJavaPlugins.getInstance().getObservableExecutionHook();
  public static  Observable create(OnSubscribe f) {
     return new Observable(hook.onCreate(f));
  }
  .....省略代码......
}

直接返回一个 Observable，接下里继续看看它的构造函数：

public class Observable {
  .....省略代码......
  final OnSubscribe onSubscribe;
  protected Observable(OnSubscribe f) {
     this.onSubscribe = f;
  }
  .....省略代码......
}

返回继续查看 hook.onCreate(f) 。 hook 是什么鬼?

hook是一个代理对象, 仅仅用作调试的时候可以插入一些测试代码。如单元测试

static final RxJavaObservableExecutionHook hook = 
         RxJavaPlugins.getInstance().getObservableExecutionHook();

继续查看hook.onCreate(f) ：

public abstract class RxJavaObservableExecutionHook {
  .....省略代码......
  public  OnSubscribe onCreate(OnSubscribe f) {
     return f;
  }
  .....省略代码......
}

直接把OnSubscribe 这个对象返回了一下。

创建时做了三件事情：
返回了一个Observable（假设为ObservableA）
返回了一个OnSubscribe（假设为OnSubscribeA）
把返回的OnSubscribeA在ObservableA构造函数中保存为ObservableA的 .onSubscribe 属性

Rxjava_第6张图片
create创建流程图

create()方法创建了一个Observable，且在这个Observable中有个OnSubscribe。

所以就画个简图就如下图所示这样：

Rxjava_第7张图片
create简图

4.2 subscribe()

subscribe() 这个是将观察者（Observer）与被观察者(Observable)联系到一起的操作，也就是产生一种订阅(Subcribe)关系。

先查看源码：

public class Observable {
  .....省略代码......
  public final Subscription subscribe(final Observer observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber)observer);
        }
        return subscribe(new Subscriber() {

            @Override
            public void onCompleted() {
                observer.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onNext(T t) {
                observer.onNext(t);
            }

        });
    }
  .....省略代码......
}

实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。

在这里就能够看出，首先 if 中的语句意思是如果这个Observer已经是Subscriber类型，那就直接返回。如果不是的话 new了一个Subscriber ，再点进去看看：

public abstract class Subscriber implements Observer, Subscription {
   .....省略代码......
}

果然，它还是转成了Subscriber类型，刚好印证了之前的话。所以为了方便起见，之后文章中，所有的观察者（Observer）我都用Subscriber来代替。
继续看 subscribe 源码：

public class Observable {
   .....省略代码......
  static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
  final OnSubscribe onSubscribe;
  public final Subscription subscribe(Subscriber  subscriber) { 
    return Observable.subscribe(subscriber, this);
  }
  private static  Subscription subscribe(Subscriber subscriber, Observable observable) {
   .....省略代码......
    hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
   .....省略代码......
  }
   .....省略代码......
}

把一些暂时无关的代码省略掉来看，其实就是执行了一句 hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber); 。
而这个 hook.onSubscribeStart 方法再点进去看看：

public  OnSubscribe onSubscribeStart(Observable observableInstance, final OnSubscribe onSubscribe) {
    // pass through by default 
    return onSubscribe; 
}

可以看到，竟然直接返回了一个 onSubscribe ，由于之前说过这个hook没什么作用，直接删掉，那就等于整个 subscribe 做了一件事就是 onSubscribe.call(subscriber) ，当然这个call里面的参数subscriber是我们代码中传递进去的。

而onSubscribe在create源码解析中我们已经知道是新建 ObservableA 的一个属性，所以总结来说，subscribe()方法做的事情就是这样：

ObservableA.onSubscribe.call(subscriber);

而调用 call方法，就是调用传入的参数subscriber的onNext/onCompleted/onError方法。这就是全部的过程。依然画个图来说，图中省略了create中的创建步骤：

Rxjava_第8张图片
使用过程

结合图我们最后再顺一下思路：

首先创建过程也就是create()方法中创建了一个Observable，并有一个onSubscribe属性；
其次在订阅过程也就是subscribe()方法中，调用了create()方法中创建的Observable的onSubscribe属性的call方法；
最后这个call回调的就是代码中创建的Subscriber的onNext/onCompleted/onError方法。
之前Log日志可以看出，将onNext与onCompleted方法执行完后，call方法才结束。这也印证了call方法回调Subscriber的方法这一说。

4.3 map

4.3.1map使用流程

Observable.create(new Observable.OnSubscribe() {  
 @Override    
public void call(Subscriber subscriber) {        
  subscriber.onNext(1);        
  subscriber.onCompleted();    
}
}).map(new Func1() {   
   @Override  
   public String call(Integer integer) {       
       return String.valueOf(integer);    
  }
}).subscribe(new Subscriber() { 
   @Override    
public void onCompleted() {          
  }   
 @Override    
public void onError(Throwable e) {    
}    
@Override    
public void onNext(String s) {   
 }
});

并且回顾Observable.create过程

final OnSubscribe onSubscribe;
protected Observable(OnSubscribe f) {
        this.onSubscribe = f;
    }

public static  Observable create(OnSubscribe f) {
        return new Observable(hook.onCreate(f));
    }
 
 public  OnSubscribe onCreate(OnSubscribe f) { 
        //直接返回
        return f;
    }

4.3.2map源码

这里比较神奇的地方是这个 map，其实 map 实际上做了两件大事:

  • (第一件)new 了一个 变形函数, 保存在了 OperatorMap.transform 中
    查看map源码
public class Observable {
   public final  Observable map(Func1 func) {
        return lift(new OperatorMap(func));
    }
}

点击继续查看OperatorMap

public final class OperatorMap implements Operator {
 final Func1 transformer;

    public OperatorMap(Func1 transformer) {
        this.transformer = transformer;
    }
}

可以看出就是把new Func1

...省略代码...
map(new Func1() {   
   @Override  
   public String call(Integer integer) {       
       return String.valueOf(integer);    
  }
 ...省略代码...

保存在了transformer中去。

  • (第二件)new了一个新的 Observable. 这个 Observable 的构造函数中, 传入了一个新的 OnSubscribe. 整个 lift 函数的难点就在于这个 OnSubscribe 对象中. 我们仔细看一下它做了什么. 它其实也做了两件大事儿:
    进入lift函数
public class Observable {
 .....省略代码.......
 final OnSubscribe onSubscribe;
    protected Observable(OnSubscribe f) {
        this.onSubscribe = f;
    }
 
 public final  Observable lift(final Operator operator) {
        //新的Observable
        return new Observable(new OnSubscribe() {
            @Override
            public void call(Subscriber o) {
                try {
                  //hook.onLift(operator).call(o)创建了一个新的 Subscriber   
                        //(实际上是一个 proxy)并调用了OperatorMap中的Subscriber.onNext
                    Subscriber st = hook.onLift(operator).call(o);
                    try {
                        // new Subscriber created and being subscribed with so 'onStart' it
                        st.onStart();
                        onSubscribe.call(st);
                    } catch (Throwable e) {
                        // localized capture of errors rather than it skipping all operators 
                        // and ending up in the try/catch of the subscribe method which then
                        // prevents onErrorResumeNext and other similar approaches to error handling
                        Exceptions.throwIfFatal(e);
                        st.onError(e);
                    }
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    // if the lift function failed all we can do is pass the error to the final Subscriber
                    // as we don't have the operator available to us
                    o.onError(e);
                }
            }
        });
    }
    .....省略代码.......
}

继续进入OnSubscribe.call 函数中, 看一下源码:

public final class OperatorMap implements Operator {
....省略代码.....
  final Func1 transformer;
 @Override
    public Subscriber call(final Subscriber o) {
        return new Subscriber(o) {

            @Override
            public void onCompleted() {
                o.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                o.onError(e);
            }
          //函数transform执行对参数t进行变形然
                //后将变形结果转发给o.onNext
            @Override
            public void onNext(T t) {
                try {
                    o.onNext(transformer.call(t));
                } catch (Throwable e) {
                    Exceptions.throwOrReport(e, this, t);
                }
            }

        };
    } 
  ....省略代码.....
}

  • hook.onLift(operator).call(o)创建了一个新的 Subscriber (实际上是一个 proxy), 并在Subscriber.onNext中调用transform函数对参数t进行变形, 然后将变形结果转发给o.onNext`. 这么上面的变量o是哪里的,

  • OnSubscribe.call 调用了 4.3.1中create 创建出来的 Observable.onSubscribe 函数!

Rxjava_第9张图片
17.png

很简单, 该变形函数保存在了 OperatorMap.transform 中.

**总结一下 map 的行为: **

  1. 创建了一个新的 Observable,
  2. 创建了一个新的 OnSubscribe: 其中的 call 方法是整个调用链的关键. 它调用了上一级 Observable.onSubscribe.call, 同时, 还将结果通过 transform 对 4.3.1处理后的结果进行变形。

3.subscribe 触发整个回调流程. 我们来看一下主要流程

Rxjava_第10张图片
refactor.png

这一步也很简单, 就是通过 Observable.subscribe 调用该对象的 Observable.onSubscribe.call 方法, 然后经过一系列调用, 最终由该对象内部临时创建的 Subscriber 对象(上文中的 proxy 对象) 调用用户目标 Subscriber (即代码中 .subscribe(…) 中的参数) 的方法.

4.4 Schedulers

.subscribeOn(Schedulers.io())和.observeOn(Schedulers.computation())应用后的原理.

4.4.1基本使用

Observable.create(new Observable.OnSubscribe() {  
 @Override    
public void call(Subscriber subscriber) {        
  subscriber.onNext(1);        
  subscriber.onCompleted();    
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() { 
   @Override    
public void onCompleted() {          
  }   
 @Override    
public void onError(Throwable e) {    
}    
@Override    
public void onNext(String s) {   
 }
});

我们来拆解一下 .subscribeOn 和 .observeOn 的作用范围:

Rxjava_第11张图片
24.png
  • subscribeOn 将作用于 create 中的 OnSubscribe.call() 方法.
  • observeOn 作用于其语法中下一语句的 Subscriber.onNext 等函数中.

首先分析 subscribeOn

public class Observable {
 public final Observable subscribeOn(Scheduler scheduler) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);
        }
         //创建了一个 Observable 来转发 OnSubscribe.call 请求
        return create(new OperatorSubscribeOn(this, scheduler));
    }
}

与 map 一样, 是通过创建了一个 Observable 来转发 OnSubscribe.call 请求(代码中的 OperatorSubscribeOn 继承自 OnSubscribe. 来看看具体实现

public final class OperatorSubscribeOn implements OnSubscribe {

    final Scheduler scheduler;
    final Observable source;

    public OperatorSubscribeOn(Observable source, Scheduler scheduler) {
        this.scheduler = scheduler;
        this.source = source;
    }

    @Override
    public void call(final Subscriber subscriber) {
        final Worker inner = scheduler.createWorker();
        subscriber.add(inner);
        //这里使用了Worker.schedule方法改变了source.call()方法执行的线程
        inner.schedule(new Action0() {
            @Override
            public void call() {
                final Thread t = Thread.currentThread();
                
                Subscriber s = new Subscriber(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }
                    
                    @Override
                    public void onError(Throwable e) {
                        try {
                            subscriber.onError(e);
                        } finally {
                            inner.unsubscribe();
                        }
                    }
                    
                    @Override
                    public void onCompleted() {
                        try {
                            subscriber.onCompleted();
                        } finally {
                            inner.unsubscribe();
                        }
                    }
                    
                    @Override
                    public void setProducer(final Producer p) {
                        subscriber.setProducer(new Producer() {
                            @Override
                            public void request(final long n) {
                                if (t == Thread.currentThread()) {
                                    p.request(n);
                                } else {
                                    inner.schedule(new Action0() {
                                        @Override
                                        public void call() {
                                            p.request(n);
                                        }
                                    });
                                }
                            }
                        });
                    }
                };
                
                source.unsafeSubscribe(s);
            }
        });
    }
}
}

可见, 该函数中做了如下两件事:

  1. 创建一个用于在不同线程执行的 Worker 对象(代码中的 inner)
  2. 使用上述 inner 在该对象所代表的线程中执行 Observable.onSubscribe.call 方法(代码中的 source.unsafeSubscribe(s);

再来分析 observeOn

   public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);
        }
         //返回一个新Observable对象
        return lift(new OperatorObserveOn(scheduler, delayError, bufferSize));
    }```


  继续查看OperatorObserveOn对象及OperatorObserveOn.call` 方法是如何生成 `st` 对象的

public final class OperatorObserveOn implements Operator {

private final Scheduler scheduler;
private final boolean delayError;
private final int bufferSize;


public OperatorObserveOn(Scheduler scheduler, boolean delayError, int bufferSize) {
    this.scheduler = scheduler;
    this.delayError = delayError;
    this.bufferSize = (bufferSize > 0) ? bufferSize : RxRingBuffer.SIZE;
}

@Override
public Subscriber call(Subscriber child) {
    if (scheduler instanceof ImmediateScheduler) {
        // avoid overhead, execute directly
        return child;
    } else if (scheduler instanceof TrampolineScheduler) {
        // avoid overhead, execute directly
        return child;
    } else {
        ObserveOnSubscriber parent = new ObserveOnSubscriber(scheduler, child, delayError, bufferSize);
        parent.init();
        return parent;
    }
}

}

该方法会根据 `scheduler` 的类型决定返回什么样的`Subscriber` 对象. 可见, 如果 child 类型为 `ImmediateScheduler` 或者 `TrampolineScheduler` 等以当前线程为执行环境的类型, 则直接返回 `child` 对象. 本例中, `child` 为 `NewThreadScheduler`, 因此将通过 `ObserveOnSubscriber` 对 `child` 进行包装. 生成一个 proxy subscriber 对象.

返回来继续查看

public class Observable {
final OnSubscribe onSubscribe;
//这段代码熟悉吧
protected Observable(OnSubscribe f) {
this.onSubscribe = f;
}
public final Observable lift(final Operator operator) {
return new Observable(new OnSubscribeLift(onSubscribe, operator));
}
}



继续查看OnSubscribeLift
```public final class OnSubscribeLift implements OnSubscribe {
    
    static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();

    final OnSubscribe parent;

    final Operator operator;

    public OnSubscribeLift(OnSubscribe parent, Operator operator) {
        this.parent = parent;
        this.operator = operator;
    }

    @Override
    public void call(Subscriber o) {
        try {
            //调用并且切换线程
            Subscriber st = hook.onLift(operator).call(o);
            try {
                st.onStart();
                //熟悉.....
                parent.call(st);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                st.onError(e);
            }
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            o.onError(e);
        }
    }
}

至此, 我们可以知道 observeOn 是通过以下方法对其后面的 Subscriber 进行控制的:

  1. lift -> OnSubscribe.call -> proxy subscriber = new Subscriber(original subscriber) 创建了一个新的 Subscriber(实际上是个代理)
  2. 在上述 proxy subscriber 中对 original subscriber 对象的执行进行转发. 转发过程中, proxy subscriber 完全可以自由的控制 original subscriber 执行的线程.
Rxjava_第12张图片
l1.png

5. 在项目中Rxjava应用

你可能感兴趣的:(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
  • Java实现的简单双向Map，支持重复Value superlxw1234 java双向map
    关键字：Java双向Map、DualHashBidiMap     有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。   数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。   即：既要根据Key找Value，又要根据Value
  • PL/SQL触发器基础及例子 百合不是茶 oracle数据库触发器PL/SQL编程
      触发器的简介; 触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用,   一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行, 触发时间：指明触发器何时执行，该值可取： before：表示在数据库动作之前触发
  • [时空与探索]穿越时空的一些问题 comsci 问题
          我们还没有进行过任何数学形式上的证明,仅仅是一个猜想.....       这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
  • easy ui datagrid上移下移一行 商人shang js上移下移easyuidatagrid
    /** * 向上移动一行 * * @param dg * @param row */ function moveupRow(dg, row) { var datagrid = $(dg); var index = datagrid.datagrid("getRowIndex", row); if (isFirstRow(dg, row)) {
  • Java反射 oloz 反射
    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教 首先看看java中的Class package demo; public class ClassTest { /*先了解java中的Class*/ public static void main(String[] args) { //任何一个类都
  • springMVC 使用JSR-303 Validation验证 杨白白 springmvc
    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。 登录需要验证类 public class Login { @NotEmpty
  • log4j 香水浓 log4j
    log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE #log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML #console log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender log4
  • 使用ajax和history.pushState无刷新改变页面URL agevs jquery框架Ajaxhtml5chrome
    表现 如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。 是什么有这么强大的功能呢？ HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
  • centos中文乱码 AILIKES centosOSssh
    一、CentOS系统访问 g.cn ，发现中文乱码。 于是用以前的方式：yum -y install fonts-chinese CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。       后来，终于找到以下方法可以解决，需要两个中文支持的包： fonts-chinese-3.02-12.
  • 触发器 baalwolf 触发器
    触发器(trigger)：监视某种情况，并触发某种操作。 触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 语法： create trigger triggerName after/before 
  • JS正则表达式的i m g bijian1013 JavaScript正则表达式
            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
  • HTML5模式和Hashbang模式 bijian1013 JavaScriptAngularJSHashbang模式HTML5模式
            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 html5Mode         一个布尔值，标识$location服务是否运行在HTML5模式下。 ha
  • [Maven学习笔记六]Maven生命周期 bit1129 maven
    从mvn test的输出开始说起   当我们在user-core中执行mvn test时，执行的输出如下：   /software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
  • 【Hadoop七】基于Yarn的Hadoop Map Reduce容错 bit1129 hadoop
    运行于Yarn的Map Reduce作业，可能发生失败的点包括 Task Failure Application Master Failure Node Manager Failure Resource Manager Failure 1. Task Failure 任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
  • 记一次数据推送的异常解决端口解决 ronin47 记一次数据推送的异常解决
    　　 需求：从db获取数据然后推送到B         程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。 　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。 　　　service iptables stop
  • 巧用视错觉-UI更有趣 brotherlamp UIui视频ui教程ui自学ui资料
    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。 视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。 格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。 在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
  • 线段树-poj1177-N个矩形求边长（离散化+扫描线） bylijinnan 数据结构算法线段树
    package com.ljn.base; import java.util.Arrays; import java.util.Comparator; import java.util.Set; import java.util.TreeSet; /** * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177
  • HTTP协议详解 chicony http协议
    引言                                 
  • Scala设计模式 chenchao051 设计模式scala
    Scala设计模式                我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
  • 安装mysql daizj mysql安装
    安装mysql   (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除)      执行命令rpm -qa |grep mysql 检查是否删除干净   (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
  • HTTP状态码大全 dcj3sjt126com http状态码
    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
  • asihttprequest上传图片 dcj3sjt126com ASIHTTPRequest
    NSURL *url =@"yourURL"; ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url]; [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
  • C语言中，关键字static的作用 e200702084 C++cC#
    在C语言中，关键字static有三个明显的作用： 1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。 一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
  • win7/8使用curl geeksun win7
    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。 下载地址：  http://curl.haxx.se/download.html 请选择不带SSL的版本，否则还需要安装SSL的支持包   2.  可以给Windows增加c
  • Creating a Shared Repository; Users Sharing The Repository hongtoushizi git
    转载自：   http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/ Commands discussed in this section: git init –bare git clone git remote git pull git p
  • Java实现字符串反转的8种或9种方法 Josh_Persistence 异或反转递归反转二分交换反转java字符串反转栈反转
    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： http://josh-persistence.iteye.com/blog/2205768   /** * */ package com.wsheng.aggregator.algorithm.string; import java.util.Stack; /**
  • 代码实现任意容量倒水问题 home198979 PHP算法倒水
    形象化设计模式实战             HELLO!架构                     redis命令源码解析   倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
  • Druid datasource zhb8015 druid
    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
  • 两种启动监听器ApplicationListener和ServletContextListener spjich javaspring框架
    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器   ServletContextListener  特点: 依赖于sevlet容器，需要配置web.xml 使用方法: public class StartListener implements
  • JavaScript Rounding Methods of the Math object 何不笑 JavaScriptMath
        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他