AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);      

public GenericApplicationContext(){ 
  this.beanFactory = new DefaultListableBeanFactory(); 
}

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml"); 

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 
> refreshBeanFactory(); // AbstractApplicationContext#refreshBeanFactory 

DefaultListableBeanFactory beanFactory = createBeanFactory(); 
beanFactory.setSerializationId(getId()); 
// 定制beanFactory,设置参数 
customizeBeanFactory(beanFactory); 
// 注册spring的xml配置的bean到beanFactory,此时容器还未指定beanbeanFactory
loadBeanDefinitions(beanFactory); 
// 给容器指定beanFactory 
synchronized(this.beanFactoryMonitor){ 
  this.beanFactory = beanFactory; 
} 

DefaultListableBeanFactory#registerBeanDefinition   //实现了BeanDefinitionRegistry 
> beanDefinitionMap.put(beanName,beanDefinition); //缓存beanDefinition 

// 拿到工厂 实现了BeanDefinitionRegistry 
DefaultListableBeanFactorybeanFactory = context.getDefaultListableBeanFactory(); 
// 创建一个beanDefinition 
RootBeanDefinitionbeanDefinition = newRootBeanDefinition(User.class); 
// 注册 
beanFactory.registerBeanDefinition("user",beanDefinition); 

invokeBeanFactoryPostProcessors(beanFactory); // 解析注解,注册bean 
> ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry 

// 解析配置类@ComponentScan(bean注册到容器)@Import @ImportResource @Bean 
parser.parse(candidates); 
// 注册bean到容器 
// 注册实现了ImportSelector的bean 
// 方法bean注册到容器 
// @ImportResource("spring.xml")配置的bean注册到容器 
// 实现ImportBeanDefinitionRegistrar的bean注册到容器 
this.reader.loadBeanDefinitions(configClasses); 

parser.parse(candidates); 
> ConfigurationClassParser#processConfigurationClass 
> ConfigurationClassParser#doProcessConfigurationClass 

ClassPathBeanDefinitionScanner#doScan 
> 
// 找到@Component修饰的类的beanDefiniton集合 
Set<BeanDefinition> candidates = findCandidateComponents(basePackage); 
// 注册bean 
registerBeanDefinition(definitionHolder,this.registry); 

this.reader.loadBeanDefinitions(configClasses)
> ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass 
if(configClass.isImported()){ 
  // implementsImportSelector的bean注册 
  registerBeanDefinitionForImportedConfigurationClass(configClass); 
} 
for(BeanMethodbeanMethod : configClass.getBeanMethods()){ 
  // 方法bean注册到容器 
  loadBeanDefinitionsForBeanMethod(beanMethod); 
} 
// @ImportResource("spring.xml")配置的bean注册到容器loadBeanDefinitionsFromImportedResources(configClass.getImportedResources()); 
//实现ImportBeanDefinitionRegistrar的bean注册到容器 
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars()); 

ConfigurableListableBeanFactorybeanFactory = obtainFreshBeanFactory(); 
> refreshBeanFactory(); // AbstractApplicationContext#refreshBeanFactory 

DefaultListableBeanFactorybeanFactory = createBeanFactory(); 
beanFactory.setSerializationId(getId()); 
// 定制beanFactory,设置参数 
customizeBeanFactory(beanFactory); 
// 注册spring的xml配置的bean到beanFactory,此时容器还未指定beanbeanFactoryloadBeanDefinitions(beanFactory); 
// 给容器指定beanFactory 
synchronized(this.beanFactoryMonitor){ 
  this.beanFactory = beanFactory ; 
} 

// 注册spring的xml配置的bean到beanFactory,此时容器还未指定beanbeanFactory
loadBeanDefinitions(beanFactory); 
> DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions 
preProcessXml(root); 
parseBeanDefinitions(root,this.delegate); // 解析xml 
postProcessXml(root); 
> DefaultBeanDefinitionDocumentReader#parseDefaultElement 
else if(delegate.nodeNameEquals(ele,BEAN_ELEMENT)){ 
// 解析bean 
processBeanDefinition(ele,delegate); 
} 
> DefaultBeanDefinitionDocumentReader#processBeanDefinition 
// 注册最后修饰后的实例beanDefinition 
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
getReaderContext().getRegistry()); 

// 注册beanDefiniton 
registry.registerBeanDefinition(beanName,definitionHolder.getBeanDefinition()); 

AbstractApplicationContext#refresh 
// Instantiateallremaining(non-lazy-init)singletons. 
// 实例化所有剩余的(非懒加载)单例 。 
> finishBeanFactoryInitialization(beanFactory); 
> AbstractApplicationContext#getBean(String)

AbstractApplicationContext #getBean(String)
> AbstractBeanFactory #getBean(String)

// 转换对应的beanName 
// 1. 带 & 前缀的去掉前缀 
// 2. 从aliasMap中找name对应id,bean没有配id就用name 
finalStringbeanName = transformedBeanName(name);
// 先从缓存singletonObjects中找,没有则去创建 
// 处理循环依赖的问题,比如A ->B,B->A 
ObjectsharedInstance = getSingleton(beanName); 
// 判断单例 
if(mbd.isSingleton()){ 
	sharedInstance = getSingleton(beanName,()-> { 
		return createBean(beanName,mbd,args); 
  });   
  bean = getObjectForBeanInstance(sharedInstance,name,beanName,mbd); }  

AbstractAutowireCapableBeanFactory#createBean(String,RootBeanDefinition,Object[])
// 返回bean实例 
> Object beanInstance = doCreateBean(beanName,mbdToUse,args); 

/** 
* 第2次调用后置处理器 
* 创建bean实例,并将实例放在包装类BeanWrapper中返回 
* 1. 通过工厂方法创建bean实例 
* 2. 通过构造方法自动注入创建bean实例 
* 3. 通过无参构造器创建bean实例 
*/ 
instanceWrapper = createBeanInstance(beanName,mbd,args); 
finalObjectbean = instanceWrapper.getWrappedInstance(); 

// 填充bean设置属性 
InstantiationAwareBeanPostProcessors 
// 第5次,第6次调用后置处理器   注入依赖 
populateBean(beanName,mbd,instanceWrapper); 

// 初始化bean 
exposedObject = initializeBean(beanName,exposedObject,mbd); 

// 返回类型判断FactoryBeanBeanFactroy 
bean = getObjectForBeanInstance(sharedInstance,name,beanName,mbd);> 
//涉及FactoryBean的判断,直接返回普通bean的条件类型是否是FactoryBean || name首字符是否是 & 
if(!(beanInstanceinstanceofFactoryBean)|| BeanFactoryUtils.isFactoryDereference(name){ 
	return beanInstance ; 
}