23种设计模式-创建型模式总结

儒雅的小卒

已于 2023-07-05 17:42:36 修改

阅读量481

点赞数

分类专栏： Java学习文章标签：设计模式 java 单例模式

于 2020-03-15 22:31:55 首次发布

本文链接：https://blog.csdn.net/weixin_42285505/article/details/104888344

版权

Java学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

创建型模式总结

创建型模式总结

一. 单例模式

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

单例模式的优点：

单例模式只生成一个实例，减少了系统的开销，当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久贮存在内存中来解决。
单例模式可以在系统设置全局的访问点，优化环境共享资源访问，例如可以设计一个单例类，负责所有数据的映射处理。
单例模式的应用场景

常见的五种单例模式实现方式

1. 主要

1.1 饿汉式（线程安全，调用率高。但是不能延时加载。）

饿汉式实现

package cn.design.singleton01;
/*测试饿汉式单例模式*/
public class SingletonDemo1 {
    //1.提供一个静态的私有对象
    private static SingletonDemo1 instance = new SingletonDemo1();//类初始化时，立即加载该对象。（无论是否调用该对象，都会加载，没有延时加载的优势）
    //2.构造器私有
    private SingletonDemo1(){}
    //3.提供一个全局的访问点(由于类加载器在加载静态对象时，天然的线程安全，所以该方法没有同步，调用效率高。)
    public static SingletonDemo1 getInstance() {
        return instance;
    }
}

1.1 懒汉式（线程安全，调用率不高。但是可以延时加载。）

懒汉式实现

