一般情况下依赖注入是发生在用户第一次向IOC容器获取bean的过程中，当然也有例外那就是用户设置了lazy-init属性，如果设置了这个属性依赖注入会在bean初始化过程完成，后面我们单独分析这种情况。所有的BeanFactory都会继承一个最基本的BeanFactory，里面有一个最基本的方法getBean(),依赖注入的触发及发生在该方法第一次被调用的时候。我们还是从DefaultListableBeanFactory这个BeanFactory入手。这个类的继承体系还是比较复杂的。
其中AbstractBeanFactory中实现了基本的BeanFactory的所有接口，代码中有这么一句注释：Implementation of BeanFactory interface。
//--------------------------------------------------------------------- // Implementation of BeanFactory interface //--------------------------------------------------------------------- @Override public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); } @Override public T getBean(String name, Class requiredType) throws BeansException { return doGetBean(name, requiredType, null, false); } @Override public Object getBean(String name, Object... args) throws BeansException { return doGetBean(name, null, args, false); } /** * Return an instance, which may be shared or independent, of the specified bean. * @param name the name of the bean to retrieve * @param requiredType the required type of the bean to retrieve * @param args arguments to use when creating a bean instance using explicit arguments * (only applied when creating a new instance as opposed to retrieving an existing one) * @return an instance of the bean * @throws BeansException if the bean could not be created */ public T getBean(String name, Class requiredType, Object... args) throws BeansException { return doGetBean(name, requiredType, args, false); } 获取bean的过程在doGetBean()方法中:
protectedT doGetBean( final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException { //将别名转化成bean定义名称 final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. //从缓存中获取单例bean 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 + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // 如果存在循环引用问题 抛出创建bean异常 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. //从当前缓存中获取不到BeanDefinition就从父级容器中链式查找 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); 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); } } //判断是否需要类型验证 if (!typeCheckOnly) { //标记bean已经被创建好了 markBeanAsCreated(beanName); } try { //根据指定Bean名称获取其父级的Bean定义，主要解决Bean继承时子类问题，合并父类公共属性问题 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. //获取到当前bean所依赖的所有bean的名字 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { //Spring 4.0开始对依赖注入的bean进行循环依赖检查，如果需要注入的bean存在循环依赖则抛出异常。 if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } //保存当前bean与需要依赖的bean之间的依赖关系 registerDependentBean(dep, beanName); //递归获取到当前依赖的bean实例 getBean(dep); } } // 创建单例模式的bean实例对象 if (mbd.isSingleton()) { //创建bean单例模式对象，这里采用了一个匿名内部类实现，并且实现了回调，这个方法后续在研究 sharedInstance = getSingleton(beanName, new ObjectFactory
从上面代码可以看出，如果需要创建的是单例的（默认是单例）则从缓存中加载，保证Spring上下文中只有一个实例对象存在，如果内存中不存在则创建并保存在内存中；
如果是原型模式对象，则每次都会创建一个bean对象；
如果均不为上两种则根据bean定义的置顶生命周期创建。
我们主要研究单例bean的创建过程：
sharedInstance = getSingleton(beanName, new ObjectFactory
上述代码是bean的实际创建过程，里面用到了一个匿名内部类回调，真正的是：return createBean(beanName, mbd, args);这个方法是一个抽象方法其实现在AbstractAutowireCapableBeanFactory中,其内部实现如下:
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { if (logger.isDebugEnabled()) { logger.debug("Creating instance of bean '" + beanName + "'"); } RootBeanDefinition mbdToUse = mbd; // Make sure bean class is actually resolved at this point, and // clone the bean definition in case of a dynamically resolved Class // which cannot be stored in the shared merged bean definition. Class resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { //尝试返回一个代理对象给bean的前后置处理器，这个一会再详细分析 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); //如果返回的对象不为null，直接返回 if (bean != null) { return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } //创建实例方法 Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isDebugEnabled()) { logger.debug("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; }
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { //如果是单例对象先从缓存中找到同名的对象 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { //如果缓存中没有遭到则调用createBeanInstance创建bean对应的Java对象实例 instanceWrapper = createBeanInstance(beanName, mbd, args); } final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null); //获取实例化对象的类型 Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null); mbd.resolvedTargetType = beanType; // 调用后置处理器 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } //缓存对象 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isDebugEnabled()) { logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } //防止循环引用尽早持有引用对象 addSingletonFactory(beanName, new ObjectFactory 到此IOC依赖注入基本完成。