单例模式使用记录

一、什么是单例模式
如果你已经了解过单例模式，那么不妨直接阅读第四大点。直接学习一下枚举来实现单例模式，你就能了解到为什么Joshua Bloch大神都推崇这样来实现单例模式

1.1 基本概念
单例这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

设计模式被大致分为了三种：创建型模式、结构型模式、行为型模式

人话：在java中使用工具类的实现或创建对象需要消耗资源，那么它只允许被创建一次。所有代码都使用这一个实例，那么它就能节约出一部分的内存

1.2单例模式的特点
1、单例类只能有一个实例，节省内存空间
2、单例类必须自己创建自己的唯一实例
3、单例类必须给所有其他对象提供这一实例
4、设计模式中最为简单的几个设计模式
5、自己来控制这个实例，符合面向对象的封装原则

1.3 使用单例的注意事项
1.利用反射的方式来实例化多个不同的实例（可以使用枚举解决）
2.在序列化和反序列换的时候也会出现多个不同的实例（可以使用枚举解决）
3.不要做断开单例类对象与类中静态引用的危险操作。
4.多线程使用单例使用共享资源时，注意线程安全问题。

二、为什么需要单例模式
当一个全局使用的类频繁地创建与销毁，会消耗我们一部分系统资源来处理这个过程。那么我们就只保证一个类Class只有一个实例存在， 就可以帮助节省内存，因为它限制了实例的个数，也有利于Java垃圾回收（garbage collection）。
使用场景
1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

三、单例模式的常见写法
3.1 立即加载与延迟加载
在介绍单例模式实现之前，我们先解释一下 立即加载 和延迟加载 两个概念。

立即加载 ： 在类加载初始化的时候就主动创建实例；

延迟加载 ： 等到真正使用的时候才去创建实例，不用时不去主动创建。（内存容量有限 ，为了减少并发量，在真正需要数据的时候才进行数据加载操作，减少系统资源的消耗）

延迟加载也被使用在Hibernate3关联关系对象中默认的加载方式，在我们进行一对多查询的时候，我们设置一个lazy=true/false ，数据库就可以根据这个值来决定是否加载附属的信息。

原文链接：https://blog.youkuaiyun.com/ChengHuanHuaning/article/details/106087253

单例的实现有多种，饿汉式单例，懒汉式单例，静态内部类单例，双重校验锁单例，还有枚举。以上都是单例的实现方法，但是                                        

什么时候能用到呢？我想啊想，终于想到在项目中其实每天都在用，话不多说上代码

//响应的code
public enum ResponseCode {
    SUCCESS(0, "SUCCESS"),
    ERROR(1, "ERROR"),
    NEED_LOGIN(10, "NEED_LOGIN"),
    ILLEGAL_ARGUMENT(2, "ILLEGAL_ARGUMENT");

    private final int code;
    private final String desc;

    ResponseCode(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public int getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }
}

@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class ServerResponse<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    private int status;
    private String msg;
    private T data;

    private ServerResponse(int status) {
        this.status = status;
    }

    private ServerResponse(int status, String msg) {
        this.status = status;
        this.msg = msg;
    }

    private ServerResponse(int status, T data) {
        this.status = status;
        this.data = data;
    }

    private ServerResponse(int status, String msg, T data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    @JsonIgnore
    public boolean isSuccess() {
        return this.status == ResponseCode.SUCCESS.getCode();
    }

    public int getStatus() {
        return status;
    }

    public String getMsg() {
        return msg;
    }

    public T getData() {
        return data;
    }

    public static <T> ServerResponse <T> createBySuccess() {
        return new ServerResponse <T>(ResponseCode.SUCCESS.getCode());
    }

    public static <T> ServerResponse <T> createBySuccessMessage(String msg) {
        return new ServerResponse <T>(ResponseCode.SUCCESS.getCode(), msg);
    }

    public static <T> ServerResponse <T> createBySuccess(T data) {
        return new ServerResponse <T>(ResponseCode.SUCCESS.getCode(), data);
    }

    public static <T> ServerResponse <T> createBySuccess(String msg, T data) {
        return new ServerResponse <T>(ResponseCode.SUCCESS.getCode(), msg, data);
    }

    public static <T> ServerResponse <T> createByError() {
        return new ServerResponse <T>(ResponseCode.ERROR.getCode(), ResponseCode.ERROR.getDesc());
    }

    public static <T> ServerResponse <T> createByErrorMessage(String errorMsg) {
        return new ServerResponse <T>(ResponseCode.ERROR.getCode(), errorMsg);
    }

    public static <T> ServerResponse <T> createByErrorCodeMessage(int errorCode, String errorMessage) {
        return new ServerResponse <T>(errorCode, errorMessage);
    }
}

这不就是对返回值的封装类，哈哈，打卡成功