Spring IOC 源码分析之深入理解 IOC

// 搜索 JavaPub，Spring 源码讲解。
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

    // 存储BeanDefinition的Map
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    // BeanDefinition注册接口的实现方法
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {
        Assert.hasText(beanName, "Bean name must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");

        synchronized (this.beanDefinitionMap) {
            BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
            if (existingDefinition != null) {
                if (!beanDefinition.equals(existingDefinition)) {
                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(),
                            beanName, "Definition of bean '" + beanName + "' differs from existing " +
                            "definition for the same bean name. " + "Consider deleting or renaming the existing " +
                            "bean definition with the same name.");
                }
            }
            else {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                this.frozenBeanDefinitionNames = null;
            }
        }
    }

    // BeanDefinition获取接口的实现方法
    @Override
    public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
        Assert.hasText(beanName, "Bean name must not be empty");
        BeanDefinition bd = this.beanDefinitionMap.get(beanName);
        if (bd == null) {
            throw new NoSuchBeanDefinitionException(beanName);
        }
        return bd;
    }

    // 根据Bean名称获取Bean对象
    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

    // 根据Bean类型获取Bean对象
    @Override
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        return doGetBean(requiredType.getName(), requiredType, null, false);
    }

    // 根据Bean名称和类型获取Bean对象
    @Override
    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
        return doGetBean(name, requiredType, null, false);
    }

    // 核心方法，通过Bean名称或类型获取Bean对象
    protected <T> T doGetBean(final String name, final Class<T> requiredType,
            final Object[] args, boolean typeCheckOnly) throws BeansException {

        // 根据名称或类型解析BeanDefinition对象
        final BeanDefinition beanDefinition = getBeanDefinition(name);

        // 根据BeanDefinition对象创建Bean实例
        Object bean = createBean(name, beanDefinition, args);

        // 对Bean实例进行依赖注入
        populateBean(beanName, beanDefinition, bean);

        // 对Bean实例进行初始化
        initializeBean(beanName, bean, beanDefinition);

        // 返回Bean实例
        return (T) bean;
    }
}

protected Object resolveValueIfNecessary(String beanName, BeanDefinition beanDefinition, String propertyName,
        Object originalValue) {
    if (originalValue instanceof BeanDefinitionHolder) {
        // 如果属性值是一个BeanDefinitionHolder对象，说明属性是一个引用类型
        BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) originalValue;
        Object ref = resolveReference(bdHolder, beanName, propertyName);
        if (ref instanceof NullBean) {
            return null;
        }
        return ref;
    }
    else if (originalValue instanceof RuntimeBeanReference) {
        // 如果属性值是一个RuntimeBeanReference对象，说明属性是一个引用类型
        RuntimeBeanReference ref = (RuntimeBeanReference) originalValue;
        return resolveReference(ref, beanName, propertyName);
    }
    else if (originalValue instanceof ObjectFactory) {
        // 如果属性值是一个ObjectFactory对象，说明属性是一个懒加载类型
        ObjectFactory<?> objectFactory = (ObjectFactory<?>) originalValue;
        return objectFactory.getObject();
    }
    else if (originalValue instanceof ObjectProvider) {
        // 如果属性值是一个ObjectProvider对象，说明属性是一个懒加载类型
        ObjectProvider<?> objectProvider = (ObjectProvider<?>) originalValue;
        return objectProvider.getObject();
    }
    else {
        // 如果属性值不是一个引用类型，直接返回原始值
        return originalValue;
    }
}

protected Object resolveReference(Object ref, String beanName, String propertyName) {
    if (ref instanceof RuntimeBeanReference) {
        // 如果引用类型是一个RuntimeBeanReference对象，说明需要进行自动装配
        RuntimeBeanReference reference = (RuntimeBeanReference) ref;
        String refName = reference.getBeanName();
        Object bean;
        try {
            bean = getBean(refName);
        }
        catch (BeansException ex) {
            throw new BeanCreationException(beanName, "Could not resolve reference to bean '" + refName + "' in property '" + propertyName + "'", ex);
        }
        if (bean instanceof NullBean) {
            return null;
        }
        return bean;
    }
    else if (ref instanceof BeanDefinitionHolder) {
        // 如果引用类型是一个BeanDefinitionHolder对象，说明需要进行自动装配
        BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) ref;
        return resolveReference(bdHolder.getBeanDefinition(), beanName, propertyName);
    }
    else {
        // 如果引用类型不是一个RuntimeBeanReference或者BeanDefinitionHolder对象，直接返回引用类型
        return ref;
    }
}

<bean id="foo" class="com.example.Foo">
    <property name="bar" value="hello"/>
</bean>