本篇文章将概述 「Android」 响应式编程 「RxJava」，会从设计模式、使用到原理结合案例，由浅到深、由表到里、循序渐进的概述。

本篇文章的示例代码放在 Github 上。

观察者模式(Observer pattern)

在使用 「RxJava」 之前，我们需要先理解观察者设计模式，因为，「RxJava」 就使用了观察者设计模式。

定义

观察者模式(又被称为发布-订阅 Publish/Subscribe 模式)，属于行为型模式的一种，它定义了一对多的依赖关系，让多个观察者对象同时监听某一个被观察者对象，被观察者对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新。

结构

观察者模式结构，如图：

一般我们写一个观察者模式都需要定义如下角色：

• Observable(被观察者)：一般为抽象类，用于保存观察者对象和新增、删除、通知观察者的方法。
• ConcreteObservable(具体的被观察者)：继承 Observable 类，实现 notifyObservers() 方法，当被观察者发生变化时，通知所有的观察者。
• Observer(观察者)：一般为接口，包含 update() 方法，当收到具体的被观察者通知时被调用。
• ConcreteObserver(具体的观察者)：实现 Observer 接口，重写 update() 方法，以便更新自身状态。

案例

接下来，我们来实现一个简单的观察者模式的案例，案例情景，如下：

❝

小明的水果店里的 🍊 非常甜，所以很快就卖光了，但是，接二连三的有顾客过来买 🍊，于是，小明告诉顾客：🍊已经卖完了，你们可以扫下这个公众号，订阅之后，等 🍊有货了会自动通知你们！

❞

这种场景我们就可以使用观察者模式，我们先创建一个 Observer 接口(观察者)，如下：

public interface Observer {
    void update();
}

再创建一个 Customer 客户类(具体的观察者)，如下：

// 实现 Observer 接口
public class Customer implements Observer {

    private String name;

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

    // 重新 Observer 的 update() 方法
    @Override
    public void update() {
        System.out.println(name + “ 购买了 🍊”);
    }
}

之后创建一个 Observable 抽象类(被观察者)，如下：

public abstract class Observable {
    // 观察者
    protected List<Observer> observers = new ArrayList<>();
    // 新增观察者
    public void add(Observer observer) {
        observers.add(observer);
    }
    // 移除观察者
    public void remove(Observer observer) {
        observers.remove(observer);
    }
    // 通知观察者
    public abstract void notifyObservers();
}

最后创建一个 FruitStore 水果店类(具体的被观察者)，如下：

// 继承 Observable 类
public class FruitStore extends Observable {
    // 重写 notifyObservers() 通知所有的观察者
    @Override
    public void notifyObservers() {
        for (Observer observer: observers) {
            observer.update();
        }
    }

    public void run() {
        this.notifyObservers();
    }
}

我们再创建一个 Client 进行测试，如下：

public class Client {
    public static void main(String[] args) {
        // 创建一个水果店实例(被观察者)
        FruitStore fruitStore = new FruitStore();
        fruitStore.add(new Customer(“lsy”)); // 新增观察者
        fruitStore.add(new Customer(“per”)); // 新增观察者
        fruitStore.add(new Customer(“zimu”)); // 新增观察者
        fruitStore.run(); // 通知所有观察者
    }
}

运行结果如下：

lsy 购买了 🍊
per 购买了 🍊
zimu 购买了 🍊

Process finished with exit code 0

可见，使用观察者模式可以降低观察者和被观察者之间的耦合性，可以建立一套触发机制；当然，Java JDK 已经提供了 Observer、Observable，我们使用它们同样可以实现功能。

RxJava的使用

通过上文的对观察者模式的理解之后，再来看看 「RxJava」 是如何使用的，它同样有如下几个角色，如下：

「Observable」 :被观察者，也就是事件的发生者
「Observer」 :观察者，也就是事件的接受者
「subscribe」 :两者产生订阅关系

具体的使用如下：

public class UseRxJava {

    public static void main(String[] args) {
        // 创建 Observable 被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                emitter.onNext(“🍊 到货了！”);
                emitter.onNext(“大家可以来买 🍊 了！”);
                emitter.onError(new Throwable(“🍊 又卖完了！”));
                emitter.onNext(“WOW！🍊 卖光了”);
                emitter.onComplete();
                emitter.onComplete();
                emitter.onNext(“🍊 加急进货中…”);
            }
        });

        // 创建 Observer 观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                System.out.println(“onSubscribe:” + d.isDisposed());
            }

            @Override
            public void onNext(@NonNull String s) {
                System.out.println(“onNext:” + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(“onError:” + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println(“onComplete”);
            }
        };
        // 关联订阅关系
        observable.subscribe(observer);
    }

}

运行结果，如下：

onSubscribe:false
onNext:🍊 到货了！
onNext:大家可以来买 🍊 了！
onError:🍊 又卖完了！

BUILD SUCCESSFUL in 328ms

通过简单的使用案例和运行结果，可知：

「onNext()」: 可以多次发送事件
「onComplete()」: 可以多次调用不会报错，但只执行一次
「onError()」: 只能发送一次，多次调用会报错，不可和 onComplete() 共存
「onComplete()」: 和 「onError()」 都存在时，只执行 onError()
「onComplete()」: 和 「onError()」 之后，观察者无法接收到发送事件
「onSubscribe()」: 是在订阅之后，发送事件之前执行

RxJava编程思想

「RxJava」 是在 Java 上的响应式扩展，通过使用可观察序列，用于组成异步和基于事件编程的类库，也就是以响应式编程思维来进行编程的Java类库。

响应式编程是面向数据流的编程思想，在响应式编程思想下，一切皆数据流。响应式编程所侧重的是数据流的流动。

响应式编程案例

我们在理解响应式编程之前，先来使用我们传统的思想实现一个加载网络图片的案例：

public class MainActivity extends AppCompatActivity {

