AbstractApplicationContext#refresh
public void refresh() {
synchronized (this.startupShutdownMonitor) {
//准备刷新，初始化一些标志，比如active=true，closed=false，准备环境
//Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
//获得bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context
//准备bena工厂，比如往bena工厂添加类加载器，添加el表达式解析器
//添加一些beanpostprocessor 比如 ApplicationContextAwareProcessor
//和ApplicationListenerDetector
//往ApplicationListenerDetector添加一些依赖
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
//钩子方法，让子类去操作bean工厂
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context
//很重要，执行beanFactoryPostProcessors ，后面讲
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
//其实就是往 beanPostProcessors 注册beanPostProcessor
//bean的后置处理器，在实例化和初始化bean的时候都会用到
//也是spring的扩展点之一
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
//初始化 国际化用的 messagesource
initMessageSource();
// Initialize event multicaster for this context.
//初始化监听用的广播器 ApplicationEventMulticaster
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
//在springboot中
//会回调子类方法：ServletWebServerApplicationContext#onRefresh
//在子类方法中会 调用createWebServer()方法去创建容器
onRefresh();
// Check for listener beans and register them.
//往广播器 注册一些监听器，监听器用set管理起来的
//因为springboot启动的时候也会往set注册监听器，set就不会重复了
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//重点，开始往spring单例池中注册bean
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
//没研究，看上面的英文注释，是推送事件？？？
finishRefresh();
}
### AbstractApplicationContext#finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//....忽略不影响主流程代码
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
DefaultListableBeanFactory#preInstantiateSingletons
public void preInstantiateSingletons(){
.....
//把beandefinition 从beanDefinitionNames 这个map拿出来，遍历
//实例化，促使化需要被spring管理的bena
getBean(beanName);
.....
}
AbstractBeanFactory#doGetBean
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//获取beanname
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//先从单例池中根据bean名称获取bean，如果拿不到，就先去 //singletonsCurrentlyInCreation 这个list中拿，
//这个主要是bean在实例化的时候放进去的，表示bean正在创建
//如果bean正在创建，从earlySingletonObjects这个map拿
//如果拿不到就从singletonFactories拿bean的objectFactory（bean实例化之后放进去）
//如果拿到就放到 earlySingletonObjects，取出singletonFactories的引用
//这个方法可以解决循环依赖 很重要
Object sharedInstance = getSingleton(beanName);
........
if (!typeCheckOnly) {
//将bean名称放到 alreadyCreated
//表示正在创建，这个倒是没看到后续有啥用
markBeanAsCreated(beanName);
}
try {
//合并父类的属性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
..........
// Create bean instance. 重要
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//最重要的逻辑在这里
return createBean(beanName, mbd, args);
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
............
return (T) bean;
}
DefaultSingletonBeanRegistry#getSingleton
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//再次从单例池中获取bean
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
.......
//在bean实例化前先放到一个list中去，告诉别人，这个bean在实例化了
//放到 singletonsCurrentlyInCreation
beforeSingletonCreation(beanName);
...........
try {
//开始实例化，初始化bean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
...........
finally {
//实例化完bean，将beanname从singletonsCurrentlyInCreation
//移除，因为已经实例化完了
afterSingletonCreation(beanName);
}
//如果是单例
if (newSingleton) {
//往singletonObjects这个单例池中放bean，这个可以说就是狭义的ioc容器
//移除 singletonFactories，earlySingletonObjects，registeredSingletons
//这个三个容器，会在 singletonFactory.getObject() 这里放进去
//到这里spring就完成了对bean的管理，放到容器也就是一个map中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
singletonFactory.getObject() 做了什么？就是前面说的 AbstractAutowireCapableBeanFactory#createBean
AbstractAutowireCapableBeanFactory#createBean
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args){
//解析出 class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
..............
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 调用InstantiationAwareBeanPostProcessor 看是否有实例
//如果有就不走后续流程
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
...............
try {
//创建bean，最终要的步骤
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
...........
}
AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
........
if (instanceWrapper == null) {
//实例化bean，然后放到BeanWrapperImpl
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
................
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//调用 MergedBeanDefinitionPostProcessor 去将类中的注解缓存下来
//为了后续依赖注入等做准备
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
..............
}
}
...........
if (earlySingletonExposure) {
............
//很重要，做了两件事情
//1.调用SmartInstantiationAwareBeanPostProcessor 判断是否需要包装bean
//在aop上有使用到
//2.将实例化的对象，放到singletonFactories这个map，可以解决循环依赖
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//填充属性
populateBean(beanName, mbd, instanceWrapper);
//初始化对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
...........
return exposedObject;
}
实例化对象：AbstractAutowireCapableBeanFactory#createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
//解析出class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
..............
// Candidate constructors for autowiring?
//调用 SmartInstantiationAwareBeanPostProcessor 判断要使用那个构造方法进行实例化
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);
}
//使用默认的构造方法实例化，实例化其实就是调用java反射
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
里面还有很多复杂的逻辑，比如怎么填充属性，怎么做到依赖注入，怎么对对象初始化等等..........
