Guava学习笔记-Supplier

还是先贴代码，先跑起来再说^_^，都是抄书上的

public class RegionPredicate implements Predicate<State> {
    @Override
    public boolean apply(State input) {
        return !Strings.isNullOrEmpty(input.getRegion())&&input.getRegion().equals("New York");
    }
}

class ComposedPredicateSupplier implements Supplier<Predicate<String>> {
    @Override
    public Predicate<String> get() {
        City city=new City("Austin,TX");
        State state=new State("Texas");
        state.setCode("TX");
        City city1=new City("New York,NY");
        State state1=new State("New York");
        state1.setCode("NY");
        Map<String,State> stateMap= Maps.newHashMap();
        stateMap.put(state.getCode(),state);
        stateMap.put(state1.getCode(),state1);
        Function<String,State> mf= Functions.forMap(stateMap);

        return Predicates.compose(new RegionPredicate(), mf);
    }
}

/**
 *
 * SupplierDemo接口
 * public interface Supplier<T>{
 *     T get();
 * }
 * get方法返回T的是一个实例，每次get调用可以返回相同的实例（单例）也可以每次返回新实例。
 * Supplier接口提供了一个灵活的延迟初始化机制直到get方法被调用。
 *
 * Supplier<T> Suppliers.memoize(Supplier<T> delegate)
 * 对delegate进行包装，对其get调用将返回delegate.get的执行结果，只有第一次调用时delegate.get会被
 * 执行，Supplier<T>会缓存delegate.get的结果，后面的调用将返回缓存，即单例模式。
 *
 * Supplier<T> memoizeWithExpiration(Supplier<T> delegate, long duration, TimeUnit unit)
 * 功能与memoize相同，但是缓存的结果具有时效性。
 */
public class SupplierDemo {

    @Test
    public void test(){
        ComposedPredicateSupplier composedPredicateSupplier=new ComposedPredicateSupplier();
        Predicate<String> predicate=composedPredicateSupplier.get();
        boolean isNy=predicate.apply("NY");
        System.out.println(isNy);

        Predicate<String> predicate1=composedPredicateSupplier.get();
        System.out.println(predicate==predicate1);

        Supplier<Predicate<String>> wrapped= Suppliers.memoize(composedPredicateSupplier);
        Predicate<String> predicate2=wrapped.get();
        Predicate<String> predicate3=wrapped.get();
        System.out.println(predicate2==predicate3);
    }
}

我想到的应用场景：
1.可以考虑使实体实现Supplier接口，用get作为其实例化方法

2.可以考虑Supplier接口和Suppliers.memoize方法组合，实现单例模式

3.可以考虑Supplier接口和Suppliers.memoizeWithExpiration方法组合，每隔一段时间更新缓存的数据

深入的学习还是看源码，当做一个基础工具的时候，可以考虑引入Guava，当写一个新的方法时可以考虑看看Guava有没有现成的^_^,如果没有，仍然推荐使用Guava实现

一个Guava风格的方法。

参考资料：《Getting Started with Google Guava》