SpringIoc中各个scope的Bean是怎么创建的
这篇文章主要讲解了“Spring Ioc中各个scope的Bean是怎么创建的”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Spring Ioc中各个scope的Bean是怎么创建的”吧!
公司主营业务:网站制作、网站设计、移动网站开发等业务。帮助企业客户真正实现互联网宣传,提高企业的竞争能力。创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化,感谢他们对我们的高要求,感谢他们从不同领域给我们带来的挑战,让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。创新互联推出淮北免费做网站回馈大家。
一、singleton
代码:
// Create bean instance. //创建单例Bean if (mbd.isSingleton()) { //这里使用了一个匿名内部类,创建Bean实例对象,并且注册给所依赖的对象 sharedInstance = getSingleton(beanName, () -> { try { //创建一个指定Bean实例对象,如果有父级继承,则合并子类和父类的定义 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. //显式地从容器单例模式Bean缓存中清除实例对象 destroySingleton(beanName); throw ex; } }); //获取给定Bean的实例对象 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); }
这里使用了匿名内部类,先通过
createBean(beanName, mbd, args)
方法获取一个 ObjectFactory把 ObjectFactory 作为参数传入
getSingleton(beanName,objectFactory)
方法使用 getSingleton(beanName,objectFactory) 方法返回的 sharedInstance作为参数传入
getObjectForBeanInstance(sharedInstance, name, beanName, mbd)
来回去最终的Bean实例(详情见Spring Ioc 之 Bean的加载(一))
createBean(beanName, mbd, args)
方法比较复杂,在之后的文章中会详细分析,这里就先略过,直接看 getSingleton(beanName,objectFactory)
方法。
// DefaultSingletonBeanRegistry.java public Object getSingleton(String beanName, ObjectFactory> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); //全局加锁 synchronized (this.singletonObjects) { // 从缓存中获取单例bean // 因为 singleton 模式其实就是复用已经创建的 bean 所以这步骤必须检查 Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { //是否正在销毁该bean if (this.singletonsCurrentlyInDestruction) { throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); } // 加载前置处理 beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { // 初始化 bean // 这个过程其实是调用 createBean() 方法 singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { // Has the singleton object implicitly appeared in the meantime -> // if yes, proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { throw ex; } } catch (BeanCreationException ex) { if (recordSuppressedExceptions) { for (Exception suppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throw ex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } //后置处理 afterSingletonCreation(beanName); } if (newSingleton) { //加入缓存中 addSingleton(beanName, singletonObject); } } return singletonObject; } }
在这段代码中,其实主要是做了一些准备和预处理步骤,真正创建Bean是在singletonFactory.getObject()
方法实现的,而 singletonFactory是由createBean()方法创建后回调的参数。
那么这段代码主要做的事情是什么呢?
尝试从缓存中获取单例Bean
如果已经加载了则直接返回,否则开始加载过程加载前置处理
获取Bean实例
后置处理
加入缓存
1.1、加载前置处理
beforeSingletonCreation(beanName)
是个标记方法,我们来看代码:
// 用于添加标志,当前 bean 正处于创建中 protected void beforeSingletonCreation(String beanName) { if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { //添加失败,抛出异常 throw new BeanCurrentlyInCreationException(beanName); } }
把 beanName 添加到 singletonsCurrentlyInCreation
map中,用来表示该单例bean正在创建,如果添加失败,抛出异常。
1.2、获取Bean实例
通过createBean(beanName)
方法返回的 singletonFactory获取Bean。
1.3、后置处理
afterSingletonCreation(beanName)
同样是个表示方法:
// 用于移除标记,当前 Bean 不处于创建中 protected void afterSingletonCreation(String beanName) { if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { //移除失败,抛出异常 throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); } }
创建Bean之后移除创建标示。
前置处理和后置处理的这个创建标示,会在调用isSingletonCurrentlyInCreation(String beanName)
时用到,该方法用来判断当前bean是否已经在创建中。
1.4、加入缓存
直接看代码:
protected void addSingleton(String beanName, Object singletonObject) { synchronized (this.singletonObjects) { this.singletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } }
一个 put、一个 add、两个 remove 操作。
【put】singletonObjects 属性,单例 bean 的缓存。
【remove】singletonFactories 属性,单例 bean Factory 的缓存。
【remove】earlySingletonObjects 属性,“早期”创建的单例 bean 的缓存。
【add】registeredSingletons 属性,已经注册的单例缓存。
二、Prototype
代码:
//创建多例Bean else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. //原型模式(Prototype)是每次都会创建一个新的对象 Object prototypeInstance = null; try { //加载前置处理,默认的功能是注册当前创建的原型对象 beforePrototypeCreation(beanName); //创建指定Bean对象实例 prototypeInstance = createBean(beanName, mbd, args); } finally { //加载后置处理,默认的功能告诉IOC容器指定Bean的原型对象不再创建 afterPrototypeCreation(beanName); } //获取给定Bean的实例对象 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); }
原型模式很简单,直接创建一个新的实例就好了,不再从缓存中去获取。beforePrototypeCreation(beanName)
前置处理,将当前bean标记为正在创建的原型。afterPrototypeCreation(beanName)
后置处理,取消当前bean的正在创建标示。
调用getObjectFrBeanInstance()
方法获取最终bean。(详情见Spring Ioc 之 Bean的加载(一))
三、其他作用域
//要创建的Bean既不是Singleton也不是Prototype //如:request、session、application等生命周期 else { String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); //Bean定义资源中没有配置生命周期范围,则Bean定义不合法 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); } }); //获取给定Bean的实例对象 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex); } }
分为以下几个步骤:
从Scope注解中获取scope名称
前置处理
createBean()
后置处理
scope.get()获取bean
getObjectForBeanInstance()方法获取Bean
核心流程与原型模式一样,只不过这里调用了scope.get()来获取bean。
Object get(String name, ObjectFactory> objectFactory);
scope.get()是一个接口,它有多种实现类:
我们看一下spring自带的一个实现 SimpleThreadScope:
//SimpleThreadScope.java private final ThreadLocal
其他scope的实现就不一一去看了,感兴趣的朋友可以自己看一下。
总结
上面的代码中有2个重要方法:
createBean(beanName, mbd, args)
getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd)
这2个方法在3个代码分支中都用到了,createBean
下篇文章会详细分析,getObjectForBeanInstance
方法在Spring Ioc 之 Bean的加载(一)中已经分析过了。
这里再引用下《Spring 源码深度解析》对该方法的分析:
这个方法主要是验证以下我们得到的 bean 的正确性,其实就是检测当前 bean 是否是 FactoryBean 类型的 bean 。
如果是,那么需要调用该 bean 对应的 FactoryBean 实例的 getObject() 方法,作为返回值。
无论是从缓存中获得到的 bean 还是通过不同的 scope 策略加载的 bean 都只是最原始的 bean 状态,并不一定就是我们最终想要的 bean。
举个例子,假如我们需要对工厂 bean 进行处理,那么这里得到的其实是工厂 bean 的初始状态,但是我们真正需要的是工厂 bean 中定义 factory-method 方法中返回的 bean,而 getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) 方法,就是完成这个工作的。
感谢各位的阅读,以上就是“Spring Ioc中各个scope的Bean是怎么创建的”的内容了,经过本文的学习后,相信大家对Spring Ioc中各个scope的Bean是怎么创建的这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是创新互联,小编将为大家推送更多相关知识点的文章,欢迎关注!
当前题目:SpringIoc中各个scope的Bean是怎么创建的
标题URL:http://pwwzsj.com/article/gdpdpj.html