创建型模式

本文主要介绍一下设计模式中的创建型模式。

开篇之前，先说一下，什么是设计模式，一言以蔽之，设计模式是代码设计经验的总结。设计模式的原理非常简单，但是也绝不可能通过一篇文章或者一本书来完全掌握（在学习任何一种知识的时候都应该博采众长，取舍有度，而不是盯着一本书或者一篇文章看，偏信一家之言，要如鲁迅所说：“运用脑髓，放出眼光，自己来拿！”）。其次，死记硬背设计模式的UML图或者示例代码没有意义，和OOP编程一下，设计模式本质上是一种思想，须得领会后方能灵活运用。

设计模式主要基于以下两个面向对象的编程思想：

• 面向接口编程
• 组合优于继承

设计模式还有所谓的六大原则，这里择其重点说明一下：

• 对扩展开放，对修改关闭
• 任何基类可以出现的地方，子类一定可以出现。理解这个原则：只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。
• 使用多个隔离的接口，比使用单个接口要好
• 一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立

创建型模式，顾名思义，就是一种创建对象的方法。

创建型模式有五种：工厂、抽象工厂、单例、建造者、原型。

工厂

工厂模式在工厂、策略和桥接这篇文章中已经介绍过，这里不再赘述。

抽象工厂

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

先看图：

image

再看代码：

public interface Shape {
   void draw();
}

public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

public interface Color {
   void fill();
}

public class Green implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}

public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() method.");
   }
}

public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape) ;
}

public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      return null;
   }
}

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
 
      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取形状为 Rectangle 的对象
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
      
      //获取形状为 Square 的对象
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
 
      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
 
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
 
      //调用 Red 的 fill 方法
      color1.fill();
 
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("Green");
 
      //调用 Green 的 fill 方法
      color2.fill();
 
      //获取颜色为 Blue 的对象
      Color color3 = colorFactory.getColor("BLUE");
 
      //调用 Blue 的 fill 方法
      color3.fill();
   }
}

总结：抽象工厂相较于工厂而言，多了一个产品族的概念，实际上就是在工厂接口下再做一个细分。

单例

单例模式在多线程下的单例模式这篇文章已经有过初步介绍，这里详细列出：

1. 懒汉式，线程不安全，懒加载

   public class Singleton {  
       private static Singleton instance;  
       private Singleton (){}  
     
       public static Singleton getInstance() {  
           if (instance == null) {  
               instance = new Singleton();  
           }  
           return instance;  
       }  
   }
   

2. 懒汉式，线程安全，懒加载

   加锁会影响效率。

   public class Singleton {  
       private static Singleton instance;  
       private Singleton (){}  
       public static synchronized Singleton getInstance() {  
           if (instance == null) {  
               instance = new Singleton();  
           }  
           return instance;  
       }  
   }
   

3. 饿汉式，线程安全，非懒加载，常用

   没有加锁，执行效率会提高。

   类加载时就初始化，浪费内存：虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

   public class Singleton {  
       private static Singleton instance = new Singleton();  
       private Singleton (){}  
       public static Singleton getInstance() {  
        return instance;  
       }  
   }
   

4. 双重校验锁，线程安全，懒加载

   4和2比较起来，可以在保证线程安全的情况下依然保持高性能。

   public class Singleton {  
       private volatile static Singleton singleton;  
       private Singleton (){}  
       public static Singleton getSingleton() {  
           if (singleton == null) {  
               synchronized (Singleton.class) {  
                   if (singleton == null) {  
                       singleton = new Singleton();  
                   }  
               }  
           }  
           return singleton;  
       }  
   }
   

5. 使用静态内部类，线程安全，懒加载

   这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

   public class Singleton {  
       private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
       }  
       private Singleton (){
           
       }  
       public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
       }  
   }
   

6. 使用枚举，线程安全，非懒加载

   这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。

   public enum Singleton {  
       INSTANCE;  
       public void whateverMethod() {
       }  
   }
   

   总结一下：加锁降低执行效率，非懒加载产生垃圾对象，浪费内存。根据具体场景决定使用哪种方式。

