Spring|Spring - IOC容器初始化 Spring-IOC容器初始化

最近阅读了一些Spring Framework里IOC容器的初始化相关的代码。
IOC容器的初始化，将对象交给容器去管理
bean：交给ioc容器去管理的对象

初始化bean工厂

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry { public GenericApplicationContext() { this.beanFactory = new DefaultListableBeanFactory(); } }

Map beanDefinitionMap //缓存beanDefinition，key：id（beanName）
BeanDefinition:bean的定义，承载bean的属性

注册beanDefinition到beanDefinitionMap
beanDefinitionRegistry：bean定义的注册器，注册bean

//bean工厂的后置处理器。解析注解，注册bean
invokeBeanFactoryPostProcessors(beanFactory);
【Spring|Spring - IOC容器初始化】//bean的后置处理器
registerBeanPostProcessors(beanFactory);

实例化bean
// 实例化非懒加载的单例bean
finishBeanFactoryInitialization(beanFactory);

DefaultListableBeanFactory
preInstantiateSingletons()
创建bean之前判断，singletonObjects单例对象池中获取
Map singletonObjects 缓存单例，key: beanName
getSingleton(beanName)
单例工厂
ObjectFactory singletonFactory
3.1 new（实例化）
反射：选择构造器
@Bean method.invoke
instanceWrapper = createBeanInstance(beanName, mbd, args);
3.2 填充属性
普通属性，依赖bean
populateBean(beanName, mbd, instanceWrapper);

PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);

@Override public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) { InjectionMetadata metadata = https://www.it610.com/article/findAutowiringMetadata(beanName, bean.getClass(), pvs); try { metadata.inject(bean, beanName, pvs); } catch (BeanCreationException ex) { throw ex; } catch (Throwable ex) { throw new BeanCreationException(beanName,"Injection of autowired dependencies failed", ex); } return pvs; }

3.3 初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);
3.4 放入单例对象池singletonObjects
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
3.5 factoryBean的判断
getObjectForBeanInstance(sharedInstance, name, beanName, null)
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
factoryBean，既是普通bean，又是特殊bean
几个重要的类：
DefaultListableBeanFactory
BeanDefinition

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable { // /** Map of bean definition objects, keyed by bean name. */ private final Map beanDefinitionMap = new ConcurrentHashMap<>(256); // }

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON; String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE; void setScope(@Nullable String scope); @Nullable String getScope(); void setLazyInit(boolean lazyInit); boolean isLazyInit(); /** * Set the names of the beans that this bean depends on being initialized. * The bean factory will guarantee that these beans get initialized first. */ void setDependsOn(@Nullable String... dependsOn); @Nullable String[] getDependsOn(); void setInitMethodName(@Nullable String initMethodName); @Nullable String getInitMethodName(); }

AbstractBeanDefinition，通过这个类，可以窥见bean的一些默认设置。

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable {private int autowireMode = AUTOWIRE_NO; @Nullable private String scope = SCOPE_DEFAULT; private boolean lazyInit = false; }

Spring有几种bean构造器模式，定义在AutowireCapableBeanFactory里。

public interface AutowireCapableBeanFactory extends BeanFactory { /** * Constant that indicates no externally defined autowiring. Note that * BeanFactoryAware etc and annotation-driven injection will still be applied. * @see #createBean * @see #autowire * @see #autowireBeanProperties */ int AUTOWIRE_NO = 0; /** * Constant that indicates autowiring bean properties by name * (applying to all bean property setters). * @see #createBean * @see #autowire * @see #autowireBeanProperties */ int AUTOWIRE_BY_NAME = 1; /** * Constant that indicates autowiring bean properties by type * (applying to all bean property setters). * @see #createBean * @see #autowire * @see #autowireBeanProperties */ int AUTOWIRE_BY_TYPE = 2; /** * Constant that indicates autowiring the greediest constructor that * can be satisfied (involves resolving the appropriate constructor). * @see #createBean * @see #autowire */ int AUTOWIRE_CONSTRUCTOR = 3; }

BeanDefinitionRegistry

public interface BeanDefinitionRegistry extends AliasRegistry { void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException; }

/** * Create a new instance for the specified bean, using an appropriate instantiation strategy: * factory method, constructor autowiring, or simple instantiation. * @param beanName the name of the bean * @param mbd the bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a BeanWrapper for the new instance * @see #obtainFromSupplier * @see #instantiateUsingFactoryMethod * @see #autowireConstructor * @see #instantiateBean */ protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // Make sure bean class is actually resolved at this point. Class beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); }Supplier instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); }if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); }// Shortcut when re-creating the same bean... boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } if (resolved) { if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null); } else { return instantiateBean(beanName, mbd); } }// Candidate constructors for autowiring? Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); }// Preferred constructors for default construction? ctors = mbd.getPreferredConstructors(); if (ctors != null) { return autowireConstructor(beanName, mbd, ctors, null); }// No special handling: simply use no-arg constructor. return instantiateBean(beanName, mbd); }