【Spring注解必知必会】@Scope注解源码解析

简介: 【Spring注解必知必会】@Scope注解源码解析

概述


@Scope注解想必大家都有所了解,但是很少使用。项目中大部分使用的都是默认值,单例模式。但是作为一个有追求的程序员,我们是有必要了解它底层的实现原理,可以加深我们对Spring Bean生命周期和作用域的理解。


注解简述


@Scope注解, 用来表示Spring中Bean的作用域范围,可以分为一下几种类型:

● singleton: 默认值,单例模式,在整个Spring IoC容器中,使用singleton定义的Bean将只有一个实例。

● prototype: 多实例模式,每次通过容器的getBean方法获取prototype定义的Bean时,都将产生一个新的Bean实例。

● request: 对于每次HTTP请求,使用request定义的Bean都将产生一个新实例,即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时,该作用域才有效。

● session: 对于每次HTTP Session,使用session定义的Bean都将产生一个新实例。同样只有在Web应用中使用Spring时,该作用域才有效。

具体使用参考下面的文章【Spring注解必知必会】全面了解@Scope:

结论:

  1. 如果Bean是singleton类型,会在容器初始化的时候,实例化Bean对象,并且每次调用getBean获取到的Bean对象都是同一个, 伴随着Spring 容器关闭而消亡。
  2. 如果Bean是prototype类型,会在每次调用getBean方法的时候实例化Bean对象,销毁由GC决定。
  3. request、session等类型的bean,只有在web应用中生效。
  4. 默认不设置的情况下,Bean的类型都是singleton类型。


源码解析


整体思路

1671172458634.jpg

  1. 解析定义的Bean Class, 生成对应的BeanDefinition, BeanDefintion中定义了接口判断Bean的作用域scope。
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
  void setScope(@Nullable String scope);
  @Nullable
  String getScope();
  boolean isSingleton();
  boolean isPrototype();
}
复制代码
  1. BeanDefintion根据scope属性判断Bean创建的逻辑,如果scope是singleton单例模式,直接实例化,如果scope是prototype多实例模式,每次getBean重新实例化,如果是其他类型,则采用另外的逻辑处理,由于不常用,本文不重点讨论。


解析Bean Class


1671172625221.jpg

  1. 容器在初始化 执行refresh方法时,最终会调用到ConfigurationClassPostProcessor类来扫描Bean Class。
  2. ConfigurationClassPostProcessor类实现了BeanDefinitionRegistryPostProcessor接口,扩展该接口,可以往BeanDefinition注册中心中添加BeanDefinition。而ConfigurationClassPostProcessor类其中一个作用就是解析@ComponentScan注解,扫描@Configuration、@Service、@Controller、@Repository和@Component注解并注册BeanDefinition。
  3. 最终调用 ClassPathBeanDefinitionScanner#doScan方法扫描获取容器中的Bean Class,恒诚BeanDefinition对象。

1671172631282.jpg

  1. 通过socpeMeataResolver解析器解析出scope属性,设置到BeanDefinition中。

1671172638225.jpg

1671172645434.jpg

  1. 处理scope中的代理属性

1671172652672.jpg

1671172658274.jpg

  1. 至此,就解析出scope类的Bean Definition。


创建Bean


1671172667769.jpg

上面是根据BeanDefinition获取Bean对象时候调用的堆栈信息,最终会调用到AbstractBeanFactory#doGetBean方法, 我们重点查看下该方法。

