Spring Bean 作用域

最新推荐文章于 2024-06-21 08:15:00 发布
最新推荐文章于 2024-06-21 08:15:00 发布
阅读量285 收藏
点赞数
分类专栏： Spring核心编程思想 文章标签： spring
原文链接：https://time.geekbang.org/course/intro/100042601?utm_campaign=guanwang&utm_source=baidu-ad&utm_medium=ppzq-pc&utm_content=title&utm_term=baidu-ad-ppzq-title
版权

Spring Bean 作用域

作用域

来源说明
singleton默认 Spring Bean 作用域，一个 BeanFactory 有且仅有一个实例
prototype原型作用域，每次依赖查找和依赖注入生成新 Bean 对象
request将 Spring Bean 存储在 ServletRequest 上下文中
session将 Spring Bean 存储在 HttpSession 中
application将 Spring Bean 存储在 ServletContext 中

“singleton” Bean 作用域

配置
在这里插入图片描述

“prototype” Bean 作用域

配置
在这里插入图片描述
注意事项
• Spring 容器没有办法管理 prototype Bean 的完整生命周期，也没有办法记录示例的存在。销毁回调方法将不会执行，可以利用 BeanPostProcessor 进行清扫工作。

/**
 * Bean 的作用域示例
 */
public class BeanScopeDemo implements DisposableBean {

    @Bean
    // 默认 scope 就是 "singleton"
    public static User singletonUser() {
        return createUser();
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public static User prototypeUser() {
        return createUser();
    }

    private static User createUser() {
        User user = new User();
        user.setId(System.nanoTime());
        return user;
    }

    @Autowired
    @Qualifier("singletonUser")
    private User singletonUser;

    @Autowired
    @Qualifier("singletonUser")
    private User singletonUser1;

    @Autowired
    @Qualifier("prototypeUser")
    private User prototypeUser;

    @Autowired
    @Qualifier("prototypeUser")
    private User prototypeUser1;

    @Autowired
    @Qualifier("prototypeUser")
    private User prototypeUser2;

    @Autowired
    private Map<String, User> users;

    @Autowired
    private ConfigurableListableBeanFactory beanFactory; // Resolvable Dependency

    public static void main(String[] args) {

        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 注册 Configuration Class（配置类） -> Spring Bean
        applicationContext.register(BeanScopeDemo.class);

        applicationContext.addBeanFactoryPostProcessor(beanFactory -> {
            beanFactory.addBeanPostProcessor(new BeanPostProcessor() {

                @Override
                public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                    System.out.printf("%s Bean 名称:%s 在初始化后回调...%n", bean.getClass().getName(), beanName);
                    return bean;
                }
            });
        });

        // 启动 Spring 应用上下文
        applicationContext.refresh();

        // 结论一：
        // Singleton Bean 无论依赖查找还是依赖注入，均为同一个对象
        // Prototype Bean 无论依赖查找还是依赖注入，均为新生成的对象

        // 结论二：
        // 如果依赖注入集合类型的对象，Singleton Bean 和 Prototype Bean 均会存在一个
        // Prototype Bean 有别于其他地方的依赖注入 Prototype Bean

        // 结论三：
        // 无论是 Singleton 还是 Prototype Bean 均会执行初始化方法回调
        // 不过仅 Singleton Bean 会执行销毁方法回调

        scopedBeansByLookup(applicationContext);

        scopedBeansByInjection(applicationContext);

        // 显示地关闭 Spring 应用上下文
        applicationContext.close();
    }

    private static void scopedBeansByLookup(AnnotationConfigApplicationContext applicationContext) {

        for (int i = 0; i < 3; i++) {
            // singletonUser 是共享 Bean 对象
            User singletonUser = applicationContext.getBean("singletonUser", User.class);
            System.out.println("singletonUser = " + singletonUser);
            // prototypeUser 是每次依赖查找均生成了新的 Bean 对象
            User prototypeUser = applicationContext.getBean("prototypeUser", User.class);
            System.out.println("prototypeUser = " + prototypeUser);
        }
    }

    private static void scopedBeansByInjection(AnnotationConfigApplicationContext applicationContext) {
        BeanScopeDemo beanScopeDemo = applicationContext.getBean(BeanScopeDemo.class);

        System.out.println("beanScopeDemo.singletonUser = " + beanScopeDemo.singletonUser);
        System.out.println("beanScopeDemo.singletonUser1 = " + beanScopeDemo.singletonUser1);

        System.out.println("beanScopeDemo.prototypeUser = " + beanScopeDemo.prototypeUser);
        System.out.println("beanScopeDemo.prototypeUser1 = " + beanScopeDemo.prototypeUser1);
        System.out.println("beanScopeDemo.prototypeUser2 = " + beanScopeDemo.prototypeUser2);

        System.out.println("beanScopeDemo.users = " + beanScopeDemo.users);
    }

