业务首页优化记录

当界面有多个tab时，把tab做成懒加载。

好处：
- 减少View的创建。（待验证）
- 减少接口不必要的接口请求

并行请求接口

当界面有多个接口请求且界面逻辑有数据依赖时，即有先后顺序，可以从接口层面拆分为没有依赖关系。这样就可以把接口做成并行的。

预加载数据模板类实现方式见：PreLoadListStateFragment

zip操作符误区

结论：
zip操作符使用时，需要给每个Observable都加上执行线程。

1.0 zip 、 zipWith误区

正常调用如下：

long time = System.currentTimeMillis();Observable<String> observable1 = getObservable(1800);Observable<String> observable2 = getObservable(1500);Observable zip1 = observable1.zipWith(observable2, (str1, str2)->{  Log.e(TAG, "zip1 threadName=" + Thread.currentThread().getName());  return str1 + str2;});zip1.subscribeOn(Schedulers.newThread())      .observeOn(AndroidSchedulers.mainThread())      .subscribe(obj ->Log.e(TAG, "zip observable run time=" + (System.currentTimeMillis() - time)));

将会发生什么：


从log可以看出，
1、两个Observable执行在同一个线程。
2、执行总时长大于1800 + 1500。

1.1 zip中每个Observable使用subscribeOn(Schedulers.io())处理

long time = System.currentTimeMillis();Observable<String> observable1 = getObservable(1800)      .subscribeOn(Schedulers.io());Observable<String> observable2 = getObservable(1500)      .subscribeOn(Schedulers.io());Observable zip1 = observable1.zipWith(observable2, (str1, str2)->{  Log.e(TAG, "zip1 threadName=" + Thread.currentThread().getName());  return str1 + str2;});zip1.subscribeOn(Schedulers.newThread())      .observeOn(AndroidSchedulers.mainThread())      .subscribe(obj ->Log.e(TAG, "zip observable run time=" + (System.currentTimeMillis() - time)));

神奇时刻：



注意
1、两个Observable的线程名不同，
2、zip执行总时长略>1800毫秒

结论：

• 使用zip时，需要对每个Observable分别设置执行线程，否则所有Observable执行在同一个线程。
• 通过两个log可以看出zip合并线程执行在耗时最长的线程中。### 2.1 Zip 中嵌套Zip：observable1 执行1800秒，observable2 执行1500秒observable3 执行1000秒

long time = System.currentTimeMillis();        Observable<String> observable1 = getObservable(1800)                .subscribeOn(Schedulers.io());        Observable<String> observable2 = getObservable(1500)                .subscribeOn(Schedulers.io());        Observable<String> observable3 = getObservable(1000);        Observable<String> zip = observable1.zipWith(observable2, (str1, str2) -> {                    Log.e(TAG, "zip threadName=" + Thread.currentThread().getName());                    return str1 + str2;                }        );        Observable<String> zip3 = observable3.zipWith(zip, (str3, zipStr) -> {                    Log.e(TAG, "zip threadName=" + Thread.currentThread().getName());                    return str3 + zipStr;                }        );        zip3.subscribeOn(Schedulers.newThread())                .observeOn(AndroidSchedulers.mainThread())                .subscribe((str) -> Log.e(TAG, "zip observable run time=" + (System.currentTimeMillis() - time)));


结论：

• 三个Observable执行在同一个线程
• 耗时大于 1800 +1500 + 1000

2.2 嵌套Zip部分设置执行线程

long time = System.currentTimeMillis();Observable<String> observable1 = getObservable(1800)      .subscribeOn(Schedulers.io());Observable<String> observable2 = getObservable(1500)      .subscribeOn(Schedulers.io());Observable<String> observable3 = getObservable(1000);Observable<String> zip = observable1.zipWith(observable2, new Func2<String, String, String>() {  @Override  public String call(String integer, String integer2) {      String threadName = Thread.currentThread().getName();      Log.e(TAG, "zip threadName=" + threadName);      return integer + integer2;  }});Observable<String> zip3 = observable3.zipWith(zip, new Func2<String, String, String>() {  @Override  public String call(String s, String zips) {      Log.e(TAG, "zip in zip threadName=" + Thread.currentThread().getName());      return s + zips;  }});

Observable3没有设置执行线程，可以预见zip3只有两个执行线程。从log中也验证了这一猜想



2.3 调换zip和Observable3的位置。

Observable<String> zip3 = zip.zipWith(observable3, (str3, zipStr) -> {                    Log.e(TAG, "zip threadName=" + Thread.currentThread().getName());                    return str3 + zipStr;                }        );


从2.2和2.3比较可以看出，不同的zipWith顺序，可导致不同的并行线程数。

2.4 都加上 subscribeOn(Schedulers.io())

Observable<String> observable1 = getObservable(1800)                .subscribeOn(Schedulers.io());        Observable<String> observable2 = getObservable(1500)                .subscribeOn(Schedulers.io());        Observable<String> observable3 = getObservable(1000)                .subscribeOn(Schedulers.io());


从log看Observable执行在不同的线程。
结论：
- Observable执行在不同线程
- 执行时长 > 1800

3.0 map误区：

//测试得出结论,observeOn之前的执行现成在subscribeOn设置的线程中执行,observeOn之后的线程在observeOn设置的线程中执行。第一次设置subscribeOn、observeOn之后,在调用这两个方法,不在改变执行线程//每次操作符执行时,都会判断是否 UnSubscribe,若已执行,则终端后面的操作符mTestSubscribe = Observable.just("1")//io      .map(createMap("just"))//io      .subscribeOn(Schedulers.io())//io      .map(createMap("subscribeOn after"))//io      .subscribeOn(Schedulers.newThread())//io      .map(createMap("new thread1111"))//io      .observeOn(Schedulers.newThread())//此处不能用 MainThread,      .map(createMap("observeOn after"))//      .subscribeOn(Schedulers.newThread())      .map(createMap("new thread2222"))//mainThread      //mainThread      .flatMap(new Func1<String, Observable<String>>() {          @Override          public Observable<String> call(final String s) {              return Observable.create(new Observable.OnSubscribe<String>() {                  @Override                  public void call(Subscriber<? super String> subscriber) {                      Log.e(TAG, "call:start flatMap Threadname=" + Thread.currentThread().getId());                      try {                          Thread.sleep(1500);                      } catch (InterruptedException e) {                          e.printStackTrace();                      }                      subscriber.onNext("flatMap");                      subscriber.onCompleted();                      Log.e(TAG, "call:end flatMap Threadname=" + Thread.currentThread().getId());                  }              });          }      })      //mainThread      .subscribe(new Action1<String>() {          @Override          public void call(String s) {              Log.e(TAG, "call:结束 Threadname=" + Thread.currentThread().getId() + " s=" + s);          }      }, new Action1<Throwable>() {          @Override          public void call(Throwable throwable) {              throwable.printStackTrace();          }      });

布局优化

布局优化减少ViewGroup的嵌套

优化前层级结构：共有7个层级


cach使用。

可对部分变化不大的接口是用cache
注意事项：
1、缓存会调用两次onNext回调
2、当缓存加载成功、接口加载失败是，需要处理onError回调，不在显示失败页面。
3、使用缓存后，第一次数据返回很快，loading可以适当延迟显示下。