protected <T> T doGetBean(
      String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
      throws BeansException {
    String beanName = transformedBeanName(name);
    Object beanInstance;
    // 先从单例缓存池中获取Bean
    Object sharedInstance = getSingleton(beanName);
        // 如果Bean实例已经存在
    if (sharedInstance != null && args == null) {
      if (logger.isTraceEnabled()) {
        if (isSingletonCurrentlyInCreation(beanName)) {
          logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
              "' that is not fully initialized yet - a consequence of a circular reference");
        }
        else {
          logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
        }
      }
      beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
        // 如果缓存中不存在,则需要创建Bean实例
    else {
               ............
        // 如果BeanDefinition是singleton单例模式
        if (mbd.isSingleton()) {
                    // 创建Bean对象,同时会将新建的Bean对象放到缓存池中
          sharedInstance = getSingleton(beanName, () -> {
            try {
              return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
              // Explicitly remove instance from singleton cache: It might have been put there
              // eagerly by the creation process, to allow for circular reference resolution.
              // Also remove any beans that received a temporary reference to the bean.
              destroySingleton(beanName);
              throw ex;
            }
          });
          beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
                // 如果BeanDefinition是prototype多实例模式
        else if (mbd.isPrototype()) {
          // It's a prototype -> create a new instance.
          Object prototypeInstance = null;
          try {
            beforePrototypeCreation(beanName);
                        // 直接创建对象
            prototypeInstance = createBean(beanName, mbd, args);
          }
          finally {
            afterPrototypeCreation(beanName);
          }
          beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        }
                // 如果不是singleton或者prototype类型,则采用下面的逻辑
        else {
          String scopeName = mbd.getScope();
          if (!StringUtils.hasLength(scopeName)) {
            throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
          }
          Scope scope = this.scopes.get(scopeName);
          if (scope == null) {
            throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
          }
          try {
            Object scopedInstance = scope.get(beanName, () -> {
              beforePrototypeCreation(beanName);
              try {
                return createBean(beanName, mbd, args);
              }
              finally {
                afterPrototypeCreation(beanName);
              }
            });
            beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
          }
          catch (IllegalStateException ex) {
            throw new ScopeNotActiveException(beanName, scopeName, ex);
          }
        }
      }
      catch (BeansException ex) {
        beanCreation.tag("exception", ex.getClass().toString());
        beanCreation.tag("message", String.valueOf(ex.getMessage()));
        cleanupAfterBeanCreationFailure(beanName);
        throw ex;
      }
      finally {
        beanCreation.end();
      }
    }
        // 适配处理
    return adaptBeanInstance(name, beanInstance, requiredType);
  }

以上就是整个@Scope注解的实现原理。


总结


本文主要讲述了@Scope注解的实现原理,可以帮助大家从源码层面理解Bean的生命周期和作用域范围。

目录
相关文章
|
4天前
|
XML 安全 前端开发
Spring Security 重点解析(下)
Spring Security 重点解析
13 1
|
4天前
|
缓存 前端开发 Java
【框架】Spring 框架重点解析
【框架】Spring 框架重点解析
18 0
|
2天前
|
Linux 网络安全 Windows
网络安全笔记-day8,DHCP部署_dhcp搭建部署,源码解析
网络安全笔记-day8,DHCP部署_dhcp搭建部署,源码解析
|
3天前
HuggingFace Tranformers 源码解析(4)
HuggingFace Tranformers 源码解析
6 0
|
3天前
HuggingFace Tranformers 源码解析(3)
HuggingFace Tranformers 源码解析
6 0
|
3天前
|
开发工具 git
HuggingFace Tranformers 源码解析(2)
HuggingFace Tranformers 源码解析
6 0
|
3天前
|
并行计算
HuggingFace Tranformers 源码解析(1)
HuggingFace Tranformers 源码解析
8 0
|
11月前
|
XML Java 数据库连接
【Spring学习笔记 五】Spring注解及Java类配置开发
【Spring学习笔记 五】Spring注解及Java类配置开发
70 0
|
XML Java 数据格式
spring基于注解的配置
**不管是 XML 还是注解,它们都是表达 Bean 定义的载体,其实质都是为 Spring 容器提供 Bean 定义的信息,在表现形式上都是将 XML 定义的内容通过类注解进****行描述。**Spring 从2.0开始就引入了基于注解的配置方式,在2.5时得到了完善,在4.0时进一步增强。
|
XML Java 数据格式
Spring(七)之基于注解配置
基于注解的配置 从 Spring 2.5 开始就可以使用注解来配置依赖注入。而不是采用 XML 来描述一个 bean 连线,你可以使用相关类,方法或字段声明的注解,将 bean 配置移动到组件类本身。 在 XML 注入之前进行注解注入,因此后者的配置将通过两种方式的属性连线被前者重写。
741 0

推荐镜像

更多