    private static final String TAG = “MainActivity”;
    private ImageView imageView;
    private final static String URL = “https://cdn.lishaoy.net/serializable/serializable.png";
    private final Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(@NonNull Message msg) {
            Log.i(TAG, “handleMessage: aaa”);
            Bitmap bitmap = (Bitmap) msg.obj;
            imageView.setImageBitmap(bitmap);
            if (loading != null) loading.dismiss();
            return false;
        }
    });
    private ProgressDialog loading;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView = findViewById(R.id.image_view);
    }

    public void loadImage(View view) {
        loading = ProgressDialog.show(this, “”, “loading”);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    URL url = new URL(URL);
                    HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
                    urlConnection.setConnectTimeout(6000);
                    int responseCode = urlConnection.getResponseCode();
                    if(responseCode == HttpURLConnection.HTTP_OK) {
                        InputStream inputStream = urlConnection.getInputStream();
                        Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                        Message message = handler.obtainMessage();
                        message.obj = bitmap;
                        handler.sendMessage(message);
                    }
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

如上，我们可能会用 new Thread() 和 Handler 来实现或者其他方法，每个人的实现方法可能都不同。如果，使用 「RxJava」 思想实现呢，必然实现方式要按照响应式编程数据流的编程思想，实现方式也就一致了。下面，我们再用 「RxJava」 来实现它，如下：

public class MainActivity extends AppCompatActivity {

    private static final String TAG = “MainActivity”;
    private ImageView imageView;
    private final static String URL = “https://cdn.lishaoy.net/image/112131.jpg";
    private ProgressDialog loading;
    private Disposable disposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView = findViewById(R.id.image_view);
    }

    public void rxJavaLoadImage(View view) {
        // Observable.just(URL) 创建被观察者
        Observable.just(URL)
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(String s) throws IOException {
                        URL url = new URL(URL);
                        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
                        urlConnection.setConnectTimeout(6000);
                        int responseCode = urlConnection.getResponseCode();
                        if (responseCode == HttpURLConnection.HTTP_OK) {
                            InputStream inputStream = urlConnection.getInputStream();
                            Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                            return bitmap;
                        }
                        return null;
                    }
                })
                .subscribeOn(Schedulers.io()) // 上面的代码分配工作线程
                .observeOn(AndroidSchedulers.mainThread()) // 下面的代码分别UI线程
                // 链式调用 subscribe 绑定观察者
                .subscribe(new Observer<Bitmap>() {
                    // onSubscribe() 方法在发送事件之前执行
                    @Override
                    public void onSubscribe(Disposable d) {
                        loading = ProgressDialog.show(MainActivity.this, “”, “loading”);
                        disposable = d;
                    }

                    // onNext() 在发送事件之后执行
                    @Override
                    public void onNext(Bitmap bitmap) {
                        imageView.setImageBitmap(bitmap);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, “onError: ” + e.getMessage(), e);
                    }

                    @Override
                    public void onComplete() {
                        if (loading != null) loading.dismiss();
                    }
                });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        disposable.dispose();
    }
}

运行结果如图：

「RxJava」 以链式调用，Observable.just(URL) 分发事件，map() 来加工数据流(可以使用多个map处理不同的业务)、subscribeOn(Schedulers.io()) 切换工作线程、observeOn(AndroidSchedulers.mainThread()) 切换主线程，数据流流向 subscribe 进行处理(下游的处理根据上游的数据流变化而变化)。

RxJava结合Retrofit使用(案例)

通过 「RxJava」 使用，现在我们已经了解它的流式的响应式编程的思想，下面我们通过和 Retrofit 结合使用，看看是什么体验？

我们使用 玩Android 开放API 来完成本次案例。首先我们使用 Retrofit 定义一个 Api 的接口，如下：

public interface Api {
    // 获取项目分类数据
    @GET(“project/tree/json”)
    Observable<ProjectBean> getProject();
    // 获取项目列表数据(项目列表数据依赖于项目分类数据的id)
    @GET(“project/list/{pageIndex}/json”)
    Observable<ProjectItem> getProjectItem(@Path(“pageIndex”) int pageIndex, @Query(“cid”) int cid);

}

ProjectBean、ProjectItem JavaBean 我们根据接口返回的数据利用工具 GsonFormat 生成。

然后，新建一个 HttpClient 生成 Retrofit，如下：

public class HttpClient {
    // api 的 base url
    public static String BASE_URL = “https://www.wanandroid.com/";

    public static void setBaseUrl(String baseUrl) {
        BASE_URL = baseUrl;
    }

    // 创建 Retrofit
    public static Retrofit getRetrofit() {
        // 创建 OkHttp 客户端
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        // 配置参数
        OkHttpClient httpClient = builder.addNetworkInterceptor(new StethoInterceptor())
                .readTimeout(6666, TimeUnit.SECONDS)
                .connectTimeout(6666, TimeUnit.SECONDS)
                .writeTimeout(6666, TimeUnit.SECONDS)
                .build();

        return new Retrofit.Builder().baseUrl(BASE_URL)
                .client(httpClient) // 使用 OkHttp 访问网络
                .addConverterFactory(GsonConverterFactory.create(new Gson())) // 设置 json 解析工具
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 设置 rxjava
                .build();
    }

}

再新建一个 RetrofitActivity 来演示，如下：

public class RetrofitActivity extends AppCompatActivity {

    private static final String TAG = “RetrofitActivity”;
    private Api api;
    private TextView textView;
    private String itemData;
    private Disposable disposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_retrofit);
        textView = findViewById(R.id.text_view);

        api = HttpClient.getRetrofit().create(Api.class); // 生成 api
    }

    // 查询项目分类数据
    @SuppressLint(“CheckResult”)
    public void getProject(View view) {
        disposable = api.getProject() // 查询项目分类数据(返回的是 Observable 被观察者)
                .subscribeOn(Schedulers.io()) // 给上面的代码分配工作线程
                .observeOn(AndroidSchedulers.mainThread()) // 给下面的代码分配主线程
                .subscribe(new Consumer<ProjectBean>() { // 订阅并创建观察者
                    @Override
                    public void accept(ProjectBean projectBean) throws Exception {
                        textView.setText(projectBean.toString()); // 进行 UI 操作
                    }
                });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        disposable.dispose();
    }

}

运行结果如图：

可见 Retrofit 和 RxJava 结合使用，代码量减少的同时，整个流程思路更为清晰，且可以为所欲为的切换线程。

防抖

我们再使用防抖(防止用户操作带来的频繁发起请求问题)的方式来查询项目列表数据，如下：

public class RetrofitActivity extends AppCompatActivity {

    private static final String TAG = “RetrofitActivity”;
    private Api api;
    private TextView textView;
    private String itemData;
    private Disposable disposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_retrofit);
        textView = findViewById(R.id.text_view);

        api = HttpClient.getRetrofit().create(Api.class); // 生成 api
        getProjectItemData();
    }

    …

    // 查询项目列表数据，项目列表数据需要根据项目分类数据的 id 进行查询
    // 且使用 rxbinding 增加防抖功能
    public void getProjectItemData() {
        Button button = findViewById(R.id.get_item_button_fd);
        disposable = RxView.clicks(button) // 设置防抖的 view
                .throttleFirst(2600, TimeUnit.MILLISECONDS) // 设置在 2.6 秒内只响应一次点击事件
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        disposable = api.getProject() // 查询项目分类数据(返回的是 Observable 被观察者)
                                .subscribeOn(Schedulers.io()) // 给上面的代码分配工作线程
                                .observeOn(AndroidSchedulers.mainThread()) // 给下面的代码分配主线程
                                .subscribe(new Consumer<ProjectBean>() { // 订阅并创建观察者
                                    @Override
                                    public void accept(final ProjectBean projectBean) throws Exception {
                                        for (ProjectBean.DataBean bean: projectBean.getData()) {
                                            disposable = api.getProjectItem(1, bean.getId()) // 根据项目分类数据的 id 查询项目列表数据(返回的是 Observable 被观察者)
                                                    .subscribeOn(Schedulers.io()) // 给上面的代码分配工作线程
                                                    .observeOn(AndroidSchedulers.mainThread()) // 给下面的代码分配主线程
                                                    .subscribe(new Consumer<ProjectItem>() { // 订阅并创建观察者
                                                        @Override
                                                        public void accept(ProjectItem projectItem) throws Exception {
                                                            Log.d(TAG, “accept: ” + projectItem);
                                                            textView.setText(projectItem.toString()); // 进行 UI 操作
                                                        }
                                                    });
                                        }
                                    }
                                });
                    }
                });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        disposable.dispose();
    }

}

