设计模式（一）| 创建型模式（单例模式、原型模式等）

• UML以及七大原则总结
• 设计模式总览
• • 单例模式
  • 原型模式
  • 工厂模式
  • • 1.简单工厂模式
    • 2.工厂方法模式
    • 3.抽象工厂模式
  • 建造者模式

！！！！

• 概述

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

• 饿汉式（无法实现延迟加载，系统一开始就存在这个对象无论你用不用）

直接赋值：

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


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

枚举：

public enum EnumSingleton {
    
    instance;
}

• 懒汉式（受制于锁的性能限制）

这里对于懒汉式的双重锁定做了很详细的解析

public class VUGDoubleLock {
    private static volatile VUGDoubleLock vugDoubleLock;

    private VUGDoubleLock() {
    }

    public static VUGDoubleLock getInstance(){
        if(vugDoubleLock == null)
            synchronized (VUGDoubleLock.class){
                if(vugDoubleLock == null)
                    vugDoubleLock = new VUGDoubleLock();
            }
        System.out.println("双重检测锁！");
        return vugDoubleLock;
    }

    public static void main(String[] args) {
        VUGDoubleLock instance = VUGDoubleLock.getInstance();
    }
}

• IoDH

汉式单例类不能实现延迟加载，不管将来用不用始终占据内存；懒汉式单例类线程安全控制烦琐，而且性能受影响

Initialization Demand Holder (IoDH)：在IoDH中，我们在单例类中增加一个静态(static)内部类，在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用

由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

通过使用IoDH，我们既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现方式（其缺点是与编程语言本身的特性相关，很多面向对象语言不支持IoDH）。

public class VUGIoDH {
    private VUGIoDH() {}

    private static class HolderClass{
        private static final VUGIoDH instance = new VUGIoDH();
    }

    public static VUGIoDH getInstance(){
        System.out.println("IoDH单例对象建立");
        return HolderClass.instance;
    }

    public static void main(String[] args) {
        VUGIoDH instance = VUGIoDH.getInstance();
    }

}

• 优点

• 提供了对唯一实例的受控访问
• 可以节约系统资源，提高系统的性能
• 允许可变数目的实例（多例类）

缺点

• 扩展困难（缺少抽象层）
• 单例类的职责过重

• 概述

• 复制一个对象，从而克隆出多个与原型对象一模一样的对象——原型模式
• 有些对象的创建过程较为复杂，而且需要频繁创建
• 通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象

• Java中的克隆方式

• 所有的Java类都继承自java.lang.Object，而Object类提供一个clone()方法，可以将一个Java对象复制一份
• 在Java中可以直接使用Object提供的clone()方法来实现对象的克隆（浅克隆）
• 能够实现克隆的Java类必须实现一个标识接口Cloneable，表示这个Java类支持复制
• 如果一个类没有实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异常

this.clone() == this;		//false，浅拷贝

代码演示：

先要实现Cloneable接口，然后可以利用这个机制去得到存储在缓存中的对象，而对实际的对象不做任何影响，但是实际上有spring的Bean复制方法会更快

class User implements Cloneable{
    String username;
    String password;

    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return new User(username, password);
    }
}

• 浅克隆：当原型对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制

• 深克隆：除了对象本身被复制外，对象所包含的所有成员变量也将被复制

• 优点

• 简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率
• 扩展性较好
• 简化创建结构，原型模式中产品的复制是通过封装在原型类中的克隆方法实现的，无须专门的工厂类来创建产品
• 可以使用深克隆的方式保存对象的状态，以便在需要的时候使用，可辅助实现撤销操作

• 缺点

• 需要为每一个类配备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有的类进行改造时，需要修改源代码，违背了开闭原则
• 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重的嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来可能会比较麻烦

• 概述

• 简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式
• 在简单工厂模式中，可以根据参数的不同返回不同类的实例
• 简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类

• 角色构成
  

• 代码实例

public class SimplyFactory {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.initShape("Circle");
        circle.draw();
        circle.erase();
        System.out.println("-----------------");
        Shape triangle = ShapeFactory.initShape("Triangle");
        triangle.draw();
        triangle.erase();
    }
}


public class ShapeFactory {
    public static Shape initShape(String arg){
        if(arg.equals("Circle"))
            return new Circle();
        else if(arg.equals("Triangle"))
            return new Triangle();
        else if(arg.equals("Rectangle"))
            return new Rectangle();
        else
            try {
                throw new UnsupportedShapeException("图形不存在！");
            } catch (UnsupportedShapeException e) {
                e.printStackTrace();
            }
        return null;
    }
}


public interface Shape {
    void draw();
    void erase();
}


public class Triangle implements Shape{
    @Override
    public void draw() {
        System.out.println("画三角形");
    }

    @Override
    public void erase() {
        System.out.println("擦三角形");
    }
}

• 优点

• 实现了对象创建和使用的分离
• 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可
• 通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性

• 缺点

• 工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响
• 增加系统中类的个数（引入了新的工厂类），增加了系统的复杂度和理解难度
• 系统扩展困难，一旦添加新产品不得不修改工厂逻辑
• 由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构，工厂类不能得到很好地扩展

• 概述

