您好,登录后才能下订单哦!
本篇内容主要讲解“Spring Ioc中Bean加载的方法”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“Spring Ioc中Bean加载的方法”吧!
在之前的文章中,我们分析了Spring的Ioc的初始化过程,实际上就是把beanName
和BeanDefinition
注册到DefaultListableBeanFactory
的map中。
在完成 bean 的注册之后,refresh()
还调用了很多后处理器的方法,其中有一个方法 finishBeanFactoryInitialization()
,注释上面写着 Instantiateall remaining(non-lazy-init)singletons
,意味着非延迟加载的类,将在这一步实例化,完成类的加载。
而我们使用到 context.getBean("beanName")方法,如果对应的 bean 是非延迟加载的,那么直接就能拿出来进行使用,而延迟加载的 bean 就需要上面的步骤进行类的加载,加载完之后才能进行使用。
我们接着分析一下Ioc的bean实例化过程:
当我们显示或者隐式地调用 BeanFactory#getBean(String name)
方法时,则会触发加载 Bean 阶段。代码如下:
// AbstractBeanFactory.java @Override public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); }
内部调用 doGetBean(String name, final Class<T> requiredType, Object[] args, boolean typeCheckOnly)
方法,其接受四个方法参数:
name :要获取 Bean 的名字
requiredType :要获取 bean 的类型
args :创建 Bean 时传递的参数。这个参数仅限于创建 Bean 时使用。
typeCheckOnly :是否为类型检查。
//真正实现向IOC容器获取Bean的功能,也是触发依赖注入功能的地方 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { //根据指定的名称获取被管理Bean的名称,剥离指定名称中对容器的相关依赖 // 如果指定的是别名,将别名转换为规范的Bean名称 <1> final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. // 从缓存中获取已被创建过的单例Bean <2> Object sharedInstance = getSingleton(beanName); //如果缓存中有 if (sharedInstance != null && args == null) { if (logger.isDebugEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.debug("Returning cached instance of singleton bean '" + beanName + "'"); } } //注意:BeanFactory是管理容器中Bean的工厂 // FactoryBean是创建创建对象的工厂Bean,两者之间有区别 //获取给定Bean的实例对象,该对象要么是 bean 实例本身,要么就是 FactoryBean 创建的 Bean 对象 //(为什么要再次获取呢,因为上面获取的sharedInstance不一定是完整的) <3> bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. // 因为 Spring 只解决单例模式下的循环依赖,在原型模式下如果存在循环依赖则会抛出异常。 <4> if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. //对IOC容器中是否存在指定名称的BeanDefinition进行检查,首先检查是否 //能在当前的BeanFactory中获取的所需要的Bean,如果不能则委托当前容器 //的父级容器去查找,如果还是找不到则沿着容器的继承体系向父级容器查找 BeanFactory parentBeanFactory = getParentBeanFactory(); //当前容器的父级容器存在,且当前容器中不存在指定名称的Bean if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. //解析指定Bean名称的原始名称 String nameToLookup = originalBeanName(name); // 若为 AbstractBeanFactory 类型,委托父类处理 if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. //委派父级容器根据指定名称和显式的参数查找 return (T) parentBeanFactory.getBean(nameToLookup, args); } else { // No args -> delegate to standard getBean method. //委派父级容器根据指定名称和类型查找 return parentBeanFactory.getBean(nameToLookup, requiredType); } } // 创建的Bean是否需要进行类型验证,一般不需要 <5> if (!typeCheckOnly) { //向容器标记指定的Bean已经被创建 markBeanAsCreated(beanName); } try { //从容器中获取 beanName 相应的 GenericBeanDefinition 对象,并将其转换为 RootBeanDefinition 对象 // 主要解决Bean继承时子类合并父类公共属性问题 <6> final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 检查给定的合并的 BeanDefinition (是否为抽象类) checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. // 处理所依赖的 bean @DependsOn() // 获取当前Bean所有依赖Bean的名称 <7> String[] dependsOn = mbd.getDependsOn(); //如果有依赖 if (dependsOn != null) { for (String dep : dependsOn) { //校验该依赖是否已经注册过给当前 Bean if (isDependent(beanName, dep)) { //已注册,抛出异常 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } //没有,则先注册依赖的bean registerDependentBean(dep, beanName); //递归调用getBean(),先生成依赖的bean getBean(dep); } } // Create bean instance. //创建单例Bean <8> 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); } //创建多例Bean else if (mbd.isPrototype()) { //原型模式(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); } //要创建的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); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } // Check if required type matches the type of the actual bean instance. //对创建的Bean实例对象进行类型检查 <9> if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isDebugEnabled()) { logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }
代码很长,需要一些耐心,下面我们来逐步分析这段代码:
<1>处:具体分析,见2.1获取原始beanName
<2>处: 具体分析,见2.2从缓存中获取单例bean
<3>处: 具体分析,见2.3获取最终的bean实例对象
<4>处: 具体分析,见2.4原型模式依赖检查
<5>处: 具体分析,见2.5标记bean为已创建或即将创建
<6>处: 具体分析,见2.6获取BeanDefinition
<7>处: 具体分析,见2.7bean依赖处理
<8>处: 具体分析,见2.8不同作用域bean的实例化
<9>处: 具体分析,见2.9类型转换
代码如下:
final String beanName = transformedBeanName(name);
继续深入,代码如下:
protected String transformedBeanName(String name) { return canonicalName(BeanFactoryUtils.transformedBeanName(name)); }
BeanFactoryUtils.transformedBeanName(name)
方法主要是去除 FactoryBean 的修饰符
//对FactoryBean的转义定义,因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象, //如果需要得到工厂本身,需要转义 String FACTORY_BEAN_PREFIX = "&"; public static String transformedBeanName(String name) { Assert.notNull(name, "'name' must not be null"); String beanName = name; while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) { beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length()); } return beanName; }
ps: 如果一个factoryBean
的名称为“student”,获取factoryBean
创建的Bean时,使用getBean("student")
,获取factoryBean
本身时,使用getBean("&student")
接着深入,最终代码如下:
/** Map from alias to canonical name */ private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16); //循环处理,从aliasMap中根据aliasName获取真实beanName,直到获取到的真实beanName为null public String canonicalName(String name) { String canonicalName = name; // Handle aliasing... String resolvedName; do { resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); return canonicalName; }
主要是一个循环获取 beanName 的过程,例如,别名 A 指向名称为 B 的 bean 则返回 B,若 别名 A 指向别名 B,别名 B 指向名称为 C 的 bean,则返回 C
Spring 对单例模式的 bean 只会创建一次。后续,如果再获取该 Bean ,则是直接从单例缓存中获取,该过程就体现在 #getSingleton(String beanName) 方法中。代码如下:
/** Cache of singleton objects: bean name --> bean instance */ //单例bean的缓存 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); /** Cache of singleton factories: bean name --> ObjectFactory */ //单例对象工厂缓存 private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); /** Cache of early singleton objects: bean name --> bean instance */ //预加载单例bean缓存 //存放的 bean 不一定是完整的 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); //对于单例模式的Bean整个IOC容器中只创建一次,不需要重复创建 @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { //从单例缓存中获取单例bean Object singletonObject = this.singletonObjects.get(beanName); //如果缓存中没有 并且 该bean正在创建 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { singletonObject = this.earlySingletonObjects.get(beanName); // earlySingletonObjects 中没有,且允许提前创建 if (singletonObject == null && allowEarlyReference) { //从缓存中获取 ObjectFactory ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { //从单例工厂中获取bean singletonObject = singletonFactory.getObject(); //存入early this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } return singletonObject; }
这段代码很简单,流程如下:
第一步,从singletonObjects
中获取Bean对象
第二步,如果获取不到且Bean正在创建中,从earlySingletonObjects
获取Bean对象
第三步,如果获取不到且允许提前创建,从singletonFactories
获取FactoryBean
第四步,如果不为null,则通过FactoryBean.getObject()
获取Bean,然后将其加入到 earlySingletonObjects
,并且从 singletonFactories
删除,两者是互斥的,主要用来解决循环依赖的问题
总结就是:从这三个Map依次去取,取不到就取下一个Map
在上面的代码中又一个重要的方法isSingletonCurrentlyInCreation(beanName)
,代码如下:
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16)); public boolean isSingletonCurrentlyInCreation(String beanName) { return this.singletonsCurrentlyInCreation.contains(beanName); }
这个方法是用来判断当前Bean是否在创建中,看到是个Map,我们可以猜测,应该有一个地方在创建Bean的时候,会把正在创建的BeanName给put到这个Map中。具体我们之后将。
当我们从getSingleton(beanName)
拿到bean对象后,会接着调用getObjectForBeanInstance()
方法,来获取最终的Bean实例。
为什么这里要再获取一次Bean呢,之前明明都拿到了呀?
因为我们从缓存中获取的 bean 是最原始的 Bean ,并不一定是我们最终想要的 Bean
怎么办呢?调用 #getObjectForBeanInstance(...) 方法,进行处理,该方法的定义为获取给定 Bean 实例的对象,该对象要么是 bean 实例本身,要么就是 FactoryBean 创建的 Bean 对象。
看代码:
//获取给定Bean的实例对象,主要是完成FactoryBean的相关处理 protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { // Don't let calling code try to dereference the factory if the bean isn't a factory. //容器已经得到了Bean实例对象,这个实例对象可能是一个普通的Bean, //也可能是一个工厂Bean,如果是一个工厂Bean,则使用它创建一个Bean实例对象, //如果调用本身就想获得一个容器的引用,则指定返回这个工厂Bean实例对象 //若为工厂类引用(name 以 & 开头) 且 Bean实例也不是 FactoryBean if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) { //抛出异常 throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass()); } // Now we have the bean instance, which may be a normal bean or a FactoryBean. //如果类型不是FactoryBean,直接返回 if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { return beanInstance; } Object object = null; //若 BeanDefinition 为 null,则从缓存中加载 Bean 对象 if (mbd == null) { //从Bean工厂缓存中获取给定名称的Bean实例对象 object = getCachedObjectForFactoryBean(beanName); } // 若 object 依然为空,则可以确认,beanInstance 一定是 FactoryBean 。从而,使用 FactoryBean 获得 Bean 对象 if (object == null) { // Return bean instance from factory. FactoryBean<?> factory = (FactoryBean<?>) beanInstance; // Caches object obtained from FactoryBean if it is a singleton. // 检测是否定义 beanName if (mbd == null && containsBeanDefinition(beanName)) { //从容器中获取指定名称的Bean定义,如果继承基类,则合并基类相关属性 mbd = getMergedLocalBeanDefinition(beanName); } //如果从容器得到Bean定义信息,并且Bean定义信息不是虚构的, //则让工厂Bean生产Bean实例对象 boolean synthetic = (mbd != null && mbd.isSynthetic()); //调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法, //实现工厂Bean生产Bean对象实例的过程 object = getObjectFromFactoryBean(factory, beanName, !synthetic); } return object; }
首先看下这个方法的流程:
1、类型检查,判断是否是FactoryBean
2、对非 FactoryBean 不做处理
3、对 bean 进行转换
4、处理 FactoryBean 类型:委托给 getObjectFromFactoryBean 方法进行处理。
我们直接看第3步,走到这里,说明这个bean一定是FactoryBean
类型的,再从Ioc容器中获取该beanName对应的BeanDefinition,如果不为null,且不是abstract,则调用getObjectFromFactoryBean
方法获取bean实例
从这里可以看出, getObjectForBeanInstance(Object beanInstance, String name, String beanName,RootBeanDefinition mbd)
方法,分成两种情况:
第一种,当该实例对象为非 FactoryBean
类型,直接返回给定的 Bean 实例对象 beanInstance 。
第二种,当该实例对象为FactoryBean
类型,从 FactoryBean ( beanInstance ) 中,获取 Bean 实例对象。
我们接着看第二种情况:
//Bean工厂生产Bean实例对象 protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { //为单例模式且缓存中存在 if (factory.isSingleton() && containsSingleton(beanName)) { //多线程同步,以防止数据不一致 1.1 synchronized (getSingletonMutex()) { //从缓存中获取指定的 factoryBean 1.2 Object object = this.factoryBeanObjectCache.get(beanName); if (object == null) { // 为空,则从 FactoryBean 中获取对象 object = doGetObjectFromFactoryBean(factory, beanName); // Only post-process and store if not put there already during getObject() call above // (e.g. because of circular reference processing triggered by custom getBean calls) Object alreadyThere = this.factoryBeanObjectCache.get(beanName); if (alreadyThere != null) { object = alreadyThere; } else { 1.3 if (shouldPostProcess) { try { // 对从 FactoryBean 获取的对象进行后处理 // 生成的对象将暴露给 bean 引用 object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", ex); } } //将生产的实例对象添加到Bean工厂缓存中 1.4 this.factoryBeanObjectCache.put(beanName, object); } } return object; } } // 为空,则从 FactoryBean 中获取对象 2 else { Object object = doGetObjectFromFactoryBean(factory, beanName); // 需要后续处理 if (shouldPostProcess) { try { object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex); } } return object; } }
1、判断是否为单例并且缓存中存在 如果存在,则顺着1.1往下走,不存在,则走2的流程
1.1、sync加锁,锁住的是singletonObjects
,和其他单例锁一样,保证全局唯一
1.2、从缓存factoryBeanObjectCache
中获取Bean实例 如果获取不到,则调用doGetObjectFromFactoryBean()
方法获取,实际最后调用的是factory.getObject()
方法
1.3、如果需要后续处理( shouldPostProcess = true ),则进行下一步处理 postProcessObjectFromFactoryBean()
方法,对从 FactoryBean 处获取的 Bean 实例对象进行后置处理。其默认实现是直接返回 object 对象,不做任何处理。代码如下:
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException { return object; }
但是子类可以重写,例如应用后处理器等。
1.4、加入到 factoryBeanObjectCache 缓存中
2、如果缓存中不存在,同样调用doGetObjectFromFactoryBean()
获取bean实例
到此,相信大家对“Spring Ioc中Bean加载的方法”有了更深的了解,不妨来实际操作一番吧!这里是亿速云网站,更多相关内容可以进入相关频道进行查询,关注我们,继续学习!
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。