设计模式-五大创建型模式概念与实现

设计模式（Design pattern）代表了最佳的实践方案，可以说它是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结，通常被有经验的面向对象的软件开发人员所采用。

《Design Patterns - Elements of Reusable Object-Oriented Software 》书中提及23种设计模式，大致可分为三类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）、行为型模式（Behavioral Patterns）

创建型模式

创建型设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象，这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活，主要包含无种设计模式：

• 工厂模式（Factory Pattern）
• 抽象工厂模式（Abstract Factory Pattern）
• 单例模式（Singleton Pattern）
• 建造者模式（Builder Pattern）
• 原型模式（Prototype Pattern）

工厂模式（Factory Pattern）

定义

在创建对象时不会对客户端暴露创建逻辑，也就是说不直接采用new创建对象，而是通过使用一个共同的接口来指向新创建的对象，具体来说定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行，之后让其子类实现工厂接口，返回的是一个抽象的产品。

应用实例

1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

2、Hibernate 换数据库只需换方言和驱动就可以。

优点

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景

1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

工厂模式实现样例

首先通过定义一个Eat接口

public interface Eat {
    void eat();
}

之后定义两个子类去实现Eat接口。 

public class dogEat implements Eat{

    @Override
    public void eat() {
        System.out.println("小狗准备吃饭！");
    }
}

public class catEat implements Eat{

    @Override
    public void eat() {
        System.out.println("小猫准备吃饭！");
    }
}

通过一个工厂类，将类的创建过程延迟到工厂类进行创建，而不是直接用new方法创建dogEat，catEat对象。

public class EatFactory {
    public Eat getEat(String obj){
        if (obj == null) {
            return null;
        }
        if(obj.equalsIgnoreCase("cat")){
            return new catEat();
        }
        else if(obj.equalsIgnoreCase("dog")){
            return new dogEat();
        }
        return null;
    }
}

 创建测试用例，通过工厂模式来获取到两个类的对象，并调用了实现Eat接口后根据实际需求重写的eat方法。

public class FactoryPattern {

    public static void main(String[] args) {
        EatFactory eatFactory = new EatFactory();
        Eat obj1 = eatFactory.getEat("cat");
        obj1.eat();

        Eat obj2 = eatFactory.getEat("dog");
        obj2.eat();
    }
}

 注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，反而会增加系统的复杂度。

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

定义

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类，每个生成的工厂都能按照工厂模式提供对象。

应用实例

现有A型机器人卡布达、金龟次郎等，B型机器人鲨鱼辣椒、蟑螂恶霸等，辅助型机器人车轮滚滚等，每一类机器人只能居住在对应的仓库，比如A型机器人住在A号仓库，而A号仓库、B号仓库等都是属于总仓库类的，由总仓库这个超级工厂去创建，以后如果有C号仓库，也是通过总仓库这个超级工厂去创建新的工厂(C号仓库)，同时C号仓库下的机器人也都是C类机器人（抽象产品）。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

抽象工厂模式实现样例

在工厂模式Eat接口的基础上创建一个新的工厂通过Drink接口去实现，具体方法与工厂类相同。

public interface Drink {
    void drink();
}

public class catDrink implements Drink {

    @Override
    public void drink() {
        System.out.println("小猫准备喝水！");
    }
}

public class dogDrink implements Drink {

    @Override
    public void drink() {
        System.out.println("小狗准备喝水！");
    }
}

接下来创建一个抽象工厂，将每一个具体的工厂的创建交给抽象工厂来实现 

public abstract class AbstractFactory {
    public abstract Eat getEat(String eatObj);
    public abstract Drink getDrink(String drinkObj);
}

接下来让Eat接口与Drink接口继承抽象工厂类，基于给定的信息生成实体类的对象

public class EatAbstractFactory extends AbstractFactory{

    @Override
    public Eat getEat(String eatObj) {
        if (eatObj == null) {
            return null;
        }
        if(eatObj.equalsIgnoreCase("cat")){
            return new catEat();
        }
        else if(eatObj.equalsIgnoreCase("dog")){
            return new dogEat();
        }
        return null;
    }

    @Override
    public Drink getDrink(String drinkObj) {
        return null;
    }
}

public class DrinkAbstractFactory extends AbstractFactory{

    @Override
    public Eat getEat(String eatObj) {
        return null;
    }

