1. 创建型模式概述

创建型模式关注点是怎样创建出对象

降低系统的耦合度

使用者无需关注对象的创建细节

模式分类

  • 工厂模式：对象的创建由相关的工厂来完成
  • 建造者模式：对象的创建由一个建造者来完成
  • 原型模式：对象的创建由原来对象克隆完成

  • 单例模式：对象始终在系统中只有一个实例

    2. 单例模式

    2.1 特点和应用场景

    模式特点

  • 某个类只能有一个实例；（构造器私有）

  • 它必须自行创建这个实例；（自己编写实例化逻辑）
  • 它必须自行向整个系统提供这个实例；（对外提供实例化方法）

应用场景

  • 多线程中的线程池
  • 数据库的连接池
  • 系统环境信息

  • 上下文（ServletContext）

    2.2 饿汉式

    ```java public class HungrySingleton {

    private static final HungrySingleton INSTANCE = new HungrySingleton();

    private HungrySingleton() {

    }

    public static HungrySingleton getInstance() {

    1.   return INSTANCE;

    }

}

  1. <a name="E7qhY"></a>
  2. ## 2.3 懒汉式
  3. ```java
  4. public class LazySingleton {
  6.     // 防止指令重排序
  7.     private static volatile LazySingleton instance;
  9.     private LazySingleton() {
  11.     }
  13.     public static LazySingleton getInstance() {
  14.         // 这里需要 double-check-lock
  15.         if (instance == null) {
  16.             synchronized (LazySingleton.class) {
  17.                 if (instance == null) {
  18.                     instance = new LazySingleton();
  19.                 }
  20.             }
  21.         }
  22.         return instance;
  23.     }
  25. }

3. 原型模式

3.1 特点和应用场景

模式特点

  • 原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能
  • 本体给外部提供一个克隆体进行使用

应用场景

  • 资源优化
  • 性能和安全要求
  • 一个对象多个修改者的场景
  • 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时可以考虑使用原型模式拷贝多个对象供调用者使用

浅拷贝和深拷贝

  • 浅复制：只是拷贝了基本类型的数据，而引用类型数据复制后也是会发生引用，浅复制仅仅是指向被复制的内存地址，如果原地址中对象被改变了，那么浅复制出来的对象也会相应改变

  • 深复制：在计算机中开辟了一块新的内存地址用于存放复制的对象

    3.2 案例

    ```java @Data public class Book implements Cloneable {

    private String title; private Image image;

    @Override protected Book clone() throws CloneNotSupportedException {

    1.   Book book = (Book) super.clone();
    2.   // 深拷贝
    3.   book.setImage((Image) this.image.clone());
    4.   return book;

    }

}

@Data @NoArgsConstructor @AllArgsConstructor public class Image implements Cloneable {

  1. public String name;
  3. @Override
  4. protected Object clone() throws CloneNotSupportedException {
  5.     return super.clone();
  6. }

}

  1. ```java
  2. public class ProtoTypeTest {
  4.     public static void main(String[] args) throws Exception{
  5.         Book book1 = new Book();
  6.         book1.setTitle("《三体》");
  7.         book1.setImage(new Image("图片1"));
  8.         // 以原型方式拷貝一份
  9.         Book book2 = book1.clone();
  10.         book2.getImage().setName("图片2");
  11.         System.out.println(book1);
  12.         System.out.println(book2);
  13.     }
  15. }

4. 工厂模式

4.1 特点和应用场景

模式特点
工厂模式（Factory Pattern）提供了一种创建对象的最佳方式。我们不必关心对象的创建细节，只需要根据不同情况获取不同产品即可

应用场景

  • NumberFormat、SimpleDateFormatLoggerFactory
  • SqlSessionFactory（MyBatis）
  • BeanFactory（Spring）

工厂模式的退化

  • 当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式
  • 当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式

4.2 简单工厂模式

简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可
但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护

包含角色

  • Factory：工厂角色
  • 抽象产品角色

  • CarConcreteProduct：具体产品角色 ```java public interface Car {

    void run();

    class AoDi implements Car {

    1.   @Override
    2.   public void run() {
    3.       System.out.println("奥迪跑起来");
    4.   }

    }

    class JiLi implements Car {

    1.   @Override
    2.   public void run() {
    3.       System.out.println("吉利跑起来");
    4.   }

    }

}

  1. ```java
  2. public class CarFactory {
  4.     /**
  5.      * 简单工厂三个角色
  6.      * Factory: 工厂角色
  7.      * Product: 抽象产品
  8.      * ConcreteProduct: 具体产品角色
  9.      * <p>
  10.      * 缺点: 违背开闭，扩展不易
  11.      */
  12.     public static Car createCar(String name) {
  13.         if (name.equals("奥迪")) {
  14.             return new Car.AoDi();
  15.         }
  16.         if (name.equals("吉利")) {
  17.             return new Car.JiLi();
  18.         }
  19.         return null;
  20.     }
  22. }

4.3 工厂方法模式

工厂方法模式又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做
该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节