运行结果如图：

可见以上代码虽然实现了防抖和嵌套查询的功能，但是，代码嵌套过多，难以维护。

解决网络嵌套问题

上面的代码虽没什么问题，但是嵌套太多，所以我们使用 flatMap 操作符来解决此问题，如下：

public class RetrofitActivity extends AppCompatActivity {

    private static final String TAG = “RetrofitActivity”;
    private Api api;
    private TextView textView;
    private String itemData;
    private Disposable disposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_retrofit);
        textView = findViewById(R.id.text_view);

        api = HttpClient.getRetrofit().create(Api.class); // 生成 api
        getProjectItemData();
        getItemData();
    }

    …

    // 查询项目列表数据，使用 flatMap 操作符，解决网络嵌套问题
    public void getItemData(){
        Button button = findViewById(R.id.get_item_button);
       disposable = RxView.clicks(button) // 设置防抖的 view
                .throttleFirst(2600, TimeUnit.MILLISECONDS) // 设置在 2.6 秒内只响应一次点击事件
                .observeOn(Schedulers.io()) // 给下面的代码分配工作线程
                .flatMap(new Function<Object, ObservableSource<ProjectBean>>() {
                    @Override
                    public ObservableSource<ProjectBean> apply(Object o) throws Exception {
                        return api.getProject(); // 查询项目分类数据，并且把数据流向下游
                    }
                })
                .flatMap(new Function<ProjectBean, ObservableSource<ProjectBean.DataBean>>() {
                    @Override
                    public ObservableSource<ProjectBean.DataBean> apply(ProjectBean projectBean) throws Exception {
                        return Observable.fromIterable(projectBean.getData()); // 根据上游流过来的数据，迭代出每个 ProjectItem 项目列表数据，并且流向下游
                    }
                })
                .flatMap(new Function<ProjectBean.DataBean, ObservableSource<ProjectItem>>() {
                    @Override
                    public ObservableSource<ProjectItem> apply(ProjectBean.DataBean dataBean) throws Exception {
                        return api.getProjectItem(1, dataBean.getId()); // 根据上游流过来的数据，查询每个列表数据，并且流向下游
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ProjectItem>() {
                    @Override
                    public void accept(ProjectItem projectItem) throws Exception {
                        itemData += projectItem.toString() + “\n ================================================ \n”;
                        textView.setText(itemData); // 根据上游流过来的数据，进行 UI 操作
                    }
                });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        disposable.dispose();
    }
}

运行结果如图：

可见，使用 flatMap 操作符后，思路更为清晰，代码平铺下来更易理解，以一种流式的方式不断的向下游流去数据，下游根据上游的数据可以决定是否继续向下游流或者做UI更新操作等，flatMap 操作符可以重复使用，且线程的切换可以随意切换，这个就是 RxJava 数据流式的响应式编程思想。

Hook钩子函数

我们已经了解了 RxJava 的思想和使用，现在我们来看看它的源码，我们从创建一个被观察者(Observable)开始 Observable.create，点击 create，如下：

public static <T> Observable<T> create(@NonNull ObservableOnSubscribe<T> source) {
    Objects.requireNonNull(source, “source is null”);
    return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
}

很简单，就这么一句 RxJavaPlugins.onAssembly() 代码，我们点进 onAssembly 如下：

/
   Calls the associated hook function.
   @param <T> the value type
   @param source the hook’s input value
   @return the value returned by the hook
  */
@SuppressWarnings({ “rawtypes”, “unchecked” })
@NonNull
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
    Function<? super Observable, ? extends Observable> f = onObservableAssembly;
    if (f != null) {
        return apply(f, source);
    }
    return source;
}

可以看到注释：Calls the associated hook function(调用关联的钩子函数)，把 onObservableAssembly 赋值给了 f 函数，我们通过查找 onObservableAssembly 发现他并没有赋值，也就是说它始终是 null，所以，在没有给 onObservableAssembly 赋值的情况下，这个函数什么也不会做；所以，我们需要给 onObservableAssembly 函数赋值就可以先 if 语句执行 onObservableAssembly 函数，那么怎么赋值呢？我们对 onObservableAssembly 进行搜索发现，如下：

@SuppressWarnings(“rawtypes”)
@Nullable
static volatile Function<? super Observable, ? extends Observable> onObservableAssembly;

RxJavaPlugins.onObservableAssembly = onObservableAssembly;

onObservableAssembly 是 RxJavaPlugins 类的一个静态变量，于是我们就知道如何赋值了，我们用之前例子来测试，如下：

public class UseRxJava {

    public static void main(String[] args) {
        // 给 hook 钩子函数赋值
        RxJavaPlugins.setOnObservableAssembly(new Function<Observable, Observable>() {
            @Override
            public Observable apply(Observable observable) throws Throwable {
                System.out.println(observable + “ 你想买🍊 ？”);
                return observable;
            }
        });
        // 新增一个测试被观察者
        Observable.just(“🍊”)
                .map(new Function<String, Object>() {
                    @Override
                    public Object apply(String s) throws Throwable {
                        return “lsy 买了 ” + s;
                    }
                })
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Throwable {
                        System.out.println(o);
                    }
                });
        // 创建 Observable 被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                emitter.onNext(“🍊 到货了！”);
                emitter.onNext(“大家可以来买 🍊 了！”);
                emitter.onError(new Throwable(“🍊 又卖完了！”));
                emitter.onNext(“WOW！🍊 卖光了”);
                emitter.onComplete();
                emitter.onComplete();
                emitter.onNext(“🍊 加急进货中…”);
            }
        });

        // 创建 Observer 观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                System.out.println(“onSubscribe:” + d.isDisposed());
            }

            @Override
            public void onNext(@NonNull String s) {
                System.out.println(“onNext:” + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(“onError:” + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println(“onComplete”);
            }
        };
        // 关联订阅关系
        observable.subscribe(observer);
    }

}

运行结果，如下：

io.reactivex.rxjava3.internal.operators.observable.ObservableJust@694f9431 你想买🍊 ？
io.reactivex.rxjava3.internal.operators.observable.ObservableMap@f2a0b8e 你想买🍊 ？
lsy 买了 🍊
io.reactivex.rxjava3.internal.operators.observable.ObservableCreate@515f550a 你想买🍊 ？
onSubscribe:false
onNext:🍊 到货了！
onNext:大家可以来买 🍊 了！
onError:🍊 又卖完了！

BUILD SUCCESSFUL in 868ms

我们 hook 钩子函数执行了3次，分别是：ObservableJust、ObservableMap、ObservableCreate，可知，hook 钩子函数是一个全局监听函数，所以我们可以利用它做很多事情。

RxJava观察者模式和标准观察者模式

我们来继续解读源码，通过标准观察者模式和 RxJava 观察者模式的比较已区别来更加深刻的理解 RxJava。

上面我们通过源码了解到 hook 钩子函数，Observable.create 创建一个被观察者时如果我们给钩子函数赋值，就会先执行钩子函数；那么，我们的准观察者模式和 「RxJava」 观察者模式有什么不同呢？

