Singleton 设计模式与 Spring 容器中的 Singleton bean

Question

众所周知，Spring 容器中默认将 bean 作为单例，如果我们有一个基于 Spring 框架的 Web 应用程序，那么在这种情况下，我们是否真的需要实现单例设计模式来保存全局数据，而不是仅仅通过 spring 创建一个 bean 。

如果我无法解释我真正想问的内容，请耐心等待。

Answer 1

Spring 中的单例 bean 和单例模式有很大不同。单例模式表示每个类加载器将创建一个且仅一个特定类的实例。

Spring 单例的范围被描述为“每个容器每个 bean”。它是每个 Spring IoC 容器的单个对象实例的 bean 定义范围。 Spring 中的默认作用域是 Singleton。

即使默认范围是单例，您也可以通过指定 元素的范围属性来更改 bean 的范围。

<bean id=".." class=".." scope="prototype" />

Answer 2

我发现“每个容器每个豆子”很难理解。我会说“容器中每个 bean id 一个 bean”。让我们举一个例子来理解它。我们有一个 bean 类 Sample。我在bean定义中从这个类中定义了两个bean，例如：

<bean id="id1" class="com.example.Sample" scope="singleton">
        <property name="name" value="James Bond 001"/>    
</bean>    
<bean id="id7" class="com.example.Sample" scope="singleton">
        <property name="name" value="James Bond 007"/>    
</bean>

所以当我尝试获取id为“id1”的bean时，spring容器将创建一个bean，缓存它并返回与id1引用的相同的bean。如果我尝试使用 id7 获取它，将从 Sample 类创建另一个 bean，每次使用 id7 引用该 bean 时都会缓存并返回相同的 bean。

对于单例模式来说这是不太可能的。在 Singlton 模式中，每个类加载器总是创建一个对象。然而，在 Spring 中，将作用域设为 Singleton 并不会限制容器从该类创建许多实例。 它只是再次限制相同 ID 的新对象创建，当请求相同 ID 的对象时返回先前创建的对象。 参考

Answer 3

Spring 中的单例范围意味着 Spring 上下文中的单个实例..
Spring 容器只是一次又一次地返回相同的实例，以便后续调用来获取 bean。