    @Override
    public void destroy() throws Exception {

        System.out.println("当前 BeanScopeDemo Bean 正在销毁中...");

        this.prototypeUser.destroy();
        this.prototypeUser1.destroy();
        this.prototypeUser1.destroy();
        this.prototypeUser2.destroy();
        // 获取 BeanDefinition
        for (Map.Entry<String, User> entry : this.users.entrySet()) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            if (beanDefinition.isPrototype()) { // 如果当前 Bean 是 prototype scope
                User user = entry.getValue();
                user.destroy();
            }
        }

        System.out.println("当前 BeanScopeDemo Bean 销毁完成");
    }
}

org.springframework.context.event.EventListenerMethodProcessor Bean 名称:org.springframework.context.event.internalEventListenerProcessor 在初始化后回调...
org.springframework.context.event.DefaultEventListenerFactory Bean 名称:org.springframework.context.event.internalEventListenerFactory 在初始化后回调...
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor Bean 名称:org.springframework.context.annotation.internalAutowiredAnnotationProcessor 在初始化后回调...
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor Bean 名称:org.springframework.context.annotation.internalCommonAnnotationProcessor 在初始化后回调...
User Bean [singletonUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:singletonUser 在初始化后回调...
User Bean [prototypeUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:prototypeUser 在初始化后回调...
User Bean [prototypeUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:prototypeUser 在初始化后回调...
User Bean [prototypeUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:prototypeUser 在初始化后回调...
User Bean [prototypeUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:prototypeUser 在初始化后回调...
org.geekbang.thinking.in.spring.ioc.bean.scope.BeanScopeDemo Bean 名称:beanScopeDemo 在初始化后回调...
singletonUser = User{id=1310440987738200, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='singletonUser'}
User Bean [prototypeUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:prototypeUser 在初始化后回调...
prototypeUser = User{id=1310441063206900, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='prototypeUser'}
singletonUser = User{id=1310440987738200, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='singletonUser'}
User Bean [prototypeUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:prototypeUser 在初始化后回调...
prototypeUser = User{id=1310441064716800, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='prototypeUser'}
singletonUser = User{id=1310440987738200, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='singletonUser'}
User Bean [prototypeUser] 初始化...
org.geekbang.thinking.in.spring.ioc.overview.domain.User Bean 名称:prototypeUser 在初始化后回调...
prototypeUser = User{id=1310441065636900, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='prototypeUser'}
beanScopeDemo.singletonUser = User{id=1310440987738200, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='singletonUser'}
beanScopeDemo.singletonUser1 = User{id=1310440987738200, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='singletonUser'}
beanScopeDemo.prototypeUser = User{id=1310441012636300, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='prototypeUser'}
beanScopeDemo.prototypeUser1 = User{id=1310441014759500, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='prototypeUser'}
beanScopeDemo.prototypeUser2 = User{id=1310441016456700, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='prototypeUser'}
beanScopeDemo.users = {singletonUser=User{id=1310440987738200, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='singletonUser'}, prototypeUser=User{id=1310441024264100, name='null', city=null, workCities=null, lifeCities=null, configFileLocation=null, company=null, context=null, contextAsText='null', beanName='prototypeUser'}}
当前 BeanScopeDemo Bean 正在销毁中...
User Bean [prototypeUser] 销毁中...
User Bean [prototypeUser] 销毁中...
User Bean [prototypeUser] 销毁中...
User Bean [prototypeUser] 销毁中...
User Bean [prototypeUser] 销毁中...
当前 BeanScopeDemo Bean 销毁完成
User Bean [singletonUser] 销毁中...

“request” Bean 作用域

• 配置

  • XML -
  • Java 注解 - @RequestScope 或 @Scope(WebApplicationContext.SCOPE_REQUEST)

• 实现

  • API - RequestScope

“session” Bean 作用域

• 配置

  • XML -
  • Java 注解 - @RequestScope 或 @Scope(WebApplicationContext.SCOPE_REQUEST)

• 实现

  • API - SessionScope

“application” Bean 作用域

• 配置

  • XML -
  • Java 注解 - @ApplicationScope 或 @Scope(WebApplicationContext.SCOPE_APPLICATION)

• 实现

  • API - ApplicationScope

自定义 Bean 作用域

• 实现 Scope

  • org.springframework.beans.factory.config.Scope

• 注册 Scope

  • API - org.springframework.beans.factory.config.ConfigurableBeanFactory#registerScope
  • 配置
<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
	<property name="scopes">
		<map>
			<entry key="...">
			</entry>
		</map>
	</property>
</bean>

/**
 * ThreadLocal 级别 Scope
 */
public class ThreadLocalScope implements Scope {

    public static final String SCOPE_NAME = "thread-local";

    private final NamedThreadLocal<Map<String, Object>> threadLocal = new NamedThreadLocal("thread-local-scope") {

        public Map<String, Object> initialValue() {
            return new HashMap<>();
        }
    };

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {

        // 非空
        Map<String, Object> context = getContext();

        Object object = context.get(name);

        if (object == null) {
            object = objectFactory.getObject();
            context.put(name, object);
        }

        return object;
    }

    @NonNull
    private Map<String, Object> getContext() {
        return threadLocal.get();
    }

    @Override
    public Object remove(String name) {
        Map<String, Object> context = getContext();
        return context.remove(name);
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        // TODO
    }

    @Override
    public Object resolveContextualObject(String key) {
        Map<String, Object> context = getContext();
        return context.get(key);
    }

    @Override
    public String getConversationId() {
        Thread thread = Thread.currentThread();
        return String.valueOf(thread.getId());
    }
}

/**
 * 自定义 Scope {@link ThreadLocalScope} 示例
 */
public class ThreadLocalScopeDemo {

    @Bean
    @Scope(ThreadLocalScope.SCOPE_NAME)
    public User user() {
        return createUser();
    }

    private static User createUser() {
        User user = new User();
        user.setId(System.nanoTime());
        return user;
    }

    public static void main(String[] args) {

        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 注册 Configuration Class（配置类） -> Spring Bean
        applicationContext.register(ThreadLocalScopeDemo.class);

        applicationContext.addBeanFactoryPostProcessor(beanFactory -> {
            // 注册自定义 scope
            beanFactory.registerScope(ThreadLocalScope.SCOPE_NAME, new ThreadLocalScope());
        });

        // 启动 Spring 应用上下文
        applicationContext.refresh();

        scopedBeansByLookup(applicationContext);

        // 关闭 Spring 应用上下文
        applicationContext.close();
    }

    private static void scopedBeansByLookup(AnnotationConfigApplicationContext applicationContext) {

        for (int i = 0; i < 3; i++) {
            Thread thread = new Thread(() -> {
                // user 是共享 Bean 对象
                User user = applicationContext.getBean("user", User.class);
                System.out.printf("[Thread id :%d] user = %s%n", Thread.currentThread().getId(), user);
            });

            // 启动线程
            thread.start();
            // 强制线程执行完成
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void scopedBeansByInjection(AnnotationConfigApplicationContext applicationContext) {
    }
}

课外资料

• Spring Cloud RefreshScope 是如何控制 Bean 的动态刷新？

面试题

Spring 內建的 Bean 作用域有几种？
答：singleton、prototype、request、session、application 以及websocket

singleton Bean 是否在一个应用是唯一的？
答：否，singleton bean 仅在当前 Spring IoC 容器（BeanFactory）中是单例对象。

“application”Bean 是否被其他方案替代？
答：可以的，实际上，“application” Bean 与“singleton” Bean 没有本质区别

简单了解spring bean作用域属性singleton和prototype的区别
08-25
Spring Bean作用域属性singleton和prototype的区别详解 Spring Framework中，Bean的作用域属性是指Bean实例的生命周期和作用域。Spring提供了五种作用域：singleton、prototype、request、session和global session...
Spring Bean 作用域.pdf
最新发布
07-25
spring Bean 作用域.pdf
Spring中Bean的作用域有哪些
rm_rf1024的博客
01-23 5594
（1）作用域包括： Singleton（单例模式） Prototype（原型模式；多例模式） Request（HTTP请求） Session（会话） global-session（全局会话，在Spring5.X中已经删除了） （2）作用范围说明 Singleton： 使用该属性定义Bean时，I0C 容器仅创建一个Bean实例，I0C 容器每次返回的是同一个 Bean实例。 Prototype： ...
Spring中bean的作用域问题
weixin_42324471的博客
05-27 255
当在Spring中定义一个Bean时，你必须要声明改bean的作用域。可能很多人会说我在开发中没有设置过什么作用域啊！那是应为Spring找那个有设置Bean的默认作用域singleton， 当作用域为singleton时，Spring在需要该bean时，都会返回同一个Bean实例。也就说说Spring中默认是单例模式。为了强制 Spring 在每次需要时都产生一个新的 bean 实例，你应该声...
Spring中Bean的作用域有哪些？
一位普普通通程序员的博客
08-19 1048
谈一谈Spring中Bean的作用域： singleton : 唯一 bean 实例，Spring 中的 bean 默认都是单例的。 prototype : 每次调用getBean()时，都会创建一个新的 bean 实例。 request : 每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效。 session : 同一个Http Session共享一个Bean，不同的Http Session使用不同的Bean，该作用域仅适用于WebApplicationConte
Spring中的Bean的作用域有哪些
m0_50831101的博客
04-06 187
Spring中的Bean的作用域有哪些? singleton : 唯一 bean 实例，Spring 中的 bean 默认都是单例的。 prototype : 每次请求都会创建一个新的 bean 实例。 request : 每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效。 session : 每一次HTTP请求都会产生一个新的 bean，该bean仅在当前 HTTP session 内有效。 global-session:全局session作用域，仅仅在基于po
Spring中Bean的五个作用域
weixin_34124577的博客
09-04 642
当通过spring容器创建一个Bean实例时，不仅可以完成Bean实例的实例化，还可以为Bean指定特定的作用域。Spring支持如下5种作用域： singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例 prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实...
Spring实战之Bean的作用域request用法分析
08-25
主要介绍了Spring实战之Bean的作用域request用法,结合实例形式分析了spring中Bean的request作用域相关使用技巧与操作注意事项,需要的朋友可以参考下
理解Spring Bean的作用域
常备不懈
06-21 1379
在Spring框架中，Bean的作用域决定了Bean的生命周期及其可见性。Spring提供了几种不同的Bean作用域，以便开发人员根据特定的应用程序需求来管理Bean的创建和使用。本文将详细介绍Spring Bean的各种作用域，包括它们的特点和适用场景。
Spring中bean的作用域
谦谦君子
10-26 250
在spring2.0中只有5种作用域即：singleton(单例)、prototype，Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。spring中默认为singleton   singleton:每次调用getBean的时候返回相同的实例   &lt;bean id="role" class="spring....
从源码中理解bean作用域
whatisthespring的博客
04-25 165
#从源码中理解bean作用域 应用scope配置项配置Bean的作用域。 目前只理解单例模式singleton和应用原型模式prototype。 作用域限定了Spring Bean的作用范围，在Spring配置文件定义Bean时，通过声明scope配置项，可以灵活定义Bean的作用范围。例如，当你希望每次IOC容器返回的Bean是同一个实例时，可以设置scope为singleton；当你希望每次IOC容器返回的Bean实例是一个新的实例时，可以设置scope为prototype。 scope配置项有5个属性
Java笔试题（题目附加答案及解析）
weixin_47514459的博客
04-13 3973
此文章记录小编在招聘过程中遇到的笔试题记录，希望此文章对许多和小编一样参加笔试的人提供帮助。同时此文章是小编整理，如有错误欢迎评论指出。谢谢。 ：目录方便大家观看题目 单选题 以下哪个不是SpringBoot默认支持自动装配的?(A) A.spring-boot-starter-web B spring-boot-starter-data-redis C spring-boot-starter-security D mybatis spring-boot-starter Spr
Spring Bean的五个作用域
Ahuuua的博客
04-15 1万+
Spring支持五个作用域：singleton、prototype、request、session、global session
Spring Bean的作用域
热门推荐
forever-and-ever的博客
08-25 6万+
在Spring中，bean作用域用于确定哪种类型的bean实例应该从Spring容器中返回给调用者。 目前Spring Bean的作用域或者说范围主要有五种。 作用域 描述 singleton 在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，bean作用域范围的默认值。 prototype 每次从容器中调用Bean时，都返回一个新的实例，即每...
在Spring中，Bean有几种作用域?
sinat_36255061的博客
10-27 1282
1、singleton作用域 当一个bean的作用域设置为singleton，那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleto
Spring bean的作用域有哪些？
Quasimodo24的博客
05-19 2621
spring 的 controller 是单例还是多例，怎么保证并发的安全。 spring bean 作用域有五种： singleton：单例模式，当 spring 创建 applicationContext 容器的时候， spring 会欲初始化所有的该作用域实例，加上 lazy-init 就可以避免预处 理； prototype：原型模式，每次通过 getBean 获取该 bean 就会新产生一个 实例，创建后 spring 将不再对其管理； 下面是在 web 项目下才用到的 reque
掌握Spring Bean作用域的编程技术
在实际开发中，开发者需要根据不同的业务需求和环境来选择合适的bean作用域。例如，在多用户环境下，共享同一个singleton bean可能会导致数据不一致或者数据泄露的问题，此时应该考虑使用prototype或其他作用域。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值