Java内功心法，创建型设计模式包括哪些

1. 单例（Singleton）

Intent

确保一个类只有一个实例，并提供该实例的全局访问点。

Class Diagram

使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

Implementation

Ⅰ 懒汉式-线程不安全

以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。

这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (uniqueInstance == null) ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 uniqueInstance = new Singleton(); 语句，这将导致实例化多次 uniqueInstance。

public class Singleton {

    private static Singleton uniqueInstance;

    private Singleton() {

    }

    public static Singleton getUniqueInstance() {

        if (uniqueInstance == null) {

            uniqueInstance = new Singleton();

        }

        return uniqueInstance;

    }

}

Ⅱ 饿汉式-线程安全

线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。

但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。

public class Singleton {

    //线程不安全问题主要是由于 uniqueIntance被实例化了多次，

    //如果uniqueInstance采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全的问题。

    private static Singleton uniqueInstance=new Singleton2();

    private Singleton(){

    }

    public  static Singleton getUniqueInstance(){

        return uniqueInstance;

    }

}

Ⅲ 懒汉式-线程安全

只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。

但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。

public class Singleton{

    //线程不安全问题主要是由于 uniqueIntance被实例化了多次，

    //如果uniqueInstance采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全的问题。

    private static Singleton uniqueInstance;

    private Singleton(){

    }

    //当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待

    public  synchronized static Singleton getUniqueInstance(){

        if(uniqueInstance == null){

           uniqueInstance = new Singleton();

        }

        return uniqueInstance;

    }

}

延迟加载的思想就是一开始不要加载资源或者数据，一直等，等到马上就要使用这个资源或者数据了，躲不过去了才加载，所以也称Lazy Load，不是懒惰啊，是“延迟加载”，这在实际开发中是一种很常见的思想，尽可能的节约资源。
缓存的思想把这些数据缓存到内存里面，每次操作的时候，先到内存里面找，看有没有这些数据，如果有，那么就直接使用，如果没有那么就获取它，并设置到缓存中，下一次访问的时候就可以直接从内存中获取了。从而节省大量的时间，当然，缓存是一种典型的空间换时间的方案。

Ⅳ 双重校验锁-线程安全

uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。

双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {

    }

    public static Singleton getUniqueInstance() {

        if (uniqueInstance == null) {

            synchronized (Singleton.class) {

                if (uniqueInstance == null) {

                    uniqueInstance = new Singleton();

                }

            }

        }

        return uniqueInstance;

    }

}

考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 uniqueInstance = new Singleton(); 这条语句，只是先后的问题，那么就会进行两次实例化。因此必须使用双重校验锁，也就是需要使用两个 if 语句。

if (uniqueInstance == null) {

    synchronized (Singleton.class) {

        uniqueInstance = new Singleton();

    }

}

uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：

为 uniqueInstance 分配内存空间
初始化 uniqueInstance
将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

Ⅴ 静态内部类实现

当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

public class Singleton {

    private Singleton() {

    }

    private static class SingletonHolder {

        private static final Singleton INSTANCE = new Singleton();

    }

    public static Singleton getUniqueInstance() {

        return SingletonHolder.INSTANCE;

    }

}

Ⅵ 枚举实现

public enum Singleton {

    INSTANCE;

    private String objName;

    public String getObjName() {

        return objName;

    }

    public void setObjName(String objName) {

        this.objName = objName;

    }

