Spring笔记之六（IoC Singleton）单例的使用与否

最新推荐文章于 2022-02-03 16:07:03 发布

liyong1115

最新推荐文章于 2022-02-03 16:07:03 发布

阅读量2.2k

点赞数

CC 4.0 BY-SA版权

分类专栏： spring 文章标签： spring ioc bean string system class

本文链接：https://blog.youkuaiyun.com/liyong1115/article/details/2059170

spring 专栏收录该内容

14 篇文章

订阅专栏

本文探讨了Spring框架中BeanFactory支持的两种对象模型：Singleton和Prototype。通过具体示例展示了这两种模型的区别，并分析了它们在实际应用中的表现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring中BeanFactory支持两个对象模型

单态： 模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。

原型： 模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。

实例：

1  <  beans  >
2
3       
4      <bean id="nonSingleton" class="java.lang.String" singleton="true">
5          <constructor-arg>
6               <value>Value</value>
7          </constructor-arg>
8       </bean>
9
10  </beans>
11
12 singleton：指定此JavaBean是否采用单例（Singleton）模式，如果设为"true"，则在BeanFactory作用范围内，只维护此JavaBean  的一个实例，代码通过BeanFactory   获得此JavaBean  实例的引用。反之，如果设为"false"，则通过BeanFactory获取此Java Bean  实例时，BeanFactory每次都将创建一个新的实例返回。

     1 public class NonSingleton {
2
3 public static void main(String[] args) {
4
5 BeanFactory factory = new XmlBeanFactory(new FileSystemResource(
6                     "build/beans.xml"));
7
8    String s1 = (String)factory.getBean("nonSingleton");
9    String s2 = (String)factory.getBean("nonSingleton");
10    System.out.println("Identity Equal?: " + (s1 ==s2));
11    System.out.println("Value Equal:? " + s1.equals(s2));
12    System.out.println(s1);
13    System.out.println(s2);
14  }
15 }

分析结果：

Identity Equal?: true
Value Equal:? true
Value
Value

由结果可以看出由fantory产生的bean对象只有一个。

注意： 在Spring中消除了由用户自己来实现Singleton模式的应用，Spring Bean的缺省行为就是Singleton，不必再为了Singleton编码。

另外一个例子：

这里还是以HelloBean为例，这三个文件都放在包javamxj.spring.basic.singleton下。

HelloBean.java

这里多加了属性i，用它得到随机数

package javamxj.spring.basic.singleton;

public class HelloBean {

    private String helloWorld;

    private int i = (int) (100 * Math.random());

    public HelloBean(String helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld);
        System.out.println("输出随机整数:  " + i);
    }
}

· 配置文件 bean.xml

在这个Beans中，定义了两个bean，都指向HelloBean类，主要不同就是第二个bean指明了singleton="false"，即不采用singleton部署方式。

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN" 
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <bean id="singletonBean" class="javamxj.spring.basic.singleton.HelloBean">
        <constructor-arg>
            <value>Hello! 这是singletonBean!</value>
        </constructor-arg>
    </bean>

    <bean id="prototypeBean" class="javamxj.spring.basic.singleton.HelloBean"
        singleton="false">
        <constructor-arg>
            <value>Hello! 这是prototypeBean! </value>
        </constructor-arg>
    </bean>

</beans>

· 测试程序：main.java

分别取得singletonBean和prototypeBean各两个实例，然后输出随机数，最后比较同一个bean的两个实例的引用是否相同。

package javamxj.spring.basic.singleton;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class Main {
    public static void main(String[] args) {

        Resource res = new ClassPathResource("javamxj/spring/basic/singleton/bean.xml");
        BeanFactory factory = new XmlBeanFactory(res);

        HelloBean h1 = (HelloBean) factory.getBean("singletonBean");
        h1.sayHello();        
        
        HelloBean h2 = (HelloBean) factory.getBean("singletonBean");
        h2.sayHello();
        
        System.out.println("h1==h2: " + (h1==h2));
        System.out.println("");
        
        
        HelloBean h3 = (HelloBean) factory.getBean("prototypeBean");
        h3.sayHello();
        
        HelloBean h4 = (HelloBean) factory.getBean("prototypeBean");
        h4.sayHello();
        
        System.out.println("h3==h4: " + (h3==h4));
    }
}