标准观察者模式有4个角色：Observable(被观察者)、ConcreteObservable(具体的被观察者)、Observer(观察者)、ConcreteObserver(具体的观察者)，「RxJava」 观察者模式的这4个角色分别是什么呢？对应关系如下：

在标准的观察者模式中 Observable (被观察者) 是持有 Observer(观察者) 列表的，那么 「RxJava」 观察者模式呢？

我们来继续看源码，上文我们已经看过 Observable.create，点击 create，如下：

public static <T> Observable<T> create(@NonNull ObservableOnSubscribe<T> source) {
    Objects.requireNonNull(source, “source is null”);
    return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
}

RxJavaPlugins.onAssembly() 我们已经看过，我们来看看 new ObservableCreate<>(source)， 这个 source 就是我们传进来的 new ObservableOnSubscribe(){ … }，我们点进 ObservableCreate 如下：

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

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

    …

}

可知，return RxJavaPlugins.onAssembly(new ObservableCreate<>(source)); 返回的是 ObservableCreate(ObservableOnSubscribe<T> source) { this.source = source; }，而 source 是我们自己传进去的；

我们再来看看订阅 observable.subscribe(observer) 代码，点进 subscribe，如下：

@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(@NonNull Observer<? super T> observer) {
    Objects.requireNonNull(observer, “observer is null”);
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        Objects.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");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        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;
    }
}

我们看到重点代码 subscribeActual(observer); 点进 subscribeActual 如下：

protected abstract void subscribeActual(@NonNull Observer<? super T> observer);

是一个抽象函数，也就说它的实现是在 ObservableCreate 类里面的，因为，是 ObservableCreate 调用了 subscribe 方法，那么，我们就回到 subscribeActual 类，如下：

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

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

    // subscribeActual 抽象方法的实现
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        // 创建了一个 CreateEmitter 发射器，且传入了目标观察者
        CreateEmitter<T> parent = new CreateEmitter<>(observer);
        // 执行了目标观察者的 onSubscribe 方法
        observer.onSubscribe(parent);

        try {
            // 执行目标被观察者(ObservableCreate) 的 subscribe 方法且传入了 发射器 CreateEmitter
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

}

可知，subscribeActual 抽象方法的实现：创建了一个 CreateEmitter 发射器，且传入了目标观察者，且执行了目标观察者的 onSubscribe() 方法；这就是为什么 onSubscribe() 方法会在订阅之后，发送事件之前执行的原因。

之后，又执行目标被观察者(ObservableCreate) 的 subscribe 方法且传入了发射器 CreateEmitter，在看下我们的 CreateEmitter 发射器源码，如下：

static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {

        private static final long serialVersionUID = -3434801548987643227L;

        final Observer<? super T> observer;
        // 持有目标观察者 observer
        CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }

        // 执行 onNext() 会调用 observer.onNext(t) 执行目标观察者的 onNext()
        @Override
        public void onNext(T t) {
            if (t == null) {
                onError(ExceptionHelper.createNullPointerException(“onNext called with a null value.”));
                return;
            }
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }

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

       …

CreateEmitter 发射器持有目标观察者 observer 目标观察者，执行 onNext() 会调用 observer.onNext(t) 执行目标观察者的 onNext()。

「RxJava」 的观察者模式整个流程，如图：

可见，「RxJava」 观察者模式和标准的观察者模式完全不同，「RxJava」 观察者模式的被观察者并没有持有观察者的列表，而是通过一个中间层 CreateEmitter 发射器来完成事件的传递，它更像是一个发布订阅者模式，如图：

Map操作符原理

上文加载图片的案例里我们已经使用过 map 操作符，用来把 String 数据加工成 Bitmap 数据，从而流向下游，我们来回顾一下上文的案例代码，如下：

public void rxJavaLoadImage(View view) {
        // Observable.just(URL) 创建被观察者
        Observable.just(URL)
                // 使用 map 操作符加工数据,从 String 转换为 Bitmap
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(String s) throws IOException {
                        URL url = new URL(URL);
                        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
                        urlConnection.setConnectTimeout(6000);
                        int responseCode = urlConnection.getResponseCode();
                        if (responseCode == HttpURLConnection.HTTP_OK) {
                            InputStream inputStream = urlConnection.getInputStream();
                            Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                            return bitmap; // 将 Bitmap 数据流向下游
                        }
                        return null;
                    }
                })
               .subscribeOn(Schedulers.io()) // 上面的代码分配工作线程
               .observeOn(AndroidSchedulers.mainThread()) // 下面的代码分别UI线程
                // 链式调用 subscribe 绑定观察者
                .subscribe(new Observer<Bitmap>() {
                    // onSubscribe() 方法在发送事件之前执行
                    @Override
                    public void onSubscribe(Disposable d) {
                        loading = ProgressDialog.show(MainActivity.this, “”, “loading”);
                        disposable = d;
                    }

                    // onNext() 在发送事件之后执行
                    @Override
                    public void onNext(Bitmap bitmap) {
                        imageView.setImageBitmap(bitmap);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, “onError: ” + e.getMessage(), e);
                    }

                    @Override
                    public void onComplete() {
                        if (loading != null) loading.dismiss();
                    }
                });
    }

我们点进 map 查看源码，如下

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
    ObjectHelper.requireNonNull(mapper, “mapper is null”);
    return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}

可知，最终返回的是一个 ObservableMap，点进 ObservableMap 如下：

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }

    // new MapObserver<T, U>(t, function) 把我们传进来的函数包上了一次 MapObserver
    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }

    …

}

关键代码 source.subscribe(new MapObserver<T, U>(t, function)) 把我们传进来的函数包上了一次 MapObserver，source.subscribe() 这个 source 就是 Observable，就相当于 Observable.subscribe()，而 MapObserver 继承与 BasicFuseableObserver，BasicFuseableObserver 实现了 Observer，最终 source.subscribe() 会执行到：

 @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(@NonNull Observer<? super T> observer) {
        Objects.requireNonNull(observer, “observer is null”);
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            Objects.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");
            // 是一个静态抽象方法，最终由实现类完成
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            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;
        }
    }

subscribeActual(observer) 是一个静态抽象方法，最终由实现类完成，也就是 ObservableJust 的 subscribeActual 方法，如下

public final class ObservableJust<T> extends Observable<T> implements ScalarSupplier<T> {

    private final T value;
    public ObservableJust(final T value) {
        this.value = value;
    }
    // source.subscribe(new MapObserver<T, U>(t, function)); 又对 observer 包裹了一层
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        ScalarDisposable<T> sd = new ScalarDisposable<>(observer, value);
        observer.onSubscribe(sd);
        sd.run();
    }

    @Override
    public T get() {
        return value;
    }
}

observer 是我们从 source.subscribe 里 传进来的 MapObserver，而此段代码又对 observer 包裹了一层。

observer.onSubscribe(sd) 就会执行我们自己 new 出来的目标观察者的 onSubscribe 里的逻辑。

sd.run() 进去看看源码，如下：