    public static void main(String[] args) {

        // 单例测试

        Singleton firstSingleton = Singleton.INSTANCE;

        firstSingleton.setObjName("firstName");

        System.out.println(firstSingleton.getObjName());

        Singleton secondSingleton = Singleton.INSTANCE;

        secondSingleton.setObjName("secondName");

        System.out.println(firstSingleton.getObjName());

        System.out.println(secondSingleton.getObjName());

        // 反射获取实例测试

        try {

            Singleton[] enumConstants = Singleton.class.getEnumConstants();

            for (Singleton enumConstant : enumConstants) {

                System.out.println(enumConstant.getObjName());

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

firstName

secondName

secondName

secondName

该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。

该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。

枚举实现(最推荐使用)

public class Singleton {

    private Singleton(){}

    public static Singleton getUniqueInstance(){

        return Singleton.INSTANCE.getSingleton();

    }

    private enum Singleton{

        INSTANCE;

        //如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。

        //而且 Java 要求必须先定义 enum 实例

        private Singleton singleton;

        //JVM保证这个方法绝对只被调用一次

        Singleton(){

            singleton=new Singleton();

        }

        public Singleton getSingleton() {

            return singleton;

        }

    }

}

Examples

Logger Classes
Configuration Classes
Accesing resources in shared mode
Factories implemented as Singletons

JDK

2. 简单工厂（Simple Factory）

Intent

在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。

Class Diagram

简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。

这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。

Implementation

public interface Product {

}

public class ConcreteProduct implements Product {

}

public class ConcreteProduct1 implements Product {

}

public class ConcreteProduct2 implements Product {

}

以下的 Client 类包含了实例化的代码，这是一种错误的实现。如果在客户类中存在这种实例化代码，就需要考虑将代码放到简单工厂中。

public class Client {

    public static void main(String[] args) {

        int type = 1;

        Product product;

        if (type == 1) {

            product = new ConcreteProduct1();

        } else if (type == 2) {

            product = new ConcreteProduct2();

        } else {

            product = new ConcreteProduct();

        }

        // do something with the product

    }

}

以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。

public class SimpleFactory {

    public Product createProduct(int type) {

        if (type == 1) {

            return new ConcreteProduct1();

        } else if (type == 2) {

            return new ConcreteProduct2();

        }

        return new ConcreteProduct();

    }

}

public class Client {

    public static void main(String[] args) {

        SimpleFactory simpleFactory = new SimpleFactory();

        Product product = simpleFactory.createProduct(1);

        // do something with the product

    }

}

简单工厂的优缺点

帮助封装：简单工厂虽然很简单，但是非常友好的帮助我们实现了组件的封装，然后让组件外部能真正面向接口编程。
解耦：通过简单工厂，把客户类和具体子类的实现解耦。
可能增加客户端的复杂度：如果通过客户端的参数来选择具体的实现类，那么就必须让客户端能理解各个参数所代表的具体功能和含义，这会增加客户端使用的难度，也部分暴露了内部实现，这种情况可以选用可配置的方式来实现
不方便扩展子工厂：私有化简单工厂的构造方法，使用静态方法来创建接口，也就不能通过写简单工厂类的子类来改变创建接口的方法的行为了。不过，通常情况下是不需要为简单工厂创建子类的。

3. 工厂方法（Factory Method）

Intent

定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。

Class Diagram

在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。

下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。

Implementation

public abstract class Factory {

    abstract public Product factoryMethod();

    public void doSomething() {

        Product product = factoryMethod();

        // do something with the product

    }

}

public class ConcreteFactory extends Factory {

    public Product factoryMethod() {

        return new ConcreteProduct();

    }

}

public class ConcreteFactory1 extends Factory {

    public Product factoryMethod() {

        return new ConcreteProduct1();

    }

}

public class ConcreteFactory2 extends Factory {

    public Product factoryMethod() {

        return new ConcreteProduct2();

    }

}

JDK

4. 抽象工厂（Abstract Factory）

Intent

提供一个接口，用于创建相关的对象家族。

Class Diagram

抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。

抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。

至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。

从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。

Implementation

public class AbstractProductA {

}

public class AbstractProductB {

}

public class ProductA1 extends AbstractProductA {

}

public class ProductA2 extends AbstractProductA {

}

public class ProductB1 extends AbstractProductB {

}

public class ProductB2 extends AbstractProductB {

}

public abstract class AbstractFactory {

    abstract AbstractProductA createProductA();

    abstract AbstractProductB createProductB();

}

public class ConcreteFactory1 extends AbstractFactory {

    AbstractProductA createProductA() {

        return new ProductA1();

    }

    AbstractProductB createProductB() {

        return new ProductB1();

    }

public class ConcreteFactory2 extends AbstractFactory {

    AbstractProductA createProductA() {

        return new ProductA2();

    }

    AbstractProductB createProductB() {

        return new ProductB2();

    }

}

public class Client {

    public static void main(String[] args) {

        AbstractFactory abstractFactory = new ConcreteFactory1();

        AbstractProductA productA = abstractFactory.createProductA();

        AbstractProductB productB = abstractFactory.createProductB();

        // do something with productA and productB

    }

}

JDK

5. 生成器（Builder）

Intent

封装一个对象的构造过程，并允许按步骤构造。 (将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。)

Class Diagram

要实现同样的构建过程可以创建不同的表现，那么一个自然的思路就是先把构建过程独立出来，在生成器模式中把它称为指导者，由它来指导装配过程，但是不负责每步具体的实现。当然，光有指导者是不够的，必须要有能具体实现每步的对象，在生成器模式中称这些实现对象为生成器。这样一来，指导者就是可以重用的构建过程，而生成器是可以被切换的具体实现。

Implementation1

**

 * 指导者负责指导装配过程，但是不负责每步具体的实现。

 */

public class Director {

    private AbstractComputerBuilder computerBuilder;

    public void setComputerBuilder(AbstractComputerBuilder computerBuilder) {

        this.computerBuilder = computerBuilder;

    }

    public Product getProduct() {

        return computerBuilder.getProduct();

    }

   public void constructComputer() {

        computerBuilder.buildProduct();

        computerBuilder.buildMaster();

        computerBuilder.buildScreen();

        computerBuilder.buildKeyboard();

        computerBuilder.buildMouse();

        computerBuilder.buildAudio();

    }

}

/**

 * 定义一个产品类

 */

public class Product {

    private String master;

    private String screen;

    private String keyboard;

    private String mouse;

    private String audio;

    public void setMaster(String master) {

        this.master = master;

    }

    public void setScreen(String screen) {

        this.screen = screen;

    }

    public String getMaster() {

        return master;

    }

    public String getScreen() {

        return screen;

    }

    public String getKeyboard() {

        return keyboard;

    }

    public void setKeyboard(String keyboard) {

        this.keyboard = keyboard;

    }

    public String getMouse() {

        return mouse;

    }

    public void setMouse(String mouse) {

        this.mouse = mouse;

    }

    public String getAudio() {

        return audio;

    }

    public void setAudio(String audio) {

        this.audio = audio;

    }

}

/**

 * 生成器的抽象类

 * 负责具体实现每步的对象

 */

public abstract class AbstractComputerBuilder {

    protected Product product;

    public Product getProduct() {

        return product;

    }

    public void buildProduct(){

        product=new Product();

        System.out.println("生产出一台电脑");

    }

    public abstract void buildMaster();

    public abstract void buildScreen();

    public abstract void buildKeyboard();

    public abstract void buildMouse();

    public abstract void buildAudio();

}

public class HPComputerBuilder extends AbstractComputerBuilder{

    @Override

    public void buildMaster() {

        // TODO Auto-generated method stub

        product.setMaster("i7,16g,512SSD,1060");

        System.out.println("(i7,16g,512SSD,1060)的惠普主机");

    }

    @Override

    public void buildScreen() {

        // TODO Auto-generated method stub

        product.setScreen("4K");

        System.out.println("(4K)的惠普显示屏");

    }

    @Override

    public void buildKeyboard() {

        // TODO Auto-generated method stub

        product.setKeyboard("cherry 青轴机械键盘");

        System.out.println("(cherry 青轴机械键盘)的键盘");

    }

    @Override

    public void buildMouse() {

        // TODO Auto-generated method stub

        product.setMouse("MI 鼠标");

        System.out.println("(MI 鼠标)的鼠标");

    }

    @Override

    public void buildAudio() {

        // TODO Auto-generated method stub

        product.setAudio("飞利浦 音响");

        System.out.println("(飞利浦 音响)的音响");

    }

}

public class DELLComputerBuilder extends AbstractComputerBuilder{

    @Override

    public void buildMaster() {

        // TODO Auto-generated method stub

        product.setMaster("i7,32g,1TSSD,1060");

        System.out.println("(i7,32g,1TSSD,1060)的戴尔主机");

    }

    @Override

    public void buildScreen() {

        // TODO Auto-generated method stub

        product.setScreen("4k");

        System.out.println("(4k)的dell显示屏");

    }

    @Override

    public void buildKeyboard() {

        // TODO Auto-generated method stub

        product.setKeyboard("cherry 黑轴机械键盘");

        System.out.println("(cherry 黑轴机械键盘)的键盘");

    }

    @Override

    public void buildMouse() {

        // TODO Auto-generated method stub

        product.setMouse("MI 鼠标");

        System.out.println("(MI 鼠标)的鼠标");

    }

    @Override

    public void buildAudio() {

        // TODO Auto-generated method stub

        product.setAudio("飞利浦 音响");

        System.out.println("(飞利浦 音响)的音响");

    }

}

/**

 * 指导者就是可以重用的构建过程，

 * 而生成器是可以被切换的具体实现

 */

public class Client {

    public static void main(String[] args) {

        AbstractComputerBuilder computerBuilder=new HPComputerBuilder();

        AbstractComputerBuilder computerBuilder2=new DELLComputerBuilder();

        Director director=new Director();

        director.setComputerBuilder(computerBuilder);

        director.constructComputer();

        //获取PC

        Product pc=director.getProduct();

        director.setComputerBuilder(computerBuilder2);

        director.constructComputer();

        Product pc2=director.getProduct();

    }

}

生成器的调用顺序：

Implementation2

以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。

public class AbstractStringBuilder {

    protected char[] value;

    protected int count;

    public AbstractStringBuilder(int capacity) {

        count = 0;

        value = new char[capacity];

    }

    public AbstractStringBuilder append(char c) {

        ensureCapacityInternal(count + 1);

        value[count++] = c;

        return this;

    }

    private void ensureCapacityInternal(int minimumCapacity) {

        // overflow-conscious code

        if (minimumCapacity - value.length > 0)

            expandCapacity(minimumCapacity);

    }

    void expandCapacity(int minimumCapacity) {

        int newCapacity = value.length * 2 + 2;

        if (newCapacity - minimumCapacity < 0)

            newCapacity = minimumCapacity;

        if (newCapacity < 0) {

            if (minimumCapacity < 0) // overflow

                throw new OutOfMemoryError();

            newCapacity = Integer.MAX_VALUE;

        }

        value = Arrays.copyOf(value, newCapacity);

    }

}

public class StringBuilder extends AbstractStringBuilder {

    public StringBuilder() {

        super(16);

    }

    @Override

    public String toString() {

        // Create a copy, don't share the array

        return new String(value, 0, count);

    }

}

public class Client {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();

        final int count = 26;

        for (int i = 0; i < count; i++) {

            sb.append((char) ('a' + i));

        }

        System.out.println(sb.toString());

    }

}

abcdefghijklmnopqrstuvwxyz

JDK

6. 原型模式（Prototype）

Intent

使用原型实例指定要创建对象的类型，通过复制这个原型来创建新对象。

Class Diagram

Implementation

public abstract class Prototype {

    abstract Prototype myClone();

}

public class ConcretePrototype extends Prototype {

    private String filed;

    public ConcretePrototype(String filed) {

        this.filed = filed;

    }

    @Override

    Prototype myClone() {

        return new ConcretePrototype(filed);

    }

    @Override

    public String toString() {

        return filed;

    }

}

public class Client {

    public static void main(String[] args) {

        Prototype prototype = new ConcretePrototype("abc");

        Prototype clone = prototype.myClone();

        System.out.println(clone.toString());

    }

}

abc

免费Java高级资料需要自己领取，涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程，一共30G。
传送门：https://mp.weixin.qq.com/s/JzddfH-7yNudmkjT0IRL8Q

巴特西

Java内功心法，创建型设计模式包括哪些

1. 单例（Singleton）

Intent

Class Diagram

Implementation

Ⅰ 懒汉式-线程不安全

Ⅱ 饿汉式-线程安全

Ⅲ 懒汉式-线程安全

Ⅳ 双重校验锁-线程安全

Ⅴ 静态内部类实现

Ⅵ 枚举实现

Examples

JDK

2. 简单工厂（Simple Factory）

Intent

Class Diagram

Implementation

3. 工厂方法（Factory Method）

Intent

Class Diagram

Implementation

JDK

4. 抽象工厂（Abstract Factory）

Intent

Class Diagram

Implementation

JDK

5. 生成器（Builder）

Intent

Class Diagram

Implementation1

Implementation2

JDK

6. 原型模式（Prototype）

Intent

Class Diagram

Implementation

最新文章

热门文章