    @Override
    public Drink getDrink(String drinkObj) {
        if (drinkObj == null) {
            return null;
        }
        if(drinkObj.equalsIgnoreCase("cat")){
            return new catDrink();
        }
        else if(drinkObj.equalsIgnoreCase("dog")){
            return new dogDrink();
        }
        return null;
    }
}

接下来通过一个工厂创造类通过传递动作对象来获取工厂，降低耦合度 

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if(choice.equalsIgnoreCase("eat")){
            return new EatAbstractFactory();
        }else if(choice.equalsIgnoreCase("drink")){
            return new DrinkAbstractFactory();
        }
        return null;
    }
}

使用测试用例，分别创建Eat和Drink的工厂，并通过工厂来创建对象，实现相应的eat和drink方法。

package com.company.AbstractFactoryPatternDemo;

import com.company.FactoryPatternDemo.Eat;

/**
 * Description :
 * Created by Resumebb
 * Date :2022/4/1
 */
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = FactoryProducer.getFactory("eat");
        Eat obj1 = abstractFactory.getEat("cat");
        obj1.eat();
        Eat obj2 = abstractFactory.getEat("dog");
        obj2.eat();

        AbstractFactory abstractFactory2 = FactoryProducer.getFactory("drink");
        Drink obj3 = abstractFactory2.getDrink("cat");
        obj3.drink();
        Drink obj4 = abstractFactory2.getDrink("dog");
        obj4.drink();
    }
}

 

单例模式（Singleton Pattern）

定义

单例模式仅使用一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，其特点可以总结为：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

应用实例：

• 1、一个班级只有一个班主任。
• 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
• 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

• 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

• 1、要求生产唯一序列号。
• 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

单例模式实现样例

首先创建一个Singleton类，在类中创建一个instance对象，满足第二条，创建自己的唯一实例；之后通过私有化构造函数，保证了这个类不会在外部被实例化，满足第一条，只有一个实例；最后通过getInstance方法满足第三条，为其他类提供这一实例。

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton(){};
    public static Singleton getInstance(){
        return instance;
    }
    public void show(){
        System.out.println("Typing Something！");
    }
}

public class SingletonDemo {
    public static void main(String[] args) {
        Singleton obj = Singleton.getInstance();
        obj.show();
    }
}

 通过getInstance方法可以获取到这个唯一实例，调用show方法也成功打印出了预期信息

 如果不通过getInstance方法想要创建一个新的实例对象时编译就会报错，满足了单例模式的要求。

 单例模式的实现方法

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

最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

所谓懒汉式加载就是请求获取实例时，判断对象是否已经创建，如果已经创建就直接返回instance，只有未创建为null时才会创建对象。

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

2.懒汉式加载（线程安全）

这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。

优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

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

3.饿汉式加载

它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

饿汉式加载与懒汉式不同的就是不会判断instance是否为null，只要你申请实例我就会创建一个instance并返回给你。优点是没有加锁，执行效率会提高，但缺点也很明显类加载时就初始化，浪费内存。饿汉式是线程安全的。

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

4.双重校验锁DLC

JDK1.5以后出现的方式，采用双锁方式，线程安全且在多线程下能保持高性能，volatile能保证实例能实时同步至主存，且只有实例为null准备创建时才会对加锁。

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;  
    }  
}

建造者模式（Builder Pattern）

定义

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象，一个 Builder 类会一步一步构造最终的对象，该 Builder 类是独立于其他对象的，其将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

应用实例

 去KFC，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

优点

1、建造者独立，易扩展。

2、便于控制细节风险。

缺点

1、产品必须有共同点，范围有限制。

2、如内部变化复杂，会有很多的建造类。

使用场景

1、需要生成的对象具有复杂的内部结构。

2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

建造者模式实现样例

首先创建一个接口，包含事物的种类，包装，价格。

public interface Item {
   public String name();
   public Packing packing();
   public float price();    
}

public interface Packing {
   public String pack();
}

创建实现Packing接口的实现类 

public class Wrapper implements Packing {
 
   @Override
   public String pack() {
      return "Wrapper";
   }
}

public class Bottle implements Packing {
 
   @Override
   public String pack() {
      return "Bottle";
   }
}

创建实现 Item 接口的抽象类，该类提供了默认的功能。

public abstract class Burger implements Item {
 
   @Override
   public Packing packing() {
      return new Wrapper();
   }
 