建造者

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种模式的应用非常广泛，比如Java中的StringBuilder，Android中的AlertDialog.Builder。

用一个组装计算机的例子来说明。

先上图：这张图里的聚合和依赖关系标注有误，具体结合代码理解。

聚合关系（成员）：如果A由B聚合成，表现为A包含有B的全局对象，但是B对象可以不在A创建的时刻创建。

组合关系（成员）：如果A由B组成，表现为A包含有B的全局对象，并且B对象在A创建的时刻创建。

依赖关系（局部）：如果A依赖于B，则B体现为局部变量，方法的参数、或静态方法的调用。

所以这里应该是Director由Builder组合而成，MacBookBuilder由MacBook组合而成。图上有误。

image

再上代码：

public class MacBook{ 
    protected MacBook() {
    }
    
    public void setBoard(String board){
        mBoard=board;
    }
 
    public void setDisplay(String display) {
        this.mDisplay = display;
    }
}

// 可以使用抽象类，也可以使用接口
public abstract class Builder {
    abstract void buildBoard(String board);
    abstract void buildDisplay(String display);
    abstract MacBook build();
}

public class MacBookBuilder extends Builder {
 
    private MacBook mMacBook = new MacBook();
    
    @Override
    void buildBoard(String board) {
        mMacBook.setBoard(board);
    }
 
    @Override
    void buildDisplay(String display) {
        mMacBook.setDisplay(display);
    }
 
    @Override
    Computer build() {
        return mMacBook;
    }
}

public class Director {
    Builder mBuilder=null;
 
    public Director(Builder builder) {
        this.mBuilder = builder;
    }
 
    public void construct(String board,String display){
        mBuilder.buildDisplay(display);
        mBuilder.buildBoard(board);
    }
}

// 具体使用
public class Test {
 
    public static void main(String[] args){
        // 定义每个建造环节的具体实现
        Builder builder = new MacBookBuilder();
        
        // 设计建造流程，将各个环节组装排序
        Director director = new Director(builder);
        director.construct("英特尔主板", "Retina显示器");
 
        MacBook macBook = builder.build();
    }
 
}

原型

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

用代码直观理解一下：

public abstract class Shape implements Cloneable {
   
   private String id;
   protected String type;
   
   abstract void draw();
   
   public String getType(){
      return type;
   }
   
   public String getId() {
      return id;
   }
   
   public void setId(String id) {
      this.id = id;
   }
   
   public Object clone() {
      Object clone = null;
      try {
         clone = super.clone();
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
      return clone;
   }
}

public class Rectangle extends Shape {
 
   public Rectangle(){
     type = "Rectangle";
   }
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

public class Square extends Shape {
 
   public Square(){
     type = "Square";
   }
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

public class Circle extends Shape {
 
   public Circle(){
     type = "Circle";
   }
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}
 
// 从数据库获取实体类，并把它们存储在一个 Hashtable 中。
public class ShapeCache {
    
   private static Hashtable shapeMap 
      = new Hashtable();
 
   public static Shape getShape(String shapeId) {
      Shape cachedShape = shapeMap.get(shapeId);
      return (Shape) cachedShape.clone();
   }
 
   // 对每种形状都运行数据库查询，并创建该形状
   // shapeMap.put(shapeKey, shape);
   // 例如，我们要添加三种形状
   public static void loadCache() {
      Circle circle = new Circle();
      circle.setId("1");
      shapeMap.put(circle.getId(),circle);
 
      Square square = new Square();
      square.setId("2");
      shapeMap.put(square.getId(),square);
 
      Rectangle rectangle = new Rectangle();
      rectangle.setId("3");
      shapeMap.put(rectangle.getId(),rectangle);
   }
}

public class PrototypePatternDemo {
   public static void main(String[] args) {
      ShapeCache.loadCache();
 
      Shape clonedShape = (Shape) ShapeCache.getShape("1");
      System.out.println("Shape : " + clonedShape.getType());        
 
      Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
      System.out.println("Shape : " + clonedShape2.getType());        
 
      Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
      System.out.println("Shape : " + clonedShape3.getType());        
   }
}

注意：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

微信公众号 长夜西风

个人网站 http://www.cmder.info/