並不是 Null Object 這麼簡單

原文地址：並不是Null Object這麼簡單
博客地址：zhangyi.farbox.com

在大多數程序語言中，咱們都須要與Null打交道，而且糾纏於對它的檢查中。一不當心讓它給溜出來，就可能像打開潘多拉的盒子通常，給程序世界帶來災難。提及來，在咱們人類世界中，Null到底算什麼「東西」呢？語義上講，它就是一場空，即所謂「虛無」。這個世界並無任何物質能夠表明「虛無」，於是它僅存於咱們的精神層面。說虛無存在實際上是一種悖論，由於存在實際上是虛無的反面。若從程序本質上講，Null表明一種狀態，指一個對象（或變量），雖獲聲明卻未真正誕生，甚至可能永遠不會誕生。而一旦誕生，Null就被抹去了，迴歸了正確的狀態。

站在OO的角度來說，既然Everything is object，天然能夠將Null一樣視爲Object——這近似於前面提到的悖論，既然是Null，爲什麼又是Object呢？換言之，在對象世界裏，其實沒有什麼不存在，所謂「不存在」仍然是一種「存在」。這麼說容易讓人變糊塗，就好像咱們搞不清楚「我是誰」。因此，我寧可採用Martin Fowler的說法，將Null Object視爲一種Special Case，即Null實際上是一種特例。

視Null爲一種特例，便可用OO的特化來表達。當某個對象可能存在Null這種狀態時，均可以將這種狀態表示爲一種特化的類，它再也不表明Null，而是表明「什麼都不作」。凡是返回Null的地方，都替換爲這個Null Object，用以表達這種Null其實僅僅是一種特列。因而乎，咱們像抹殺異教徒通常抹去了「虛無」的存在。（當虛無被抹去，是什麼樣的存在？）

然而，若在程序語言中實現本身的Null Object，當然能夠在必定程度上消除對Null的檢查，卻存在一些約束：

• 對於String之類的類型，沒法定義NullString子類；
• 每次都須要本身去定義子類來表示Null；
• 必須約束團隊不能返回Null；

Google的Guava框架爲了解決這一問題，引入了Optional ：

public abstract class Optional<T> implements Serializable {
  public static <T> Optional<T> absent() {
    return (Optional<T>) Absent.INSTANCE;
  }
  public static <T> Optional<T> of(T reference) {
    return new Present<T>(checkNotNull(reference));
  }
  public static <T> Optional<T> fromNullable(@Nullable T nullableReference) {
    return (nullableReference == null)
        ? Optional.<T>absent()
        : new Present<T>(nullableReference);
  }
  public abstract boolean isPresent();
  public abstract T get();
  public abstract T or(T defaultValue);
  public abstract <V> Optional<V> transform(Function<? super T, V> function);
}複製代碼

因而，咱們能夠這樣來使用Optional :

public final Optional<E> first() {
    Iterator<E> iterator = iterable.iterator();
    return iterator.hasNext()
        ? Optional.of(iterator.next())
        : Optional.<E>absent();
  }複製代碼

first()方法返回的是一個Optional 類型。這是Guava中操做集合的一個方法。當咱們要得到第一個元素時，能夠調用該方法：

List<Person> persons = newArrayList();
String name = from(persons).first().transform(new Function<Person, String>() {
        @Override
        public String apply(Person input) {
            return input.getName();
        }
    }).or("not found");
assertThat(name, is("not found"));複製代碼

不知是巧合，仍是一種借鑑，Java 8一樣定義了Optional用以處理這種狀況。前面的代碼在Java 8下能夠改寫爲：

List<Person> persons = newArrayList();
String name = persons.stream().findFirst().map(p -> p.getName()).orElse("not found");
assertThat(name, is("not found"));複製代碼

其實在Scala的早期版本，已經提供了Option[T]類型。前面的代碼若用scala編寫，就變成：

case class Person(name: String, age: Int)
val persons = List[Person]()
persons.headOption.map(p => p.name).getOrElse("not found")複製代碼

這樣的設計方式，仍是Null Object模式嗎？讓咱們回到Null的本原狀態，思考爲何會產生Null？首先，Null表明一種異常狀態，即在某種未可知的情形下，可能返回Null；正常狀況下，返回的則是非Null的對象。Null與非Null，表明一種未知與不肯定性。哈姆雷特糾結於「To be, or not to be, this is a question」，但在程序世界裏，能夠抽象爲一個集合來表達這種非此即彼的情況。

從函數式編程的角度來說，咱們能夠將這樣的集合設計爲一個Monad。根據DSL in Action一書中對Monad的介紹，一個Monad由如下三部分定義：

一個抽象M[A],其中M是類型構造函數。在Scala語言中能夠寫成class M[A]，或者case class M[A]，有或者trait M[A]
一個unit方法（unit v)。對應Scala中的函數new M(v)或者M(v)的調用。
一個bind方法，起到將運算排成序列的做用。在Scala中經過flatMap組合子來實現。bind f m對應的Scala語句是m flatMap f。

同時，Monad還必須知足如下三條規則：

右單位元(identity)。即對於任意Monad m，有m flatMap unit => m。對於Option，unit就是Option伴生對象定義的apply()方法。若m爲Some("Scala")，則m flatMap {x => Option(x)}，其結果仍是m。
左單位元(unit)。即對於任意Monad m，有unit(v) flatMap f => f(v)。

假設咱們定義一個函數f：

def f(v: String) = Option(v)複製代碼

則Option("Scala") flatMap {x => f(x)}的結果就等於f("scala")。

結合律。即對於任意Monad m，有m flatMap g flatMap h => m flatMap {x => g(x) flatMap h}。

不管是Scala中的Option[A]，仍是Java 8中的Optional[T]，都是一個Monad。此時的Null再也不是特例，而是抽象Option[A]對稱的兩個元素中的其中一個，在Scala中，即Option[T]中的Some[T]或None。它們倆面貌相同，倒是一對性格迥異的雙生子。

在設計爲Monad後，就能夠利用Monad提供的bind功能，完成多個函數的組合。組合時，並不須要考慮返回爲None的狀況。Monad能保證在前一個函數返回空值時，後續函數不會被調用。讓咱們來看一個案例。例如，咱們須要根據某個key從會話中得到對應的值，而後再將該值做爲參數去查詢符合條件的特定Customer。在Scala中，能夠將這兩個步驟定義爲函數，返回結果分別爲Option[String]與Option[Customer]：

def params(key: String): Option[String]
def queryCustomer(refId: String): Option[Customer]
val customer = 
    (
        for {
            r <- params("customerId")
            c <- queryCustomer(r)
        } yield c
    ) getOrElse error("Not Found")複製代碼

這段代碼用到了Scala的for comprehension，它實則是對flatMap的一種包裝。尤爲當嵌套多個flatMap時，使用for comprehension會更加直觀可讀。翻譯爲flatMap，則爲：

params("customerId").flatMap {
    r => queryCustomer(r).map {
        c => c
    }
} getOrElse error("Not Found")複製代碼

當我最初看到Guava設計的Optional[T]時，我覺得是Null Object模式的體現。顯然，它的功能要超出Null Object的範疇。但它也並不是Monad，在前面給出的定義中，咱們能夠看到Guava的Optional[T]僅提供了map（即定義中的transform)功能，而沒有提供更基本的flatMap操做。具備函數式編程功能的Scala與Java 8增強了這一功能，利用Monad強化了程序對Null的處理。