创建单例对象的各种方法：

根据约书亚·布洛赫的说法，埃努姆将是最好的。也可以使用双重检查锁定。甚至可以使用内部静态类。

我见过的最好的单例模式使用Supplier接口。

它是通用的，可重复使用它支持延迟初始化它只有在初始化之前才同步，然后将阻塞供应商替换为非阻塞供应商。

见下文：

public class Singleton<T> implements Supplier<T> {

    private boolean initialized;
    private Supplier<T> singletonSupplier;

    public Singleton(T singletonValue) {
        this.singletonSupplier = () -> singletonValue;
    }

    public Singleton(Supplier<T> supplier) {
        this.singletonSupplier = () -> {
            // The initial supplier is temporary; it will be replaced after initialization
            synchronized (supplier) {
                if (!initialized) {
                    T singletonValue = supplier.get();
                    // Now that the singleton value has been initialized,
                    // replace the blocking supplier with a non-blocking supplier
                    singletonSupplier = () -> singletonValue;
                    initialized = true;
                }
                return singletonSupplier.get();
            }
        };
    }

    @Override
    public T get() {
        return singletonSupplier.get();
    }
}

根据用法，有几个“正确”答案。

自Java5以来，最好的方法是使用枚举：

public enum Foo {
   INSTANCE;
}

在Java 5之前，最简单的情况是：

public final class Foo {

    private static final Foo INSTANCE = new Foo();

    private Foo() {
        if (INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return INSTANCE;
    }

    public Object clone() throws CloneNotSupportedException{
        throw new CloneNotSupportedException("Cannot clone instance of this class");
    }
}

让我们复习一下代码。首先，你希望这门课是期末考试。在本例中，我使用了final关键字来让用户知道它是final。然后，需要将构造函数设为私有，以防止用户创建自己的Foo。从构造函数中抛出异常会阻止用户使用反射来创建第二个Foo。然后创建一个私有的静态final Foo字段来保存唯一的实例，并创建一个公共的静态Foo-getInstance（）方法来返回它。Java规范确保只有在首次使用类时才调用构造函数。

当您有一个非常大的对象或大量的构造代码，并且还有其他可访问的静态方法或字段，这些方法或字段可能在需要实例之前使用，那么只有在需要时才需要使用惰性初始化。

您可以使用私有静态类来加载实例。代码将如下所示：

public final class Foo {

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

    private Foo() {
        if (FooLoader.INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }
}

由于行private static final Foo INSTANCE=new Foo（）；仅在实际使用FooLoader类时执行，这会处理延迟实例化，并保证线程安全。

当您还希望能够序列化对象时，需要确保反序列化不会创建副本。

public final class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

    private Foo() {
        if (FooLoader.INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }

    @SuppressWarnings("unused")
    private Foo readResolve() {
        return FooLoader.INSTANCE;
    }
}

方法readResolve（）将确保返回唯一的实例，即使对象是在程序的上一次运行中序列化的。

确保你真的需要它。在谷歌上搜索“singleton反模式”，看看反对它的一些论点。

我想这并没有什么本质上的问题，但它只是一种公开某些全局资源/数据的机制，因此请确保这是最好的方法。特别是，我发现依赖注入（DI）更有用，特别是如果您也在使用单元测试，因为DI允许您将模拟资源用于测试目的。

另一个经常用来反对单态的论点是它们的可测试性问题。出于测试目的，单体不容易被模拟。如果这是一个问题，我想做以下轻微修改：

public class SingletonImpl {

    private static SingletonImpl instance;

    public static SingletonImpl getInstance() {
        if (instance == null) {
            instance = new SingletonImpl();
        }
        return instance;
    }

    public static void setInstance(SingletonImpl impl) {
        instance = impl;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

添加的setInstance方法允许在测试期间设置单例类的实体模型实现：

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

这也适用于早期初始化方法：

public class SingletonImpl {

    private static final SingletonImpl instance = new SingletonImpl();

    private static SingletonImpl alt;

    public static void setInstance(SingletonImpl inst) {
        alt = inst;
    }

    public static SingletonImpl getInstance() {
        if (alt != null) {
            return alt;
        }
        return instance;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

这有一个缺点，就是将此功能也暴露给普通应用程序。其他编写该代码的开发人员可能会尝试使用“setInstance”方法来更改特定函数，从而改变整个应用程序的行为，因此该方法的javadoc中至少应该包含一个良好的警告。

尽管如此，对于模型测试的可能性（当需要时），这种代码暴露可能是可以接受的代价。

我使用Spring框架来管理我的单件。

它并没有强制实现类的“单例性”（如果涉及多个类加载器，则无论如何都无法做到这一点），但它提供了一种非常简单的方法来构建和配置不同的工厂以创建不同类型的对象。