   @Override
   public abstract float price();
}

public abstract class ColdDrink implements Item {
 
    @Override
    public Packing packing() {
       return new Bottle();
    }
 
    @Override
    public abstract float price();
}

 创建扩展了 Burger 和 ColdDrink 的实体类。

public class VegBurger extends Burger {
 
   @Override
   public float price() {
      return 25.0f;
   }
 
   @Override
   public String name() {
      return "Veg Burger";
   }
}

public class ChickenBurger extends Burger {
 
   @Override
   public float price() {
      return 50.5f;
   }
 
   @Override
   public String name() {
      return "Chicken Burger";
   }
}

public class Coke extends ColdDrink {
 
   @Override
   public float price() {
      return 30.0f;
   }
 
   @Override
   public String name() {
      return "Coke";
   }
}

public class Pepsi extends ColdDrink {
 
   @Override
   public float price() {
      return 35.0f;
   }
 
   @Override
   public String name() {
      return "Pepsi";
   }
}

 创建一个 Meal 类，带有上面定义的 Item 对象。

import java.util.ArrayList;
import java.util.List;
 
public class Meal {
   private List<Item> items = new ArrayList<Item>();    
 
   public void addItem(Item item){
      items.add(item);
   }
 
   public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
   }
 
   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : "+item.name());
         System.out.print(", Packing : "+item.packing().pack());
         System.out.println(", Price : "+item.price());
      }        
   }    
}

创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。

public class MealBuilder {
 
   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   
 
   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

最后测试，可以看出建造者模式很关注装配顺序，每一步都是循序渐进，逐步扩展，同时Builder是一个独立组件。

public class BuilderPatternDemo {
   public static void main(String[] args) {
      MealBuilder mealBuilder = new MealBuilder();
 
      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " +vegMeal.getCost());
 
      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("\n\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " +nonVegMeal.getCost());
   }
}

原型模式（Prototype Pattern）

定义

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

意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

主要解决：在运行期建立和删除原型。

何时使用

1、当一个系统应该独立于它的产品创建，构成和表示时。

2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。

3、为了避免创建一个与产品类层次平行的工厂类层次时。

4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

关键代码

1、实现克隆操作，在 JAVA 继承 Cloneable，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。

2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些"易变类"拥有稳定的接口。

应用实例： 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。

优点： 

1、性能提高。

2、逃避构造函数的约束。

缺点： 

1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。

2、必须实现 Cloneable 接口。

使用场景 

1、资源优化场景。

2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。

3、性能和安全要求的场景。

4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

5、一个对象多个修改者的场景。

6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

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

原型模式实现样例

首先创建一个User类作为实现Cloneable接口的一个抽象类

public abstract class User implements Cloneable{
    private String name;
    protected String type;
    abstract void set();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public Object clone(){
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

 创建学生类和教师类扩展为抽象类的实体类

public class Student extends User{
    public Student(){
        type = "班长";
    }

    @Override
    void set() {
        System.out.println("Inside Student set method");
    }
}

public class Teacher extends User{

    public Teacher(){
        type = "班主任";
    }

    @Override
    void set() {
        System.out.println("Inner Teacher set method");
    }
}

 创建一个新类，将数据存储在Hashtable中

public class UserCache {
    private static Hashtable<String, User> userHashtable = new Hashtable<>();

    public static User getUser(String username){
        User user = userHashtable.get(username);
        return (User) user.clone();
    }

    public static void loadCache(){
        Student student = new Student();
        student.setName("张三");
        userHashtable.put(student.getName(), student);

        Teacher teacher = new Teacher();
        teacher.setName("李老师");
        userHashtable.put(teacher.getName(), teacher);
    }
}

创建测试类，通过UserCache类来获取存在Hashtable中的人员类型的克隆

public class PrototypePatternDemo {
    public static void main(String[] args) {
        UserCache.loadCache();

        Student student = (Student) UserCache.getUser("张三");
        System.out.println("学生："+student.getName()+"， 职位："+student.getType());

        Teacher teacher = (Teacher) UserCache.getUser("李老师");
        System.out.println("老师："+teacher.getName()+"， 职位："+teacher.getType());
    }
}

 此处效果不明显，但当复杂情况下，创建对象代价较大，通过将其缓存在本地，这里是通过存储在Hashtable中来充当缓存，在请求创建时，直接返回它的克隆，这样就减少了资源消耗。