public static final class ScalarDisposable<T>
    extends AtomicInteger
    implements QueueDisposable<T>, Runnable {

        …

        @Override
        public void run() {
            if (get() == START && compareAndSet(START, ON_NEXT)) {
              // observer 就是我们传进来的 MapObserver
                observer.onNext(value);
                if (get() == ON_NEXT) {
                    lazySet(ON_COMPLETE);
                    observer.onComplete();
                }
            }
        }
    }

observer.onNext(value) 的 observer 就是我们传进来的 MapObserver，也就是执行 MapObserver.onNext()，如下：

static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> 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 = Objects.requireNonNull(mapper.apply(t), “The mapper function returned a null value.”);
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            downstream.onNext(v);
        }

        …
    }

onNext() 通过 mapper.apply(t) 对我们的数据进行转换，如下

public interface Function<@NonNull T, @NonNull R> {
    /
      Apply some calculation to the input value and return some other value.
      @param t the input value
      @return the output value
      @throws Throwable if the implementation wishes to throw any type of exception
     */
    R apply(T t) throws Throwable;
}

传入 T 返回 R，而这个 apply 会执行我们实现的重写 apply 方法的里面逻辑。

「RxJava」 的 map 操作符使用了装饰器模式，在不影响主数据流的情况下，对需要加工的数据进行包装，在自己的包装类里完成数据的加工。

「RxJava」 里的操作符非常多，只要你理解其中的几个的原理，其它的操作符原理都差不多，下面列出了基本所有的操作符，如图：

我们在日常工作中，网络数据传输最主流的的格式就是 json，我们常使用 「Gson」 开源框架来处理它，那么它们是如何工作的呢？本篇文章将解读 「Android」 中的序列化与 json 解析，如：Java 语言提供的 Serializable、Android 提供的 Parceable。

本篇文章的示例代码放在 Github 上，所有知识点，如图：

序列化的定义及相关概念

在系统的底层，数据传输形式是字节序列形式传输，系统并不认识对象，只认识字节序列，那么我们如何进行进程间的通讯，我们需要先将数据序列化，就是将对象传化为字节序列；反序列化，当底层的字节序列传输到相应的进程时，就需要反序列化，就是字节序列转化为对象。

在进程间通讯、本地数据存储、网络数据传输都离不开序列化，对于不同的场景选择合适的序列化方案对应用的性能有着极大的影响。

序列化

数据结构或对象转换成二进制的过程，就是将数据结构或对象转换成可以存储或者传输的数据格式的过程。

反序列化

二进制串转换成数据结构或对象的过程，就是序列化生成的二进制串数据被还原成数据结构或对象的过程。

序列化和反序列化的目的

• 序列化：主要用于网络传输，数据持久化，一般序列化也称为编码(Encode)
• 反序列化：主要用于从网络，磁盘上读取字节数组还原成原始对象，一般反序列化也称为解码 (Decode)

Serializable接口

Serializable 是 Java 提供的序列化接口，它非常简单，如下

public interface Serializable {
}

Serializable 只是一个标记，用来被 ObjectOutputStream 序列化，被 ObjectInputStream 反序列化。

Serializable的使用

我们先来新建一个 Student 类，代码如下：

public class Student implements Serializable {

    private static final long serialVersionUID = 7911650650846382143L;
    private String name;
    private Integer age;
    private List<Course> courses;

    // 获取课程
    public List<Course> getCourses() {
        return courses;
    }
    // 新增课程
    public void addCourse(Course course) {
        this.courses.add(course);
    }

    // 用 transient 关键字标记的成员变量不参与序列化
    private transient Date createTime;
    // 静态成员变量属于类而不属于对象，也不参与序列化
    private static SimpleDateFormat dateFormat = new SimpleDateFormat();

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        courses = new ArrayList<>();
        createTime = new Date();
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return “Student{“ +
                “name=’” + name + ‘\’’ +
                “, age=” + age +
                “, courses=” + courses +
                “, createTime=” + createTime +
                ‘}’;
    }
}

Student 类依赖于 Course 类，所以，我们再新建一个 Course 类，如下：

public class Course implements Serializable {

    private static final long serialVersionUID = 7980496416494451794L;
    private String name;
    private float score;

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

    public String getName() {
        return name;
    }

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

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return “Course{“ +
                “name=’” + name + ‘\’’ +
                “, score=” + score +
                ‘}’;
    }
}

我们再新建一个序列化的工具类，如下：

public class SerializableUtil {

    private static String path = System.getProperty(“user.dir”) + “/serializable/src/main/java/net/lishaoy/serializable/serializable/out/student.out”;

