Guava中的Optional实现

Optional实现的业务代码：

ackage com.google.common.base;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Absent;
import com.google.common.base.AbstractIterator;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Present;
import com.google.common.base.Supplier;
import java.io.Serializable;
import java.util.Iterator;
import java.util.Set;
import javax.annotation.Nullable;

@Beta
@GwtCompatible(
    serializable = true
)
public abstract class Optional<T> implements Serializable {
    private static final long serialVersionUID = 0L;

    public static <T> Optional<T> absent() {
        return Absent.INSTANCE;
    }

    public static <T> Optional<T> of(T reference) {
        return new Present(Preconditions.checkNotNull(reference));
    }

    public static <T> Optional<T> fromNullable(@Nullable T nullableReference) {
        return (Optional)(nullableReference == null?absent():new Present(nullableReference));
    }

    Optional() {
    }

    public abstract boolean isPresent();

    public abstract T get();

    public abstract T or(T var1);

    public abstract Optional<T> or(Optional<? extends T> var1);

    public abstract T or(Supplier<? extends T> var1);

    @Nullable
    public abstract T orNull();

    public abstract Set<T> asSet();

    public abstract <V> Optional<V> transform(Function<? super T, V> var1);

    public abstract boolean equals(@Nullable Object var1);

    public abstract int hashCode();

    public abstract String toString();

    public static <T> Iterable<T> presentInstances(final Iterable<Optional<T>> optionals) {
        Preconditions.checkNotNull(optionals);
        return new Iterable() {
            public Iterator<T> iterator() {
                return new AbstractIterator() {
                    private final Iterator<Optional<T>> iterator = (Iterator)Preconditions.checkNotNull(optionals.iterator());

                    protected T computeNext() {
                        while(true) {
                            if(this.iterator.hasNext()) {
                                Optional optional = (Optional)this.iterator.next();
                                if(!optional.isPresent()) {
                                    continue;
                                }

                                return optional.get();
                            }

                            return this.endOfData();
                        }
                    }
                };
            }
        };
    }
}

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Supplier;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nullable;

@GwtCompatible
final class Absent extends Optional<Object> {
    static final Absent INSTANCE = new Absent();
    private static final long serialVersionUID = 0L;

    Absent() {
    }

    public boolean isPresent() {
        return false;
    }

    public Object get() {
        throw new IllegalStateException("value is absent");
    }

    public Object or(Object defaultValue) {
        return Preconditions.checkNotNull(defaultValue, "use orNull() instead of or(null)");
    }

    public Optional<Object> or(Optional<?> secondChoice) {
        return (Optional)Preconditions.checkNotNull(secondChoice);
    }

    public Object or(Supplier<?> supplier) {
        return Preconditions.checkNotNull(supplier.get(), "use orNull() instead of a Supplier that returns null");
    }

    @Nullable
    public Object orNull() {
        return null;
    }

    public Set<Object> asSet() {
        return Collections.emptySet();
    }

    public <V> Optional<V> transform(Function<Object, V> function) {
        Preconditions.checkNotNull(function);
        return Optional.absent();
    }

    public boolean equals(@Nullable Object object) {
        return object == this;
    }

    public int hashCode() {
        return 1502476572;
    }

    public String toString() {
        return "Optional.absent()";
    }

    private Object readResolve() {
        return INSTANCE;
    }
}

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Supplier;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nullable;

@GwtCompatible
final class Present<T> extends Optional<T> {
    private final T reference;
    private static final long serialVersionUID = 0L;

    Present(T reference) {
        this.reference = reference;
    }

    public boolean isPresent() {
        return true;
    }

    public T get() {
        return this.reference;
    }

    public T or(T defaultValue) {
        Preconditions.checkNotNull(defaultValue, "use orNull() instead of or(null)");
        return this.reference;
    }

    public Optional<T> or(Optional<? extends T> secondChoice) {
        Preconditions.checkNotNull(secondChoice);
        return this;
    }

    public T or(Supplier<? extends T> supplier) {
        Preconditions.checkNotNull(supplier);
        return this.reference;
    }

    public T orNull() {
        return this.reference;
    }

    public Set<T> asSet() {
        return Collections.singleton(this.reference);
    }

    public <V> Optional<V> transform(Function<? super T, V> function) {
        return new Present(Preconditions.checkNotNull(function.apply(this.reference), "Transformation function cannot return null."));
    }

    public boolean equals(@Nullable Object object) {
        if(object instanceof Present) {
            Present other = (Present)object;
            return this.reference.equals(other.reference);
        } else {
            return false;
        }
    }

    public int hashCode() {
        return 1502476572 + this.reference.hashCode();
    }

    public String toString() {
        return "Optional.of(" + this.reference + ")";
    }
}

调用的Optional入口的方法：

    private static Optional<Connection> getConnection() {
        Connection connection = null;
        try {
            connection = ComboPool.getConnection();
        } catch (SQLException e) {
            log.error("Get connection from pool error.", e);
        }
        return Optional.fromNullable(connection);
    }

根据调用方法方法返回的Optional，直接调用

 while (!connectionOptional.isPresent()) {
                log.warn("Can't get connection from database, wait for one minute, try again.");
                Thread.sleep(60000);
                connectionOptional = getConnection();
            }

可以判断是获取的发返回值是否为null。
这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。