IOC的核心就是代码入口就在AbstractApplictionContext
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 在刷新容器前进行一些准备工作，例如设置容器的激活状态，校验容器环境所必须的启动参数
prepareRefresh();
// 刷新内部的BeanFactory，获得一个新鲜的BeanFactory，这里面主要是读取XML文件，将其转换为BeanDefinition
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 对BeanFactory进行进一步的完善，包括注册应用上下文感知以及监听器感知的BeanPostProcessor，
// 先注册一些系统的环境Bean
prepareBeanFactory(beanFactory);
try {
// 给子类在初始化BeanFactory重写修改变动beanFactory的权利
postProcessBeanFactory(beanFactory);
// 调用BeanFactoryPostProcessor，可以修改beanFactory，与上面不同的是，这里是类似插件的形式，耦合度更低
invokeBeanFactoryPostProcessors(beanFactory);
// 提前注册BeanPostProcessor，用于后期提供代理等功能
registerBeanPostProcessors(beanFactory);
// 初始化消息源，用于国际化
initMessageSource();
// 初始化应用事件广播器，用于广播应用上下文事件
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// 为应用事件广播器初始化监听器(ApplicationListener)
registerListeners();
// 实例化并注册所有非懒加载的bean
finishBeanFactoryInitialization(beanFactory);
// 刷新容器后的额外工作，初始化生命周期执行器，发布容器刷新完毕的应用上下文事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// 清除掉不再需要的缓存，节省空间
resetCommonCaches();
}
}
}---分析一下上面代码中的invokeBeanFactoryPostProcessors(beanFactory)源码---开始
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 调用所有的BeanFactoryPostProcessors
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}我们知道BeanFactoryPostProcessor可以对已经生成好的BeanDefinition进行修改，也可以动态的添加来自第三方的BeanDefinition。比如我们熟知的Mybatis中的Mapper对象。如果我们使用Spring-Mybatis包中的注解@MapperScan则可以将我们定义的mapper对象加入到Spring容器中,便于我们在项目中注入到指定的地方。
@MapperScan("com.demo")
@Configuration
public class Configuration(){
}
@Service
public class Service{
@Autowired
private DemoMapper demoMapper;
}public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {
// 存放所有已经调用过的BeanFactoryPostProcessor，避免重复执行
Set processedBeans = new HashSet();
// Spring默认使用的BeanFactory是DefaultListableBeanFactory，其已经实现了BeanDefinitionRegistry接口
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 用于存放普通的BeanFactoryPostProcessor
List regularPostProcessors = new LinkedList();
// 用于存放BeanDefinitionRegistryPostProcessor
List registryPostProcessors =
new LinkedList();
/* 执行我们自定义的beanFactoryPostProcessor，Spring提供customizeContext()方法给予我们定制化构建
ApplicationContext的机会，所以在这个方法中我们可以动态的添加自定义的BeanFactoryPostProcessor。
这里将普通的BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor区分开分别执行。
*/
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryPostProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
registryPostProcessors.add(registryPostProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 调用实现了PriorityOrdered接口的BeanFactoryPostProcessor
List priorityOrderedPostProcessors = new ArrayList();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 按照权重排序
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
registryPostProcessors.addAll(priorityOrderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
// 调用实现了 Ordered接口的，步骤跟上面一样.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
List orderedPostProcessors = new ArrayList();
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(beanFactory, orderedPostProcessors);
registryPostProcessors.addAll(orderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
// 最后调用其它的BeanFactoryPostProcessor
// 如果有BeanDefinitionRegistryPostProcessor被执行, 则有可能会产生新的BeanDefinitionRegistryPostProcessor,因此这边将reiterate赋值为true, 代表需要再循环查找一次
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
registryPostProcessors.add(pp);
processedBeans.add(ppName);
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
}
}
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
/* 上面是通过customizeContext来动态添加BeanPostProcessor，而从这里的代码我们可以看出，只要我们写好一个
BeanFactoryPostProcessor，使用任意方法将其加入到Spring容器中，Spring也可以解析后执行。这里足以看出Spring强大的兼容性*/
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
List priorityOrderedPostProcessors = new ArrayList();
List orderedPostProcessorNames = new ArrayList();
List nonOrderedPostProcessorNames = new ArrayList();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// 跳过已经执行过的
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
List orderedPostProcessors = new ArrayList();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(beanFactory, orderedPostProcessors);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
List nonOrderedPostProcessors = new ArrayList();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 清空Bean工厂的元数据缓存，因为在BeanFactoryPostProcessor中可能已经更改了BeanDefinition，所以这里需要清空
beanFactory.clearMetadataCache();
} 这个方法比较长，我个人觉得spring应当将其拆分成一个个小的方法，使结构更加清晰。
BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，它提供了动态注册Bean的能力。
我们最常使用的是它的实现类ConfigurationClassPostProcessor，其带有一个Bean定义读取器。这个读取器可
以读取@Configuration、@Import、@ImportResource注解标注下的所有Bean定义，并最终添加到Spring的BeanFactory中。
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
***
private ConfigurationClassBeanDefinitionReader reader;
***
}无论是在普通的Spring项目亦或是SpringBoot项目，只要我们开启了对注解配置的支持，那么系统就会自动注册ConfigurationClassPostProcessor
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
/**
* 获取所有的配置定义，注意：此时系统中没有任何我们自定义的@Configuration配置定义。
* 但如果是SpringBoot项目，系统默认会将启动类SpringBootApplication加入到系统配置定义中去。
*/
Set configCandidates = new LinkedHashSet();
for (String beanName : registry.getBeanDefinitionNames()) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 如果配置类为空，立即返回
if (configCandidates.isEmpty()) {
return;
}
// 这里初始化一些生成器
SingletonBeanRegistry singletonRegistry = null;
if (registry instanceof SingletonBeanRegistry) {
singletonRegistry = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet && singletonRegistry.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {
BeanNameGenerator generator = (BeanNameGenerator) singletonRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
// 递归解析每一个@Configuration配置类
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parser.parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
parser.parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("Failed to load bean class: " + bd.getBeanClassName(), ex);
}
}
/**
* 校验解析出的所有@Configuration配置类，例如如果是@Configuration注解标注的full配置类，那么类不能被声明为final，否则报错。因为Spring会为
* 每一个@Configuration配置类创建一个CGLIB代理，我们知道CGLIB是通过继承关系来实现代理的，既然用到继承，其父类肯定不能为final。
*/
parser.validate();
// 处理@PropertySource注解的配置类
Stack> parsedPropertySources = parser.getPropertySources();
if (!parsedPropertySources.isEmpty()) {
if (!(this.environment instanceof ConfigurableEnvironment)) {
logger.warn("Ignoring @PropertySource annotations. " +
"Reason: Environment must implement ConfigurableEnvironment");
}
else {
MutablePropertySources envPropertySources = ((ConfigurableEnvironment)this.environment).getPropertySources();
while (!parsedPropertySources.isEmpty()) {
envPropertySources.addLast(parsedPropertySources.pop());
}
}
}
/* 读取每一个@Configuration配置类中定义的bean，加入到ioc容器中。包括使用@Bean注解标注的方法，@Import导入的registry注册器，
* @ImportResource导入的xml资源
*/
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.problemReporter, this.metadataReaderFactory,
this.resourceLoader, this.environment, this.importBeanNameGenerator);
}
this.reader.loadBeanDefinitions(parser.getConfigurationClasses());
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (singletonRegistry != null) {
if (!singletonRegistry.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
singletonRegistry.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
}
} ---分析一下上面代码中的invokeBeanFactoryPostProcessors(beanFactory)源码---结束
未完待续。。。