    public static synchronized boolean serializable(Object o) {
        if (o == null) {
            return false;
        }
        ObjectOutputStream outputStream = null;
        try {
            outputStream = new ObjectOutputStream(new FileOutputStream(path));
            outputStream.writeObject(o);
            outputStream.close();
            System.out.println(“序列化成功！”);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return false;
    }

    public static synchronized <T> T reverseSerializable() {
        ObjectInputStream inputStream = null;

        try {
            inputStream = new ObjectInputStream(new FileInputStream(path));
            Object object = inputStream.readObject();
            System.out.println(“反序列化成功！\n”  + object);
            return (T) object;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

我们使用 SerializableUtil 工具类，来序列化和反序列化我们的 Student，如下：

public class UseSerializable {

    public static void main(String[] args) {
        Student student = new Student(“lsy”, 66);
        student.addCourse(new Course(“英语”,66));
        // 序列化
        SerializableUtil.serializable(student);
        // 反序列化
        SerializableUtil.reverseSerializable();
    }

}

运行结果，如下：

序列化成功！
反序列化成功！
Student{name=‘lsy’, age=66, courses=[Course{name=‘英语’, score=66.0}], createTime=null}

在使用 Serializable 时，可以发现以下几个特点：

• 需要现象 Serializable 的类，才可以序列化和反序列化
• 用 transient 关键字标记的成员变量不参与序列化
• 静态成员变量不参与序列化
• 一个实现序列化的类，它的子类也是可序列化的

serialVersionUID与兼容性

「serialVersionUID的作用：」 用来表明类的不同版本间的兼容性。Java 序列化机制会通过判断类的 serialVersionUID 来验证版本一致性；在反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地相应实体类的 serialVersionUID 进行比较。

「兼容性问题：」 为了在反序列化时，确保类版本的兼容性，最好在每个要序列化的类中加入 private static final long serialVersionUID = XXX 属性。如果不显式定义该属性，这个属 性值将由JVM根据类的相关信息计算，而修改后的类的计算 结果与修改前的类的计算结果往往不 同，从而造成对象的反序列化因为类版本不兼容而失败。

serialVersionUID 可以用 Android Studio 自动生成，如图：

使用时按 option + enter，如图：

Externalizable接口

JDK 提供了 Serializable 接口外还提供了 Externalizable 接口，它继承了 Serializable，优先级高于 Serializable，源码如下：

public interface Externalizable extends Serializable {
    void writeExternal(ObjectOutput var1) throws IOException;

    void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException;
}

Externalizable接口的使用

我们来看下简单的使用，代码如下：

public class Course implements Externalizable {

    private static final long serialVersionUID = -342346458732794596L;
    private String name;
    private float score;

    public Course(){}

    public Course(String name, float score) {
        this.name = name;
        this.score = score;
        System.out.println(“Course: ” + “name ” + name + “ score ” + score);
    }

    public String getName() {
        return name;
    }

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

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }

    @Override
    public void writeExternal(ObjectOutput objectOutput) throws IOException {
        System.out.println(“writeExternal …”);
        objectOutput.writeObject(name);
    }

    @Override
    public void readExternal(ObjectInput objectInput) throws IOException, ClassNotFoundException {
        System.out.println(“readExternal …”);
        name = (String) objectInput.readObject();
    }

    @Override
    public String toString() {
        return “Course{“ +
                “name=’” + name + ‘\’’ +
                “, score=” + score +
                ‘}’;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Course course = new Course(“数学”,66);
        // 序列化
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
        outputStream.writeObject(course);
        byte[] bytes = byteArrayOutputStream.toByteArray();
        outputStream.close();

        // 反序列化
        ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
        System.out.println((Course)inputStream.readObject());

    }
}

运行结果如下：

Course: name 数学 score 66.0
writeExternal …
readExternal …
Course{name=‘数学’, score=0.0}

BUILD SUCCESSFUL in 576ms

可以看到，在序列化时会调用 writeExternal 方法，反序列化时会调用 readExternal 方法，也就是说我们可以灵活的控制想序列化的字段。

Externalizable 接口，在反序列化时，需要写默认的空构造函数，否则报错：InvalidClassException。

使用Serializable的注意点

readObject和writeObject

readObject 和 writeObject 并没有在 Serializable 接口里定义，但是通过查看源码，可知，如：ObjectOutputStream 点击进入源码，如下：

…

private void writeSerialData(Object var1, ObjectStreamClass var2) throws IOException {
    ClassDataSlot[] var3 = var2.getClassDataLayout();

    for(int var4 = 0; var4 < var3.length; ++var4) {
        ObjectStreamClass var5 = var3[var4].desc;
        // hasWriteObjectMethod 会判断我们是否重写了 writeObject() 方法
        if (var5.hasWriteObjectMethod()) {
            ObjectOutputStream.PutFieldImpl var6 = this.curPut;
            this.curPut = null;
            SerialCallbackContext var7 = this.curContext;
            if (extendedDebugInfo) {
                this.debugInfoStack.push(“custom writeObject data (class \”” + var5.getName() + “\”)”);
            }

            try {
                this.curContext = new SerialCallbackContext(var1, var5);
                this.bout.setBlockDataMode(true);
                // 通过反射执行 writeObject() 方法
                var5.invokeWriteObject(var1, this);
                this.bout.setBlockDataMode(false);
                this.bout.writeByte(120);
            } finally {
                this.curContext.setUsed();
                this.curContext = var7;
                if (extendedDebugInfo) {
                    this.debugInfoStack.pop();
                }

            }

            this.curPut = var6;
        } else {
            this.defaultWriteFields(var1, var5);
        }
    }
}

…

所以，我们也可以像 Externalizable 接口提供的 writeExternal、readExternal 方法一样使用 readObject 和 writeObject 来灵活的序列化和反序列化。例如：

public class ReadWriteObjectCourse implements Serializable {

    private static final long serialVersionUID = -6828110073372979297L;
    private String name;
    private float score;

    public ReadWriteObjectCourse(){}

    public ReadWriteObjectCourse(String name, float score) {
        this.name = name;
        this.score = score;
        System.out.println(“Course: ” + “name ” + name + “ score ” + score);
    }

    public String getName() {
        return name;
    }

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

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }
    // 重写 writeObject() 方法，只序列化 name 字段
    private void writeObject(ObjectOutputStream outputStream) throws IOException {
        System.out.println(“writeObject …”);
        outputStream.writeObject(name);
    }
    // 重写 readObject() 方法，只反序列化 name 字段
    private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
        System.out.println(“readObject …”);
        name = (String) inputStream.readObject();
    }

    @Override
    public String toString() {
        return “Course{“ +
                “name=’” + name + ‘\’’ +
                “, score=” + score +
                ‘}’;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ReadWriteObjectCourse course = new ReadWriteObjectCourse(“数学”,66);
        // 序列化
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
        outputStream.writeObject(course);
        byte[] bytes = byteArrayOutputStream.toByteArray();
        outputStream.close();

        // 反序列化
        ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
        ReadWriteObjectCourse course1 = (ReadWriteObjectCourse) inputStream.readObject();
        System.out.println(course1);
    }
}

运行结果，如下：

Course: name 数学 score 66.0
writeObject …
readObject …
Course{name=‘数学’, score=0.0}

BUILD SUCCESSFUL in 722ms

readObject 和 writeObject 方法都被执行，自定义序列化 name 字段。Serializable 接口除了这2个方法可以重写外，还有2个方法，分别是 readResolve 和 writeReplace。

多引用写入

「多引用写入」 问题，我们来看如下代码：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    Course course = new Course(“数学”,66);
    // 序列化
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
    outputStream.writeObject(course);
    course.setName(“英语”);
    outputStream.writeObject(course);
    byte[] bytes = byteArrayOutputStream.toByteArray();
    outputStream.close();

    // 反序列化
    ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
    Course course1 = (Course) inputStream.readObject();
    Course course2 = (Course) inputStream.readObject();
    System.out.println(course1);
    System.out.println(course2);
}

运行结果如下：

Course: name 数学 score 66.0
writeExternal …
readExternal …
Course{name=‘数学’, score=0.0}
Course{name=‘数学’, score=0.0}

BUILD SUCCESSFUL in 557ms

我们 course.setName(“英语”); 把 name 修改后，重新 outputStream.writeObject(course); 但是结果并没有改变。这个就是多引用问题：对于一个实例的多个引用，为了节省空间，只会写入一次。

我们可以使用 outputStream.reset(); 来解决问题。

子类实现 Serializable，而父类没有实现 Serializable

「子类实现 Serializable，而父类没有实现 Serializable」 问题，我们新建一个 Person 类，代码如下：

public class Person {
    private String name;

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

    @Override
    public String toString() {
        return “Person{“ +
                “name=’” + name + ‘\’’ +
                ‘}’;
    }
}

让 Student 类继承它，代码如下：

public class Student extends Person implements Serializable {

    …

    public Student(String name, Integer age) {
        super(name);
        this.name = name;
        this.age = age;
        courses = new ArrayList<>();
        createTime = new Date();
        System.out.println(“Student: name:” + name + “ age:” + age + “ createTime:” + createTime);
    }

    …

}

运行结果如下：

java.io.InvalidClassException: net.lishaoy.serializable.serializable.Student; no valid constructor
…

提示我们没有构造函数，我们需要在父类 Person 加入无参的构造函数，如下：

public class Person {
    private String name;
    // 加入无参构造函数
    public Person(){}

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

    @Override
    public String toString() {
        return “Person{“ +
                “name=’” + name + ‘\’’ +
                ‘}’;
    }
}

单例模式的序列化

序列化会导致单例失效，就是序列化前后会产生多个对象，代码如下：

public class Single {

    public static class SingleClass implements Serializable {

