【设计模式】创建型(单例、工厂、建造)

修改记录	修改时间	备注
新建	20201.03.04	设计模式文章集合: 设计原则-SOLID、DRY、KISS、YAGNI、LOD

单例模式

饿汉式

在类加载期间，就已经将 instance 静态实现初始化好，可以保证 instance 实例的创建时线程安全的。不过也导致不支持延迟加载实例。

public class IdGenerator(){
    private IdGenerator(){}
    private AtomicLong id = new AtomicLong(0);
    private static final IdGenerator instance = new IdGenerator();
    
    public static IdGenerator getInstance(){
        retrun instance;
    }
    
    public long getId(){
        retrun id.incrementAndGet();
    }
}

懒汉式

相比较饿汉式，懒汉式支持了延迟加载，但并发度极低(=1)，导致频繁的加锁和释放锁，容易产生性能瓶颈。

public class IdGenerator(){
    private IdGenerator(){}
    private AtomicLong id = new AtomicLong(0);
    private static IdGenerator instance;
    
    public static IdGenerator getInstance(){
        if(instance == null){
            instance = new IdGenerator();
        }
        retrun instance;
    }
    
    public long getId(){
        retrun id.incrementAndGet();
    }
}

双重检测

相较于懒汉式，双重检测既支持延迟加载支持高并发。

public class IdGenerator(){
    private IdGenerator(){}
    private AtomicLong id = new AtomicLong(0);
    private static volatile IdGenerator instance;
    
    public static synchronized IdGenerator getInstance(){
        if(instance == null){
            synchronized(IdGenerator.class){
                if(instance == null){
                    instance = new IdGenerator();
                }
            }
        }
        retrun idGenerator;
    }
    
    public long getId(){
        retrun id.incrementAndGet();
    }
}

静态内部类

相较于双重检测，静态内部类方式实现更简单，同时也支持延迟加载和高并发。

public class IdGenerator(){
    private IdGenerator(){}
    private AtomicLong id = new AtomicLong(0);
    
    private static class IdGeneratorHolder{
        private static final IdGenerator singleton = new IdGenerator();
    }
    
    public static IdGenerator getInstance(){
        retrun IdGeneratorHolder.singleton;
    }
    
    public long getId(){
        retrun id.incrementAndGet();
    }
}

枚举类

最简单的实现方式

public enum IdGenerator{
    INSTANCE;
    private AtomicLong id = new AtomicLong(0);
    
    public long getId(){
        retrun id.incrementAndGet();
    }
}

工厂模式

工厂模式用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。

简单工厂/静态工厂

public class ConfigParserFactory{
    public static IConfigParser createParser(String configFormat){
        IConfigParser parser = null;
        if("json".equalsIgnoreCase(configFormat)){
            parser = new JsonConfigParser();
        }else if("xml".equalsIgnoreCase(configFormat)){
            parser = new XmlConfigParser();
        }else if("properties".equalsIgnoreCase(configFormat)){
            parser = new PropertiesConfigParser();
        }
        return parser;
    }
}
or
public class ConfigParserFactory{
    private static final Map<String,IConfigParser> cacheParser = new HashMap<>();
    
    static{
        cacheParser.push("json",new JsonConfigParser());
        cacheParser.push("xml",new XmlConfigParser());
        cacheParser.push("properties",new PropertiesConfigParser());
    }
    
    public static IConfigParser createParser(String configFormat){
        if(configFormat == null || configFormat.isEmpty){
            return null;
        }
        retrun cacheParser.get(configFormat.toLowerCase());
    }
}

工厂方法

public interface IConfigParserFactory{
    IConfigParser createParser();
}
public class JsonConfigParserFactory implements IConfigParserFactory{
    @Override IConfigParser createParser(){
        return new JsonConfigParser();
    }
}
public class XMLConfigParserFactory implements IConfigParserFactory{
    @Override IConfigParser createParser(){
        return new XmlConfigParser();
    }
}
public class PropertiesConfigParserFactory implements IConfigParserFactory{
    @Override IConfigParser createParser(){
        return new PropertiesConfigParser();
    }
}