包含角色

  • Product：抽象产品
  • ConcreteProduct：具体产品
  • Factory：抽象工厂

  • ConcreteFactory：具体工厂 ```java public interface Car {

    void run();

    class AoDi implements Car {

    1.   @Override
    2.   public void run() {
    3.       System.out.println("奥迪跑起来");
    4.   }

    }

    class JiLi implements Car {

    1.   @Override
    2.   public void run() {
    3.       System.out.println("吉利跑起来");
    4.   }

    }

}

  1. ```java
  2. public interface CarFactory {
  4.     /**
  5.      * 工厂方法四个角色
  6.      * Product: 抽象产品
  7.      * ConcreteProduct: 具体产品角色
  8.      * Factory: 抽象工厂
  9.      * ConcreteFactory：具体工厂
  10.      * <p>
  11.      * 缺点: 系统复杂度增加，产品单一
  12.      */
  13.     Car createCar();
  15.     class AoDiFactory implements CarFactory {
  17.         @Override
  18.         public Car createCar() {
  19.             return new Car.AoDi();
  20.         }
  21.     }
  23.     class JiLiFactory implements CarFactory {
  25.         @Override
  26.         public Car createCar() {
  27.             return new Car.JiLi();
  28.         }
  29.     }
  31. }

4.4 抽象工厂模式

抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品

  1. public interface Car {
  3.     void run();
  5.     class AoDi implements Car {
  7.         @Override
  8.         public void run() {
  9.             System.out.println("奥迪跑起来");
  10.         }
  11.     }
  13.     class JiLi implements Car {
  15.         @Override
  16.         public void run() {
  17.             System.out.println("吉利跑起来");
  18.         }
  19.     }
  21. }
  1. public interface Pen {
  3.     void write();
  5.     class Pencil implements Pen {
  7.         @Override
  8.         public void write() {
  9.             System.out.println("用铅笔写字");
  10.         }
  11.     }
  13.     class BallPen implements Pen {
  15.         @Override
  16.         public void write() {
  17.             System.out.println("用圆珠笔写字");
  18.         }
  19.     }
  21. }
  1. public interface IFactory {
  3.     default Car createCar() {
  4.         return null;
  5.     }
  7.     default Pen createPen() {
  8.         return null;
  9.     }
  11.     /**
  12.      * 抽象工厂创建的汽车抽象工厂
  13.      */
  14.     interface CarFactory extends IFactory {
  16.         class AoDiFactory implements CarFactory {
  18.             @Override
  19.             public Car createCar() {
  20.                 return new Car.AoDi();
  21.             }
  22.         }
  24.         class JiLiFactory implements CarFactory {
  26.             @Override
  27.             public Car createCar() {
  28.                 return new Car.JiLi();
  29.             }
  30.         }
  32.     }
  34.     /**
  35.      * 抽象工厂创建的笔抽象工厂
  36.      */
  37.     interface PenFactory extends IFactory {
  39.         class PencilFactory implements PenFactory {
  41.             @Override
  42.             public Pen createPen() {
  43.                 return new Pen.Pencil();
  44.             }
  45.         }
  47.         class BallPenFactory implements PenFactory {
  49.             @Override
  50.             public Pen createPen() {
  51.                 return new Pen.BallPen();
  52.             }
  53.         }
  55.     }
  57. }

5. 建造者模式

5.1 特点和应用场景

模式特点
与工厂模式的区别是：建造者模式更加关注细节，屏蔽过程而不屏蔽细节

包含角色

  • 产品角色（Product）
  • 抽象建造者（Builder）
  • 具体建造者(Concrete Builder）

应用场景

  • StringBuilder append()
  • Swagger ApiBuilder

  • Lombok @Builder 注解

    5.2 案例

    ```java @Data public class Phone {

    private String cpu;

    private String mem;

    private String disk;

}

  1. ```java
  2. public interface PhoneBuilder {
  4.     PhoneBuilder cpu(String cpu);
  6.     PhoneBuilder mem(String mem);
  8.     PhoneBuilder disk(String disk);
  10.     Phone build();
  12.     /**
  13.      * 产品角色（Product）：Phone
  14.      * 抽象建造者（Builder）：PhoneBuilder
  15.      * 具体建造者(Concrete Builder）：XiaomiPhoneBuilder
  16.      */
  17.     class XiaomiPhoneBuilder implements PhoneBuilder {
  19.         private Phone phone;
  21.         public XiaomiPhoneBuilder() {
  22.             this.phone = new Phone();
  23.         }
  25.         @Override
  26.         public PhoneBuilder cpu(String cpu) {
  27.             this.phone.setCpu(cpu);
  28.             return this;
  29.         }
  31.         @Override
  32.         public PhoneBuilder mem(String mem) {
  33.             this.phone.setMem(mem);
  34.             return this;
  35.         }
  37.         @Override
  38.         public PhoneBuilder disk(String disk) {
  39.             this.phone.setDisk(disk);
  40.             return this;
  41.         }
  43.         @Override
  44.         public Phone build() {
  45.             return this.phone;
  46.         }
  47.     }
  49. }