        private static final long serialVersionUID = 9153534024695280942L;
        private static boolean flag = false;

        private static SingleClass singleClass;

        public static SingleClass getInstance() {

            if(singleClass == null) {
                synchronized (SingleClass.class) {
                    if (singleClass == null) {
                        singleClass = new SingleClass();
                    }
                }
            }

            return singleClass;
        }

        private SingleClass() {
            if (!flag) flag = true; else throw new RuntimeException(“单例模式被侵犯！”);
        }
    }

    public static void main(String[] args) {
        SingleClass singleClass = SingleClass.getInstance();
        // 序列化
        SerializableUtil.serializable(singleClass);
        // 反序列化
        SingleClass singleClass1 = SerializableUtil.reverseSerializable();
        System.out.println(“序列化之前：” + singleClass.hashCode());
        System.out.println(“序列化之后：”+ singleClass1.hashCode());
    }

}

运行结果，如下：

序列化成功！
反序列化成功！
net.lishaoy.serializable.serializable.Single$SingleClass@41629346
序列化之前：1442407170
序列化之后：1096979270

BUILD SUCCESSFUL in 621ms

单例模式序列化前后会产生多个对象的问题，可以重写 readResolve() 方法解决。

Parcelable接口

Parcelable 是 Android SDK 为我们提供的序列化接口，它是基于内存的，由于内存读写速度高于硬盘，因此 Android 中的跨进程对象的传输一般使用 Parcelable；Parcelable 相对于 Serializable 的使用复杂一些，但是 Parcelable 的效率比 Serializable 也高很多

Parcelable的使用

由于 Parcelable 是 Android SDK 提供的，所以，需要在 Android 工程下使用，如下：

public class Course implements Parcelable {

    private static final String TAG = “Course”;
    private String name;
    private float score;

    @Override
    public String toString() {
        return “Course{“ +
                “name=’” + name + ‘\’’ +
                “, score=” + score +
                ‘}’;
    }

    public Course(Parcel in) {
        this.name = in.readString();
        this.score = in.readFloat();
    }
    // 反序列化，将 Parcel 对象转换为 Parcelable
    public static final Creator<Course> CREATOR = new Creator<Course>() {
        //反序列化的方法，将Parcel还原成Java对象
        @Override
        public Course createFromParcel(Parcel in) {
            return new Course(in);
        }
        //提供给外部类反序列化这个数组使用。
        @Override
        public Course[] newArray(int size) {
            return new Course[size];
        }
    };

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

    @Override
    public int describeContents() {
        return 0;
    }
    // 序列化，将对象转换成一个 Parcel 对象
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(this.name);
        dest.writeFloat(this.score);
    }
}

在 MainActivity 里通过 Intent 来传递数据，如：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Course.runParcel();

        Button button = findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, ParcelActivity.class);
                intent.putExtra(“course”, new Course(“数学”, 66f));
                startActivity(intent);
            }
        });
    }
}

在 ParcelActivity 接受数据并打印，如下：

public class ParcelActivity extends AppCompatActivity {

    private static final String TAG = “ParcelActivity”;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_parcel);

        Intent intent = getIntent();
        Parcelable course = intent.getParcelableExtra(“course”);
        Log.i(TAG, “onCreate: ” + course.toString());
    }
}

运行结果，如下：

I/ParcelActivity: onCreate: Course{name=‘数学’, score=66.0}

Parcelable与Serializable的性能比较

Serializable性能分析

Serializable 是 Java 中的序列化接口，其使用起来简单但开销较大(因为 Serializable 在序列化过程中使用了反射机制，故而会产生大量的临时变量，从而导致频繁的GC)，并且在读写数据过程中，它是通 过IO流的形式将数据写入到硬盘或者传输到网络上。

Parcelable性能分析

Parcelable 则是以 IBinder 作为信息载体，在内存上开销比较小，因此在内存之间进行数据传递时，推荐使用 Parcelable，而 Parcelable 对数据进行持久化或者网络传输时操作复杂，一般这个时候推荐使用 Serializable。

JSON解析方式

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，通常用于：数据标记，存储，传输。

Android Studio自带org.json解析

org.json 解析是基于文档驱动，需要把全部文件读入到内存中，然后遍历所有数据，根据需要检索想要 的数据，具体使用，如下：

public class OrgJsonActivity extends AppCompatActivity {

    private static final String TAG = “OrgJsonActivity”;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_org_json);
        try {
            createJson();
            parseJson();
        } catch (JSONException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void createJson() throws JSONException, IOException {
        File file = new File(getFilesDir(), “orgJson.json”);
        JSONObject student = new JSONObject();
        student.put(“name”,“lsy”);
        student.put(“age”, 66);
        JSONObject course = new JSONObject();
        course.put(“name”,“数学”);
        course.put(“score”,66);
        student.put(“course”, course);
        JSONArray courses = new JSONArray();
        courses.put(0, course);
        student.put(“courses”,courses);
        FileOutputStream outputStream = new FileOutputStream(file);
        outputStream.write(student.toString().getBytes());
        outputStream.close();
        Log.i(TAG, “createJson: ” + student.toString());
    }

    private void parseJson() throws IOException, JSONException {
        File file = new File(getFilesDir(), “orgJson.json”);
        FileInputStream inputStream = new FileInputStream(file);
        InputStreamReader streamReader = new InputStreamReader(inputStream);
        BufferedReader reader = new BufferedReader(streamReader);
        String line;
        StringBuffer stringBuffer = new StringBuffer();
        while ((line = reader.readLine()) != null) {
            stringBuffer.append(line);
        }
        inputStream.close();
        streamReader.close();
        reader.close();

        Student student = new Student();
        JSONObject jsonObject = new JSONObject(stringBuffer.toString());
        String name = jsonObject.optString(“name”, “lsy”);
        int age = jsonObject.optInt(“age”, 66);
        student.setName(name);
        student.setAge(age);

        JSONArray courses = jsonObject.optJSONArray(“courses”);
        for (int i = 0; i < courses.length(); i++) {
            JSONObject course = courses.getJSONObject(i);
            Course course1 = new Course();
            course1.setName(course.optString(“name”,“”));
            course1.setScore((float) course.optDouble(“score”, 0));
            student.addCourse(course1);
        }

        Log.i(TAG, “parseJson: ” + student);

    }
}

运行结果，如下：

I/OrgJsonActivity: createJson: {“name”:“lsy”,“age”:66,“course”:{“name”:“数学”,“score”:66},“courses”:[{“name”:“数学”,“score”:66}]}
I/OrgJsonActivity: parseJson: Student{id=0, name=‘lsy’, age=66, courses=[Course{name=‘数学’, score=66.0}]}

Gson解析

Gson 解析也是基于事件驱动，它根据所需取的数据 建立1个对应于JSON数据的JavaBean类，即可通过简单操作解析出 所需数据，具体使用如下：

public class GsonActivity extends AppCompatActivity {

    private static final String TAG = “GsonActivity”;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_gson);
        createGson();
    }

    public void createGson() {
        Student student = new Student(1,“lsy”, 66);
        student.addCourse(new Course(“英语”,66));
        // 序列化
        Gson gson = new Gson();
        String json = gson.toJson(student);
        Log.i(TAG, “createGson: json ” + json);
        // 反序列化
        Log.i(TAG, “createGson: json1” + gson.fromJson(json, Student.class));
    }
}

