《JavaPub源码》
Spring IOC 源码分析之深入理解 IOC
如果你要学习，最好的时间是十年前，其次就是当下。
在Spring框架中，IOC（Inversion of Control，控制反转）是其中最重要的一个核心概念。它的实现方式是通过BeanFactory和ApplicationContext等容器来管理对象的创建、依赖注入、生命周期等等。
下面，我们将通过分析Spring的源码，来深入理解IOC的实现原理
BeanFactory接口
在Spring的IOC容器中，BeanFactory是最基本的容器接口。它定义了IOC容器的基本行为，包括获取Bean、销毁Bean等操作。
public interface BeanFactory {
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}上述接口中，最核心的方法是 getBean() 方法，它通过Bean的名称或类型，返回对应的Bean对象。在Spring IOC的实现中，getBean() 方法是通过BeanFactory实现的，我们来看一下BeanFactory的默认实现类：DefaultListableBeanFactory。
DefaultListableBeanFactory
DefaultListableBeanFactory是Spring IOC容器的默认实现类。它实现了BeanFactory接口，并提供了Bean的定义、注册、获取等操作。
在DefaultListableBeanFactory中，最核心的是BeanDefinition对象。它是Spring IOC容器中的核心数据结构，表示一个Bean的定义信息，包括Bean的类名、构造方法、属性、依赖等等。下面是BeanDefinition接口的定义：
public interface BeanDefinition {
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
String getBeanClassName();
void setBeanClassName(String beanClassName);
String getScope();
void setScope(String scope);
boolean isSingleton();
boolean isPrototype();
String getFactoryMethodName();
void setFactoryMethodName(String factoryMethodName);
String getFactoryBeanName();
void setFactoryBeanName(String factoryBeanName);
String[] getDependsOn();
void setDependsOn(String... dependsOn);
boolean isLazyInit();
void setLazyInit(boolean lazyInit);
ConstructorArgumentValues getConstructorArgumentValues();
MutablePropertyValues getPropertyValues();
boolean isAutowireCandidate();
void setAutowireCandidate(boolean autowireCandidate);
}上述接口中，最核心的是 getBeanClassName() 和 getPropertyValues() 方法。 getBeanClassName() 返回Bean的类名，getPropertyValues() 返回Bean的属性值。在DefaultListableBeanFactory中，BeanDefinition是在DefaultListableBeanFactory中，BeanDefinition是通过Map来存储的，其中key是Bean的名称，value是对应的BeanDefinition对象。具体实现如下：
// 搜索 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;
}
}在DefaultListableBeanFactory中，Bean的创建、依赖注入和初始化等操作都是在doGetBean()方法中完成的。接下来，我们将重点介绍Bean的创建和依赖注入过程。
Bean
Bean的创建过程
在DefaultListableBeanFactory中，Bean的创建是通过createBean()方法完成的，具体实现如下：
protected Object createBean(final String beanName, final BeanDefinition beanDefinition, final Object[] args) {
// 创建Bean实例
Object beanInstance = createBeanInstance(beanDefinition, beanName, args);
// 设置Bean实例的Class属性
Class<?> beanType = beanInstance.getClass();
if (!beanType.equals(Object.class)) {
beanDefinition.setBeanClass(beanType);
}
// 对Bean实例进行属性赋值和方法注入
applyPropertyValues(beanName, beanDefinition, beanInstance);
// 处理Aware接口的回调
invokeAwareMethods(beanName, beanInstance);
// Bean后处理器的前置处理
Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(beanInstance, beanName);
// 调用Bean实例的初始化方法
try {
invokeInitMethods(beanName, wrappedBean, beanDefinition);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Invocation of init method failed", ex);
}
// Bean后处理器的后置处理
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
// 返回Bean实例
return wrappedBean;
}在createBean()方法中，首先通过createBeanInstance()方法创建Bean实例，然后设置Bean实例的Class属性、对Bean实例进行属性赋值和方法注入、处理Aware接口的回调、调用Bean实例的初始化方法，最后通过Bean后处理器进行前置处理和后置处理，最终返回Bean实例。
Bean的依赖注入过程
在DefaultListableBeanFactory中，Bean的依赖注入是通过applyPropertyValues()方法完成的，具体实现如下：
protected void applyPropertyValues(String beanName, BeanDefinition beanDefinition, Object bean) {
try {
// 对Bean实例进行属性赋值和方法注入
PropertyValues pvs = beanDefinition.getPropertyValues();
if (pvs != null) {
for (PropertyValue pv : pvs.getPropertyValues()) {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
Object resolvedValue = resolveValueIfNecessary(beanName, beanDefinition, propertyName, originalValue);
BeanWrapper bw = new BeanWrapperImpl(bean);
bw.setPropertyValue(propertyName, resolvedValue);
}
}
}
catch (BeansException ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
}在applyPropertyValues()方法中，首先获取BeanDefinition对象的PropertyValues属性，然后遍历其中的PropertyValue对象，获取属性名称和属性值，并通过resolveValueIfNecessary()方法解析属性值，最后通过BeanWrapperImpl对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;
}
}在resolveValueIfNecessary()方法中，如果属性值是一个BeanDefinitionHolder对象或者RuntimeBeanReference对象，说明属性是一个引用类型，需要进行自动装配。此时会调用resolveReference()方法进行引用的解析和自动装配。
在resolveReference()方法中，如果引用类型是一个RuntimeBeanReference对象或者BeanDefinitionHolder对象，说明需要进行自动装配。此时会通过getBean()方法获取引用类型对应的Bean实例，并返回该实例。如果获取不到Bean实例，则会抛出异常。
在自动装配的过程中，Spring会先根据属性的类型进行匹配，如果找到一个唯一的Bean实例，则使用该实例进行自动装配。如果还是找不到唯一的Bean实例，则会抛出异常。
除了自动装配外，Spring还支持手动装配，即通过配置元素来显式地指定属性值。例如：
<bean id="foo" class="com.example.Foo">
<property name="bar" value="hello"/>
</bean>上述配置表示创建一个名为foo的Bean实例，该实例的class属性为com.example.Foo，bar属性的值为字符串hello。
在手动装配的过程中，Spring会将配置的属性值解析为一个String类型的值，并将其转换为目标属性类型，最终将转换后的值设置到目标属性中。
以上就是Spring IOC源码分析的基本内容，通过阅读源码，我们可以深入理解Spring IOC的实现原理，为使用和定制Spring提供了很好的基础。
硬核源码刨析 · Spring · JavaPub
硬核源码刨析 · SpringMVC · JavaPub
硬核源码刨析 · MyBatis · JavaPub
硬核源码刨析 · Dubbo · JavaPub
硬核源码刨析 · Netty · JavaPub
硬核源码刨析 · Elastic-Job · JavaPub
硬核源码刨析 · GoLang · JavaPub
