光子CI之旅

//本例只用来说明第一大优势，请不要纠结其它问题 
public class Foo {
         Set<Bar> bars;
         List<Car> cars;
         //构造器1
         private Foo(Set<Bar> bars) {
                 this.bars = bars;
         }
         //构造器2
         private Foo(List<Car> cars) {
                 this.cars = cars;
         }
         //构造器3
         private Foo(Set<Bar> bars, List<Car> cars) {
                 this.bars = bars;
                 this.cars = cars;
         }
         //静态工厂方法1
         public static Foo newInstanceByBar(){
                 return new Foo(new HashSet<Bar>());
         }
         //静态工厂方法2
         public static Foo newInstanceByCar(){
                 return new Foo(new ArrayList<Car>());
         }
         //静态工厂方法3
         public static Foo newInstanceByAll(){
                 return new Foo(new HashSet<Bar>(),new ArrayList<Car>());
         }
         public static void main(String[] args) {
                 // 通过构造器创建实例，不好区分容易使用错误
                 Foo fbar = new Foo(new HashSet<Bar>());
                 Foo fcar = new Foo(new ArrayList<Car>());
                 Foo fall = new Foo(new HashSet<Bar>(),new ArrayList<Car>());
                  // 通过静态工厂方法可以清晰的用方法名识别
                 Foo fbar_static = Foo.newInstanceByBar();
                 Foo fcar_static = Foo.newInstanceByCar();
                 Foo fall_static = Foo.newInstanceByAll();
         }
  }
  class Bar {}
  class Car {} 

List<Type> exactly100 = Lists.newArrayListWithCapacity(100);
List<Type> approx100 = Lists.newArrayListWithExpectedSize(100); 
Set<Type> approx100Set = Sets.newHashSetWithExpectedSize(100);

// 服务提供框架示意模型 - 服务API 
public interface ServiceAPI {
         // 这里是服务指定的方法
 }
// 服务提供框架示意模型 - 服务SPI 
public interface ServiceSPI {
         ServiceAPI newService();
 }  
// 服务提供框架示意模型实现 
// 不可实例化的类，用来注册创建和提供访问 
public class ServiceFramework {
         private ServiceFramework() {
         }// 强制防止实例化（规则4）

         // 映射服务名到服务
         private static final ConcurrentMap<String, ServiceSPI> spis = new MapMaker().makeMap();//使用Guava创建
         public static final String DEFAULT_SPI_NAME = "<def>";

         // 默认SPI注册API
         public static void registerDefaultSPI(ServiceSPI spi) {
                 registerSPI(DEFAULT_SPI_NAME, spi);
         }

         // 指定SPI注册API
         public static void registerSPI(String name, ServiceSPI spi) {
                 spis.put(name, spi);
         }

         // 服务访问API
         public static ServiceAPI newInstance() {
                 return newInstance(DEFAULT_SPI_NAME);
         }
         public static ServiceAPI newInstance(String name) {
                 ServiceSPI spi = spis.get(name);
                 if(spi == null)
                         throw new IllegalArgumentException(
                                         "No provider registered with name: " + name);
                 return spi.newService();
         }
 }

// 简单的服务提供框架测试程序 
public class Test {
         public static void main(String[] args) {
                 // 服务提供商执行下面的注册
                 ServiceFramework.registerDefaultSPI(DEFAULT_PROVIDER);
                 ServiceFramework.registerSPI("comp", COMP_PROVIDER);
                 ServiceFramework.registerSPI("armed", ARMED_PROVIDER);
                  // 客户端执行下面的创建
                 ServiceAPI s1 = ServiceFramework.newInstance();
                 ServiceAPI s2 = ServiceFramework.newInstance("comp");
                 ServiceAPI s3 = ServiceFramework.newInstance("armed");
                 System.out.printf("%s, %s, %s%n", s1, s2, s3);
         }
          private static ServiceSPI DEFAULT_PROVIDER = new ServiceSPI() {
                 public ServiceAPI newService() {
                         return new ServiceAPI() {
                                 @Override
                                 public String toString() {
                                         return "默认服务";
                                 }
                         };
                 }
         };
          private static ServiceSPI COMP_PROVIDER = new ServiceSPI() {
                 public ServiceAPI newService() {
                         return new ServiceAPI() {
                                 @Override
                                 public String toString() {
                                         return "Complementary 服务";
                                 }
                         };
                 }
         };
          private static ServiceSPI ARMED_PROVIDER = new ServiceSPI() {
                 public ServiceAPI newService() {
                         return new ServiceAPI() {
                                 @Override
                                 public String toString() {
                                         return "Armed 服务";
                                 }
                         };
                 }
         };
 }
  
//输出如下 默认服务, Complementary 服务, Armed 服务

List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<TypeThatsTooLongForItsOwnGood>();

List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<>();

Set<Type> copySet = Sets.newHashSet(elements); 
List<String> theseElements = Lists.newArrayList("alpha", "beta", "gamma");