运行结果如下：

I/GsonActivity: createGson: json {“age”:66,“courses”:[{“name”:“英语”,“score”:66.0}],“id”:1,“name”:“lsy”}
I/GsonActivity: createGson: json1Student{id=1, name=‘lsy’, age=66, courses=[Course{name=‘英语’, score=66.0}]}

Json 解析方式还有 Jackson 解析、Fastjson解析等，在此就不具体介绍。

Gson原理解析

在序列化和反序列化的过程中，Gson 充当了一个解析器的角色，如图

JsonElement

该类是一个抽象类，代表着 json 串的某一个元素。这个元素可以是一个 Json(JsonObject)、可以是一个数组(JsonArray)、可以是一个Java的基本类型( JsonPrimitive)、当然也可以为null( JsonNull)；JsonObject、JsonArray、JsonPrimitive、JsonNull 都是 JsonElement 这个抽象类的子类。JsonElement 提供了一系列的方法来判断当前的JsonElement。

JsonObject 对象可以看成 name/values 的集合，而这写 values 就是一个个 JsonElement，他们的结构可以 用如下图表示:

Gson的工作流程

Gson的工作流程，如图

对于 Android 开发人员来说，并发编程知识的使用并不是那么频繁(相对于 Java 开发者而言)，但是，我们想写一些框架或者阅读开源框架源码都需要掌握并发编程的相关知识，而且，并发编程相关知识也是面试高频问题之一，所以，我们也要全面的掌握并发编程知识，本篇文章将从浅入深概述并发编程知识。

本篇文章的示例代码放在 Github 上，所有知识点，如图：

基础概念

在理解并发编程之前，我需要理解一些相关的基本概念，我们先从一些相关的基本概念开始。

CPU核心数和线程数的关系

多核心: 是物理上的，单核、双核、多核，指的就是物理核心的数目。

多线程: 是逻辑上的，简单的说就是模拟出的 CPU 核心数；

核心数和线程数的关系: 目前主流 CUP 有双核、三核和四核，增加核心数目就是为了增加线程数,因为操作系统是通过线程来执行任务的，一般情况下它们是1:1对应关系，也就是说四核CPU一般拥有四个线程。但 Intel 引入超线程技术后,使核心数与线程数形成1:2的关系。

CPU时间片轮转机制

我们平时在开发的时候，感觉并没有受cpu核心数的限制，想启动线程就启动线程，哪怕是在单核CPU上，为什么？这是因为操作系统提供了一种CPU时间片轮转机制。

时间片轮转调度是一种最古老、最简单、最公平且使用最广的算法,又称RR(Round-Robin，RR)调度。根据先进先出原则，排成队列(就绪队列)，调度时，将 CPU 分配给队首进程，让其执行一个时间段(称为：时间片)，时间片通常为 10-100ms 数量级，当执行的时间片用完时，会由计时器发出时钟中断请求，调度程序便据此来停止该进程的执行，并将它排到队列末尾，然后再把 CPU 重新分配给当前队列的队首进程，同理如此往复。

什么是进程和线程

进程是程序运行资源分配的最小单位，其中资源包括：CPU、内存空间、磁盘等,同一进程中的多个线程共享该进程中的全部系统资源，而进程和进程之间是相互独立的。进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。

进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然，程序是死的、静态的，进程是活的、动态的。进程可以分为系统进程和用户进程，凡是用于完成操作系统的各种功能的进程就是系统进程，它们就是处于运行状态下的操作系统本身，用户进程就是所有由你启动的进程。

线程是 CPU 调度的最小单位,必须依赖于进程而存在，线程是进程的一个实体，是 CPU 调度和分派的基本单位，它是比进程更小的、能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

并行和并发

我们举个例子，如果有条高速公路A上面并排有6条车道，公路中间有个收费站，那么，在某一时刻，同时通过此收费站的，就是并行；在单位时间内通过此收收费站的，就是并发。

当谈论并发的时候一定要加个单位时间，也就是说单位时间内并发量是多少，离开了单位时间其实是没有意义的。

并行: ：指在同一时刻，有多条指令在多个处理器上同时执行。

并发: ：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

线程(Thread)

线程的启动

启动线程的方式有，如下：

• className extends Thread，重新 run() 方法
• className implements Runnable，然后，由 Thread 运行
• className implements Callable，然后，由 Thread 运行

代码如下：

public class NewThread {      // 继承 Thread，重写 run() 方法     private static class UseThread extends Thread {        @Override        public void run() {            super.run();            System.out.println(“extends Thread”);        }    }         // 实现 Runnable 接口        private static class UseRunnable implements Runnable {        @Override        public void run() {            System.out.println(“implements Runnable”);        }    }        // 实现 Callable 接口       private static class UseCallable implements Callable<String> {        @Override        public String call() throws Exception {            System.out.println(“implements Callable”);            return “return UseCallable”;        }    }    public static void main(String[] args) throws ExecutionException, InterruptedException {        // 使用 Thread 创建线程        UseThread useThread = new UseThread();        useThread.start();        // 使用 Runnable 创建线程        UseRunnable useRunnable = new UseRunnable();        new Thread(useRunnable).start();        // 使用 Callable 创建线程        UseCallable useCallable = new UseCallable();        FutureTask<String> task = new FutureTask<>(useCallable);        new Thread(task).start();        System.out.println(task.get()); // 通过 get 获取返回结果    }}

运行结果，如下：

extends Threadimplements Runnableimplements Callablereturn UseCallableBUILD SUCCESSFUL in 753ms

继承 Thread 的方式和实现 Runnable 的方式，执行完成后无法返回结果，实现 Callable 的方式，执行完成后可以返回结果。 (md partial supported)

run()和start()的区别

我们通过 new Thread() 只是 new 出一个 Thread 的示例，并没有和操作系统中的真正的线程挂钩，只有执行 start() 方法后，才真正的启动线程。

进入 start() 方法查看源码，可得知最终是调用了 private native void start0()，是一个 native 方法，是由 C 或 C++ 来操作系统(分配CPU等操作)，之后才调用 run() 方法，且 start() 方法不能重复调用。

run() 只是类的一个成员方法，和普通方法并无区别，可重复执行(如单独执行 run() 方法，并不会启动线程)。

示例代码如下：

class StartRunMethod {    public static class StartAndRun extends Thread {        @Override        public void run() {            System.out.println(“run: This is “ + Thread.currentThread().getName()); // 获取当前线程名        }        public void runMethod() {            System.out.println(“runMethod: This is “ + Thread.currentThread().getName()); // 获取当前线程名        }    }    public static void main(String[] args) {        StartAndRun startAndRun = new StartAndRun();        startAndRun.setName(“ThreadRun”); // 设置线程的名字        startAndRun.start(); // 真正启动名字为 ThreadRun 的线程        startAndRun.run();  // 只是一个普通方法，和 runMethod() 没有区别        startAndRun.runMethod(); // 输出结果和 startAndRun.run() 相同    }}