Spring并不关心bean的类是否被编码为单例，事实上，如果该类被编码为单例且其构造函数为私有，则Spring使用BeanUtils.instantiateClass(javadoc 此处）将构造函数设置为可访问并调用它。

或者，我们可以在 bean 定义中使用工厂方法属性，如下所示

    <bean id="exampleBean" class="example.Singleton"  factory-method="getInstance"/>

Answer 4

让我们举一个最简单的例子：您有一个应用程序，并且您只使用默认的类加载器。您有一个类，无论出于何种原因，您决定它在应用程序中不应有多个实例。 （想象一下这样一个场景，几个人一起处理应用程序的各个部分）。

如果您不使用 Spring 框架，单例模式可确保您的应用程序中不会有多个类的实例。这是因为您无法通过执行“new”来实例化该类的实例，因为构造函数是私有的。获取类实例的唯一方法是调用类的某些静态方法（通常称为“getInstance”），该方法始终返回相同的实例。

说你在应用程序中使用 Spring 框架，只是意味着除了获取类实例的常规方法（返回类实例的新方法或静态方法）之外，你还可以要求 Spring 获取你的类实例。 Spring 将确保每当您请求该类的实例时，即使您没有使用 Singleton 模式编写该类，它也将始终返回相同的实例。换句话说，即使该类有一个公共构造函数，如果您总是向 Spring 请求该类的实例，Spring 在应用程序的生命周期中也只会调用该构造函数一次。

通常，如果您使用 Spring，您应该只使用 Spring 创建实例，并且您可以为该类拥有一个公共构造函数。但如果你的构造函数不是私有的，你并不能真正阻止任何人绕过 Spring 直接创建该类的新实例。

如果您确实想要该类的单个实例，即使您在应用程序中使用 Spring 并将 Spring 中的类定义为单例，确保这一点的唯一方法也是使用 Singleton 模式实现该类。这确保了无论人们使用 Spring 获取实例还是绕过 Spring，都会有一个实例。

Answer 5

Spring 中的单例范围意味着该 bean 只会被 Spring 实例化一次。与原型作用域（每次新实例）、请求作用域（每个请求一次）、会话作用域（每个 HTTP 会话一次）相反。

从技术上讲，单例范围与单例设计模式无关。您不必将 bean 实现为单例，即可将它们放入单例范围中。

Answer 6

两者之间有一个非常根本的区别。在单例设计模式的情况下，每个类加载器只会创建一个类的一个实例，而 Spring 单例则不是这种情况，因为稍后会为每个 IoC 容器的给定 id 创建一个共享 bean 实例。

例如，如果我有一个名为“SpringTest”的类，并且我的 XML 文件如下所示：-

<bean id="test1" class="com.SpringTest" scope="singleton">
        --some properties here
</bean>    
<bean id="test2" class="com.SpringTest" scope="singleton">
        --some properties here   
</bean>

现在在主类中，如果您检查上述两个的引用，它将返回 false，根据 Spring 文档： -

当一个 Bean 是单例时，该 Bean 中只有一个共享实例
被管理，并且所有对 id 或 id 匹配的 bean 的请求
bean 定义将导致一个特定的 bean 实例
由Spring容器返回

因此，在我们的例子中，类是相同的，但我们提供的 id 不同，因此导致创建两个不同的实例。

Answer 7

至少到目前为止，所有答案都集中在解释设计模式和 Spring 单例之间的区别，而没有解决您的实际问题：应该使用 Singleton 设计模式还是 Spring 单例 bean？什么更好？

在我回答之前，我先声明一下，两者都可以做。您可以将 bean 实现为 Singleton 设计模式，并使用 Spring 将其作为 Spring singleton bean 注入到客户端类中。

现在，问题的答案很简单：不要使用单例设计模式！
使用 Spring 的单例 bean 实现为具有公共构造函数的类。
为什么？因为单例设计模式被认为是反模式。主要是因为它使测试变得复杂。 （如果您不使用 Spring 来注入它，那么所有使用单例的类现在都与它紧密绑定），并且您无法替换或扩展它。人们可以通过谷歌搜索“Singleton anti-pattern”来获取更多信息，例如 Singleton anti- 使用 Spring 单例

是一种可行的方法（使用单例 bean 实现不是作为单例设计模式，而是使用公共构造函数），以便可以轻松测试 Spring 单例 bean，并且使用它的类是与其紧密耦合，而是 Spring 将单例（作为接口）注入到所有需要它的 bean 中，并且单例 bean 可以随时用另一个实现替换，而不会影响使用它的客户端类。

Answer 8

Spring中的Singleton bean和基于Singleton设计模式的类有很大不同。

单例模式确保每个类加载器只会创建一个特定类的一个实例，其中 Spring 单例 bean 的范围被描述为“每个容器每个 bean”。
Spring 中的单例范围意味着该 bean 只会被 Spring 实例化一次。 Spring 容器只是一次又一次地返回相同的实例，以便后续调用来获取 bean。

Answer 9

Spring singleton bean 被描述为“每个容器每个 bean”。 Spring中的单例范围意味着相同内存位置的相同对象将返回到相同的bean id。如果创建同一类的多个不同 id 的 bean，那么容器将向不同 id 返回不同的对象。这就像一个键值映射，其中键是 bean id，值是一个 spring 容器中的 bean 对象。
单例模式确保每个类加载器将创建一个且仅一个特定类的实例。

Answer 10

spring中的“singleton”是使用bean工厂获取实例，然后缓存它；严格来说，单例设计模式只能从静态 get 方法中检索实例，并且对象永远不能被公开实例化。

Answer 11

例如：“每个容器每个豆子”。

        <bean id="myBean" class="com.spring4hibernate4.TestBean">
            <constructor-arg name="i" value="1"></constructor-arg>
            <property name="name" value="1-name"></property>
        </bean>

        <bean id="testBean" class="com.spring4hibernate4.TestBean">
            <constructor-arg name="i" value="10"></constructor-arg>
            <property name="name" value="10-name"></property>
        </bean>
    </beans>



    public class Test {

        @SuppressWarnings("resource")
        public static void main(String[] args) {
            ApplicationContext ac = new ClassPathXmlApplicationContext("ws.xml");
            TestBean teatBean = (TestBean) ac.getBean("testBean");
            TestBean myBean1 = (TestBean) ac.getBean("myBean");
            System.out.println("a : " + teatBean.test + " : "   + teatBean.getName());
            teatBean.setName("a TEST BEAN 1");
            System.out.println("uPdate : " + teatBean.test + " : "  + teatBean.getName());
            System.out.println("a1 : " + myBean1.test + " : " + myBean1.getName());
            myBean1.setName(" a1 TEST BEAN 10");
            System.out.println("a1 update : " + teatBean.test + " : " + myBean1.getName());
        }
    }

public class TestBean {
    public int test = 0;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name = "default";

    public TestBean(int i) {
        test += i;
    }
}

Java 单例：

public class Singleton {
    private static Singleton singleton = new Singleton();
    private int i = 0;

    private Singleton() {
    }

    public static Singleton returnSingleton() {

        return singleton;
    }

    public void increment() {
        i++;
    }

    public int getInt() {
        return i;
    }
}

public static void main(String[] args) {
        System.out.println("Test");

        Singleton sin1 = Singleton.returnSingleton();
        sin1.increment();
        System.out.println(sin1.getInt());
        Singleton sin2 = Singleton.returnSingleton();
        System.out.println("Test");
        sin1.increment();
        System.out.println(sin1.getInt());
    }