JAVA设计模式第五讲：设计模式在 Google Guava 的应用

// 被观察者
public class UserController {
    @Autowired
    private UserService userService;
    private EventBus eventBus;
    private static final int DEFAULT_EVENTBUS_THREAD_POOL_SIZE = 20;
    public UserController() {
        // 异步非阻塞模式，可以在构造器中使用独立线程池
        eventBus = new AsyncEventBus(Executors.newFixedThreadPool(DEFAULT_EVENTBUS_SIZE));
    } 
    public void setRegObservers(List<Object> observers) {
      for (Object observer : observers) {
        // 可以接收任何类型观察者
        eventBus.register(observer);
      }
    }
    public Long register(String telephone, String password) {
        // 用户注册
        long userId = userService.register(telephone, password);
        // 用于给观察者发消息，规则：能接受的消息类型是发送消息类型的父类或相同类型
        MessageEvent event = new MessageEvent();
        event.setUserId(userId);
        eventBus.post(event);
        return userId;
    }
}
// 观察者1，任意类型的对象都可以注册到 EventBus 中
public class AObserver {
    // 依赖注入
    private AService aService; 
    // EventBus 会根据该注解找到方法，将方法能接收到的消息类型记录下来
    @Subscribe
    public void process(MessageEvent event) {
      // todo
    }
}
// 观察者2
public class RegNotificationObserver {
    private BService bService;
    @Subscribe
    public void process(MessageEvent event) {
        // todo
    }
}

public class CacheDemo {
    public static void main(String[] args) {
        Cache<String, String> cache = CacheBuilder.newBuilder()
          //设置 cache 的初始大小为100
          .initialCapacity(100)
          //最大 key 个数
          .maximumSize(1000)
          //设置 cache 中的数据在写入之后的存活时间为10秒  
          .expireAfterWrite(10, TimeUnit.MINUTES)
          .build();
        cache.put("key1", "value1");
        String value = cache.getIfPresent("key1");
        System.out.println(value);
    }
}

public final class CacheBuilder<K, V> {
    ...
    public <K1 extends K, V1 extends V> Cache<K1, V1> build() {
        checkWeightWithWeigher();
        checkNonLoadingCache();
        return new LocalCache.LocalManualCache<K1, V1>(this);
    } 
    private void checkNonLoadingCache() {
        checkState(refreshNanos == UNSET_INT, "refreshAfterWrite requires a LoadingCache");
    } 
    private void checkWeightWithWeigher() {
        if (weigher == null) {
            checkState(maximumWeight == UNSET_INT, "maximumWeight requires weigher");
        } else {
            if (strictParsing) {
                checkState(maximumWeight != UNSET_INT, "weigher requires maximumWeight");
            } else {
                if (maximumWeight == UNSET_INT) {
                    logger.log(Level.WARNING, "ignoring weigher specified without maximumWeight");
                }
            }
        }
    }
}

@GwtCompatible
public abstract class ForwardingCollection<E> extends ForwardingObject implements Collection<E> {
    protected ForwardingCollection() {}
    @Override
    protected abstract Collection<E> delegate();
    @Override
    public Iterator<E> iterator() {
      return delegate().iterator();
    }
    @Override
    public int size() {
      return delegate().size();
    }
    @Override
    public boolean isEmpty() {
      return delegate().isEmpty();
    }
    @Override
    public boolean contains(Object object) {
      return delegate().contains(object);
    }
    @Override
    public boolean add(E element) {
      return delegate().add(element);
    }
    @Override
    public boolean remove(Object object) {
      return delegate().remove(object);
    }
    @Override
    public boolean containsAll(Collection<?> collection) {
      return delegate().containsAll(collection);
    }
    @Override
    public boolean addAll(Collection<? extends E> collection) {
      return delegate().addAll(collection);
    }
    @Override
    public boolean retainAll(Collection<?> collection) {
      return delegate().retainAll(collection);
    }
    ...
}

// ConstrainedList<E> ForwardingList<E> 均为装饰器类，其中 ForwardingList 继承自 ForwardingCollection<E>
@GwtCompatible
private static class ConstrainedList<E> extends ForwardingList<E> {
    // 原始类，成员变量为父类类型
    final List<E> delegate;
    final Constraint<? super E> constraint;
    ConstrainedList(List<E> delegate, Constraint<? super E> constraint) {
      this.delegate = checkNotNull(delegate);
      this.constraint = checkNotNull(constraint);
    }
    @Override
    protected List<E> delegate() {
      return delegate;
    }
    @Override
    public boolean add(E element) {
      // 在执行委托方法前，对入参做了校验
      constraint.checkElement(element);
      return delegate.add(element);
    }
    @Override
    public void add(int index, E element) {
      constraint.checkElement(element);
      delegate.add(index, element);
    }
    @Override
    public boolean addAll(Collection<? extends E> elements) {
      return delegate.addAll(checkElements(elements, constraint));
    }
    @Override
    public boolean addAll(int index, Collection<? extends E> elements) {
      return delegate.addAll(index, checkElements(elements, constraint));
    }
    @Override
    public E set(int index, E element) {
      constraint.checkElement(element);
      return delegate.set(index, element);
    }
    @Override
    public List<E> subList(int fromIndex, int toIndex) {
      return constrainedList(delegate.subList(fromIndex, toIndex), constraint);
    }
}

// Immutable 模式， 可以使用 Builder 模式来替换，同样达到不可变类的效果
public class User {
    private String name;
    private int age;
    // 引用类型
    private Address addr;
    public User(String name, int age, Address addr) {
      this.name = name;
      this.age = age;
      this.addr = addr;
    }
    // 只有getter方法，无setter方法...
} 
public class Address {
    private String province;
    private String city;
    public Address(String province, String city) {
      this.province = province;
      this.city= city;
    }
    // 有getter方法，也有setter方法...
}

public class ImmutableDemo {
    public static void main(String[] args) {
        List<String> originalList = new ArrayList<>();
        originalList.add("a");
        originalList.add("b");
        originalList.add("c");
        List<String> jdkUnmodifiableList = Collections.unmodifiableList(originalList);
        List<String> guavaImmutableList = ImmutableList.copyOf(originalList);
        // jdkUnmodifiableList.add("d"); // 抛出UnsupportedOperationException
        // guavaImmutableList.add("d"); // 抛出UnsupportedOperationException
        originalList.add("d");
        // a,b,c,d
        print(originalList); 
        // a,b,c,d
        print(jdkUnmodifiableList); 
        // a,b,c
        print(guavaImmutableList);
    } 
    private static void print(List<String> list) {
        String join = Joiner.on(",").skipNulls().join(list);
        System.out.println(join);
    }
}