spring源码学习 - 一个简单bean的实例化过程

前言

在Spring容器中bean的解析注册和实例化是两个不同的过程,上一篇讲到Spring在初始化的时候会将我们定义的javaBean的相关元信息封装到beanDefinitionMap当中. 当要使用这个javaBean的时候spring会根据beanDefinition来实例化该对象.对初始化过程不是很清楚的朋友推荐先看看这两篇文章了解下解析注册过程

• spring源码学习 - xml方式bean的解析注册过程
• spring源码学习 - 注解bean的解析注册过程

带着问题看源码:

如果不new对象, spring是如何实例化对象的

debug过程,这里拿一个最简单的javaBean

1. 创建一个简单的javaBean

public class TestBean {
    private String name;

    public TestBean() {
    }

    public TestBean(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2. 在spring.xml中配置

3. 准备测试环境,这里采用spring提供的web单元测试功能,对spring测试功能的不清楚的朋友可以看下文档.

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration(value = "classpath:src/main/webapp")
@ContextConfiguration({"classpath:spring.xml", "classpath:spring/spring-mvc.xml"})
@Transactional
public class DebugSpring {
    private static final Logger log = LoggerFactory.getLogger(DebugSpring.class);

    @Test
    public void testLoad() throws IOException {
        Resource resource = new ClassPathResource("spring.xml");
        BeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
        TestBean testBean = xmlBeanFactory.getBean("testBean", TestBean.class); 
        log.debug("test bean name is :{}", testBean.getName());
    }
}

4. 测试环境准备好了,在TestBean testBean = xmlBeanFactory.getBean("testBean", TestBean.class);打断点开始进行正式的debug过程,进入到:

AbstractBeanFactory

@Override
 public  T getBean(String name, Class requiredType) throws BeansException {
     return doGetBean(name, requiredType, null, false);
 }

 @SuppressWarnings("unchecked")
 protected  T doGetBean(
         final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
         throws BeansException {
     //获取真实的beanName
     // 分两种情况需要转换
     // 1.别名
     // 2.传入的是工厂Bean名, 例如:"&beanName"
     final String beanName = transformedBeanName(name);
     Object bean;
     // Eagerly check singleton cache for manually registered singletons.
     //如果我们获取的bean的scope是singleton的话,首先实例化bean的时候spring会将其缓存起来,提升性能
     Object sharedInstance = getSingleton(beanName);
     //这里获取到的sharedInstance的对象还处于最初始状态的bean
     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是从工厂bean中定义的factory-method方法中生产的bean
         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
     }
     //如果是第一次创建该bean
     else {
         //原型模式下是无法解决循环依赖的,直接抛异常
         //a中有b的属性,b中有a属性
         //当创建a时会去创建b,创建b时会去创建a直接就死循环了....
         if (isPrototypeCurrentlyInCreation(beanName)) {
             throw new BeanCurrentlyInCreationException(beanName);
         }
         //尝试从父容器中进行加载
         BeanFactory parentBeanFactory = getParentBeanFactory();
         //如果当前容器属于子容器,并且该容器中没有定义该bean则从父类中进行加载
         //一直递归下去
         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);
             }
         }
         //如果是创建bean则进行相应记录
         if (!typeCheckOnly) {
             markBeanAsCreated(beanName);
         }

         try {
             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
             checkMergedBeanDefinition(mbd, beanName, args);

             //如果该bean中存在依赖bean
             String[] dependsOn = mbd.getDependsOn();
             if (dependsOn != null) {
                 for (String dependsOnBean : dependsOn) {
                     if (isDependent(beanName, dependsOnBean)) {
                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                 "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                     }
                     //注册
                     registerDependentBean(dependsOnBean, beanName);
                     //依赖bean中可能还存在依赖bean,进入递归
                     getBean(dependsOnBean);
                 }
             }

             // 作用域是单例模式,当依赖bean创建完成,开始创建本身实例
             if (mbd.isSingleton()) {
                 //首先创建工厂bean
                 //然后由工厂bean创建真实bean对象
                 sharedInstance = getSingleton(beanName, new ObjectFactory