public class RuleConfigParserFactoryMap{
    private static final Map<String,IConfigParserFactory> cacheParser = new HashMap<>();
    
    static{
        cacheParser.push("json",new JsonConfigParserFactory());
        cacheParser.push("xml",new XMLConfigParserFactory());
        cacheParser.push("properties",new PropertiesConfigParserFactory());
    }
    
    public static IConfigParserFactory createParser(String configFormat){
        if(configFormat == null || configFormat.isEmpty){
            return null;
        }
        retrun cacheParser.get(configFormat.toLowerCase());
    }
}

抽象工厂

public interface IConfigParserFactory {
  IRuleConfigParser createRuleParser();
  ISystemConfigParser createSystemParser();
  //此处可以扩展新的parser类型，比如IBizConfigParser
}

public class JsonConfigParserFactory implements IConfigParserFactory {
  @Override
  public IRuleConfigParser createRuleParser() {
    return new JsonRuleConfigParser();
  }

  @Override
  public ISystemConfigParser createSystemParser() {
    return new JsonSystemConfigParser();
  }
}

public class XmlConfigParserFactory implements IConfigParserFactory {
  @Override
  public IRuleConfigParser createRuleParser() {
    return new XmlRuleConfigParser();
  }

  @Override
  public ISystemConfigParser createSystemParser() {
    return new XmlSystemConfigParser();
  }
}

建造模式

建造者模式是用来创建复杂对象，可以通过设置不同的可选参数，“定制化”地创建不同的对象。

public class ResourcePoolConfig {
  private String name;
  private int maxTotal;
  private int maxIdle;
  private int minIdle;

  private ResourcePoolConfig(Builder builder) {
    this.name = builder.name;
    this.maxTotal = builder.maxTotal;
    this.maxIdle = builder.maxIdle;
    this.minIdle = builder.minIdle;
  }
  //...省略getter方法...

  //我们将Builder类设计成了ResourcePoolConfig的内部类。
  //我们也可以将Builder类设计成独立的非内部类ResourcePoolConfigBuilder。
  public static class Builder {
    private static final int DEFAULT_MAX_TOTAL = 8;
    private static final int DEFAULT_MAX_IDLE = 8;
    private static final int DEFAULT_MIN_IDLE = 0;

    private String name;
    private int maxTotal = DEFAULT_MAX_TOTAL;
    private int maxIdle = DEFAULT_MAX_IDLE;
    private int minIdle = DEFAULT_MIN_IDLE;

    public ResourcePoolConfig build() {
      // 校验逻辑放到这里来做，包括必填项校验、依赖关系校验、约束条件校验等
      if (StringUtils.isBlank(name)) {
        throw new IllegalArgumentException("...");
      }
      if (maxIdle > maxTotal) {
        throw new IllegalArgumentException("...");
      }
      if (minIdle > maxTotal || minIdle > maxIdle) {
        throw new IllegalArgumentException("...");
      }

      return new ResourcePoolConfig(this);
    }

    public Builder setName(String name) {
      if (StringUtils.isBlank(name)) {
        throw new IllegalArgumentException("...");
      }
      this.name = name;
      return this;
    }

    public Builder setMaxTotal(int maxTotal) {
      if (maxTotal <= 0) {
        throw new IllegalArgumentException("...");
      }
      this.maxTotal = maxTotal;
      return this;
    }

    public Builder setMaxIdle(int maxIdle) {
      if (maxIdle < 0) {
        throw new IllegalArgumentException("...");
      }
      this.maxIdle = maxIdle;
      return this;
    }

    public Builder setMinIdle(int minIdle) {
      if (minIdle < 0) {
        throw new IllegalArgumentException("...");
      }
      this.minIdle = minIdle;
      return this;
    }
  }
}

// 这段代码会抛出IllegalArgumentException，因为minIdle>maxIdle
ResourcePoolConfig config = new ResourcePoolConfig.Builder()
        .setName("dbconnectionpool")
        .setMaxTotal(16)
        .setMaxIdle(10)
        .setMinIdle(12)
        .build();