• 工厂方法模式(Factory Method Pattern)简称工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式。
• 在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
• 可以说工厂方法模式就是为了解决简单工厂模式无法实现开闭原则而诞生的
  

• 成员构造
  
• 代码实例

public class FactoryMethod {
    public static void main(String[] args) {
        System.out.println("创建HTTP连接");

        Connection http = new HTTPFactory().getConnection();
        http.connect();

        System.out.println("---------------------");
        System.out.println("创建IMAP连接");
        Connection imap = new IMAPFactory().getConnection();
        imap.connect();

        System.out.println("---------------------");
        System.out.println("创建pop3连接");
        Connection pop3 = new POP3Factory().getConnection();
        pop3.connect();

    }
}


public interface Connection {
    void connect();

    void disconnect();

}


public class HTTPConnection implements Connection{
    @Override
    public void connect() {
        System.out.println("开始连接");
    }

    @Override
    public void disconnect() {
        System.out.println("断开连接");
    }
}


public interface ConnectionFactory {
    Connection getConnection();
}


public class HTTPFactory implements ConnectionFactory{
    @Override
    public Connection getConnection() {
        return new HTTPConnection();
    }
}

• 优点

• 工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节
• 能够让工厂自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部
• 在系统中加入新产品时，完全符合开闭原则

• 缺点

• 系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，会给系统带来一些额外的开销
• 增加了系统的抽象性和理解难度

• 概述

为了更好地体现不同品牌产品的结构

• 模式结构
  
• 代码实例

创造不同游戏场景的抽象工厂，某个场景的天气、地图、背景音乐

• 横坐标划分产品族为：某个具体场景的天气、地图、背景音乐
• 纵坐标划分相同的产品等级结构（不同的天气、不同的地图）
  

public interface AbstractFactory {
    AbstractMap getMap();
    AbstractWeather getWeather();
    AbstractSound getSound();
}


public interface AbstractMap {
    void map();
}


public interface AbstractSound {
    void sound();
}


public interface AbstractWeather {
    void weather();
}


public class DesertFactory implements AbstractFactory{

    @Override
    public AbstractMap getMap() {
        return null;
    }

    @Override
    public AbstractWeather getWeather() {
        return null;
    }

    @Override
    public AbstractSound getSound() {
        return null;
    }
}


public class DesertMap implements AbstractMap {
    @Override
    public void map() {
    }
}


public class DesertSound implements AbstractSound {
    @Override
    public void sound() {
    }
}


public class DesertWeather implements AbstractWeather {
    @Override
    public void weather() {
    }
}

• 优点

• 隔离了具体类的生成，使得客户端并不需要知道什么被创建
• 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象
• 增加新的产品族很方便，无须修改已有系统，符合开闭原则

• 缺点

增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了开闭原则

• 概述

• 建造者模式(Builder Pattern)：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
• 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。

• 模式结构

• 代码演示

public class Builder {
    public static void main(String[] args) {
        CarWaiter carWaiter = new CarWaiter();
        //这里可以动态加载
        carWaiter.setCarBuilder(new FormulaCarBuilder());
        Car formulaCar = carWaiter.init();
        formulaCar.show();
    }
}


@Data
@ToString
public class Car {
    //车身
    private String body;
    //发动机
    private String engine;
    //轮胎
    private String tyre;
    //变速箱
    private String gearbox;
}


public abstract class CarBuilder {
    protected Car car = new Car();

    public abstract void buildBody();
    public abstract void buildEngine();
    public abstract void buildTyre();
    public abstract void buildGearbox();

    public Car getCar(){
        return car;
    }
}


public class CarWaiter {
    private CarBuilder carBuilder;

    public void setCarBuilder(CarBuilder carBuilder){
        this.carBuilder = carBuilder;
    }

    public Car init(){
        carBuilder.buildBody();
        carBuilder.buildEngine();
        carBuilder.buildTyre();
        carBuilder.buildGearbox();
        return carBuilder.getCar();
    }
}


public class FormulaCarBuilder extends CarBuilder{
    @Override
    public void buildBody() {
        car.setBody("方程式赛车车身");
    }

    @Override
    public void buildEngine() {
        car.setEngine("方程式赛车引擎");
    }

    @Override
    public void buildTyre() {
        car.setTyre("方程式赛车轮胎");
    }

    @Override
    public void buildGearbox() {
        car.setGearbox("方程式赛车变速箱");
    }
}


public class OffRoadRacingCarBuilder extends CarBuilder{

    @Override
    public void buildBody() {
        car.setBody("场地越野赛车车身");
    }

    @Override
    public void buildEngine() {
        car.setEngine("场地越野赛车引擎");
    }

    @Override
    public void buildTyre() {
        car.setTyre("场地越野赛车轮胎");
    }

    @Override
    public void buildGearbox() {
        car.setGearbox("场地越野赛车变速箱");
    }
}

• 优点

1. 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
2. 每一个具体建造者都相对独立，与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，扩展方便，符合开闭原则
3. 可以更加精细地控制产品的创建过程

• 缺点

1. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，不适合使用建造者模式，因此其使用范围受到一定的限制
2. 如果产品的内部变化复杂，可能会需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加了系统的理解难度和运行成本