package cn.design.singleton01;
/*测试懒汉式单例模式*/
public class SingletonDemo2 {
    //1.提供一个静态的私有对象属性，但是没有初始化，真正使用时候再创建
    private static SingletonDemo2 instance ;
    //2.构造器私有
    private SingletonDemo2(){}
    //3.提供一个全局的访问点(方法同步，调用效率低)
    public static synchronized SingletonDemo2 getInstance() {
        if(instance == null){
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

2. 其他

2.1 双重检测锁式（细粒度同步代码块，由于JVM底层内部模型原因，偶尔会出问题，不建议使用）

package cn.design.singleton01;
/*测试双重检测锁单例模式*/
public class SingletonDemo3 {
    //1.提供一个静态的私有对象属性，但是没有初始化，真正使用时候再创建
    private static SingletonDemo3 instance ;
    //2.构造器私有
    private SingletonDemo3(){}
    //3.提供一个全局的访问点(方法同步，调用效率低)
    public static SingletonDemo3 getInstance() {
        if (instance == null){
            SingletonDemo3 sc;
            synchronized(SingletonDemo3.class){
                sc = instance;
                if (sc == null){
                    synchronized (SingletonDemo3.class){
                        if (sc == null) {
                            sc = new SingletonDemo3();
                        }
                    }
                    instance = sc;
                }
            }
        }
        return instance;
    }
}

2.2 静态内部类式（线程安全，调用率高。但是可以延时加载。）

静态内部类的实现方式

package cn.design.singleton01;
/*
测试静态内部类模式
线程安全，调用效率高，并且实现了延时加载！
*/
public class SingletonDemo4 {
    //1.在内部类中提供一个静态的私有对象
    private static class SingletonClassInstnnce{
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }
    //2.构造器私有
    private SingletonDemo4(){}
    //3.提供一个全局的访问点(由于类加载器在加载静态对象时，天然的线程安全，所以该方法没有同步，调用效率高。)
    public static SingletonDemo4 getInstance() {
        return SingletonClassInstnnce.instance;
    }
}

2.3 枚举单例（线程安全，调用率高。但是不能延时加载。可以天然的防止反射和反序列化漏洞）

枚举式实现

package cn.design.singleton01;
/*测试枚举式单例模式*/
public enum SingletonDemo5 {
    //这个枚举元素，本身就是一个单例
    INSTANCE;
    //添加自己需要的操作
    public void SingletonOperation() {

    }
}

3. 使用反射和反序列化破解单例模式

3.1 使用反射破解单例模式

package cn.design.singleton01;
/*测试反射破解单例模式*/
public class SingletonDemo6 {
    //1.提供一个静态的私有对象属性，但是没有初始化，真正使用时候再创建
    private static SingletonDemo6 instance ;
    //2.构造器私有
    private SingletonDemo6(){
        //防止反射破解单例模式
        if(instance != null){
            throw new RuntimeException();
        }
    }
    //3.提供一个全局的访问点(方法同步，调用效率低)
    public static synchronized SingletonDemo6 getInstance() {
        if(instance == null){
            instance = new SingletonDemo6();
        }
        return instance;
    }
}

package cn.design.singleton01;
import java.lang.reflect.Constructor;
/*测试反射破解单例模式*/
public class Client1 {
    public static void main(String[] args) throws Exception {
        SingletonDemo6 s1 = SingletonDemo6.getInstance();
        SingletonDemo6 s2 = SingletonDemo6.getInstance();
        System.out.println(s1);
        System.out.println(s2);
        
        //加载类
        Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("cn.design.singleton01.SingletonDemo6");
        //获取类构造器
        Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
        //跳过修饰符校验
        c.setAccessible(true);
        //创建对象
        SingletonDemo6 s3 = c.newInstance();
        SingletonDemo6 s4 = c.newInstance();
        System.out.println(s3);
        System.out.println(s4);
    }
}

3.2 使用反序列化破解单例模式

package cn.design.singleton01;

import java.io.ObjectStreamException;
import java.io.Serializable;
/*测试通过反序列化破解单例模式*/
public class SingletonDemo7 implements Serializable {
    //1.提供一个静态的私有对象属性，但是没有初始化，真正使用时候再创建
    private static SingletonDemo7 instance ;
    //2.构造器私有
    private SingletonDemo7(){
        if(instance != null){
            throw new RuntimeException();
        }
    }
    //3.提供一个全局的访问点(方法同步，调用效率低)
    public static synchronized SingletonDemo7 getInstance() {
        if(instance == null){
            instance = new SingletonDemo7();
        }
        return instance;
    }
    //反序列化时，如果定义了readResolve(),则直接返回此方法指定的对象，而不需要再创建新的对象！
    private Object readResolve() throws ObjectStreamException  {
        return instance;
    }
}

package cn.design.singleton01;
import	java.io.ObjectInputStream;
import	java.io.FileInputStream;
import	java.io.ObjectOutputStream;
import java.io.FileOutputStream;
import java.io.Serializable;
/*测试反序列化破解单例模式*/
public class Client2 {
    public static void main(String[] args) throws Exception {
        //创建一个对象
        SingletonDemo7 s1 = SingletonDemo7.getInstance();
        System.out.println(s1);
        
        FileOutputStream fos = new FileOutputStream("/Users/eclipse-workspace/test/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.close();
        fos.close();

        FileInputStream fis = new FileInputStream("/Users/eclipse-workspace/test/a.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        SingletonDemo7 s3 = (SingletonDemo7) ois.readObject();
        System.out.println(s3);
    }
}

3.3 比较多线程下五种单例模式的效率

package cn.design.singleton01;
import	java.util.concurrent.CountDownLatch;
public class Client3 {
    public static void main(String[] args) throws Exception {
        long start = System.currentTimeMillis();
        int threaNum = 10;
        final CountDownLatch latch = new CountDownLatch(threaNum);
        for (int i = 0; i < threaNum; i++) {
            //以匿名内部类的方式创建多线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 100000; j++) {
                        Object o = SingletonDemo1.getInstance();
                        //Object o = SingletonDemo2.getInstance();
                        //Object o = SingletonDemo3.getInstance();
                        //Object o = SingletonDemo4.getInstance();
                        //Object o = SingletonDemo5.INSTANCE;
                    }
                    //计数器减1，直到0
                    latch.countDown();
                }
            }).start();
        }
        //main线程等待其他线程执行完毕
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end - start));
    }
}

二. 简单工厂

概述

工厂模式注重于整体对象的获取，工厂类实际上封装了new对象的过程，而建造者模式旨在复杂对象的详细装配，根据对象的蓝图（我这里理解为对象的实体）在创建者（builder）类中可以调用工厂模式中的工厂类来获取复杂对象的组件对象，从而实现工厂模式和创建者模式的混合使用。