本篇内容主要讲解“Spring Ioc中Bean加载的方法”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Spring Ioc中Bean加载的方法”吧!
10年积累的成都做网站、成都网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站制作后付款的网站建设流程，更有金秀免费网站建设让你可以放心的选择与我们合作。
在之前的文章中，我们分析了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 方法，其接受四个方法参数：
name ：要获取 Bean 的名字
requiredType ：要获取 bean 的类型
args ：创建 Bean 时传递的参数。这个参数仅限于创建 Bean 时使用。
typeCheckOnly ：是否为类型检查。
//真正实现向IOC容器获取Bean的功能，也是触发依赖注入功能的地方 protectedT doGetBean(final String name, @Nullable final Class 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")
接着深入，最终代码如下：
