注解方式启动spring时源码查找其IOC的容器

程序入口 

public class App {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);

        String[] names = annotationConfigApplicationContext.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        A a = annotationConfigApplicationContext.getBean("a", A.class);
        System.out.println(a);
    }

}

进入AnnotationConfigApplicationContext的构造 

	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        // 无参构造
		this();
        // 将配置类注入IOC并将其配置信息加载至内存
		register(annotatedClasses);
        // 容器初始化和加载的操作
		refresh();
	}

	public AnnotationConfigApplicationContext() {
        // XML方式启动的解析器
		this.reader = new AnnotatedBeanDefinitionReader(this);
        // 注解方式启动的解析器
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}


    AnnotationConfigApplicationContext的父类是GenericApplicationContext，其无参构造为
    public GenericApplicationContext() {
        // 创建bean工厂，此工厂类也实现了beanDefinitionRegistry接口
		this.beanFactory = new DefaultListableBeanFactory();
	}

    所以AnnotationConfigApplicationContext的beanFactory为DefaultListableBeanFactory

refresh

@Override
public void refresh() throws BeansException, IllegalStateException {
    ***
    // 在上下文中使用beanFactory进行处理器的注册
    invokeBeanFactoryPostProcessors(beanFactory);
    ****
}

invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 注册操作 
 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,getBeanFactoryPostProcessors());
    ****
}

 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    ****
    invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
    ****
}

invokeBeanDefinitionRegistryPostProcessors

private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
    for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
        // 进行注册
        postProcessor.postProcessBeanDefinitionRegistry(registry);
    }
}

postProcessBeanDefinitionRegistry 

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    *****
	processConfigBeanDefinitions(registry);
}

processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
	*****
	// 解析配置对应的bean将其进行注册
	parser.parse(candidates);
	*****
}

parse(Set<BeanDefinitionHolder> configCandidates)

public void parse(Set<BeanDefinitionHolder> configCandidates) {
	******
	parse(bd.getBeanClassName(), holder.getBeanName());
	*****
}

parse(@Nullable String className, String beanName)

protected final void parse(@Nullable String className, String beanName) throws IOException {
	******
	processConfigurationClass(new ConfigurationClass(reader, beanName));
}

processConfigurationClass

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
	*****
	sourceClass = doProcessConfigurationClass(configClass, sourceClass);
	*****
}

doProcessConfigurationClass

@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
		throws IOException {
	******
	// 注解方式启动时，componentScan解析其扫包范围内的类，将其进行注册
	Set<BeanDefinitionHolder> scannedBeanDefinitions =
			this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
	******		
}

Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass)

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
	******
	return scanner.doScan(StringUtils.toStringArray(basePackages));
}

doScan 

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	******
	// 将这些包下面的类封装为beanDefinitionHolder，进行注册
	registerBeanDefinition(definitionHolder, this.registry);
	******
}

registerBeanDefinition

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}

 BeanDefinitionReaderUtils.registerBeanDefinition

public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {
	******
    // 此处的registry为文章开头，context父类的无参构造初始化的DefaultListableBeanFactory
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
	******
}

 registerBeanDefinition 

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
		throws BeanDefinitionStoreException {

	******
	BeanDefinition oldBeanDefinition;
	// 通过beanName从IOC容器中获取bean的信息
	oldBeanDefinition = this.beanDefinitionMap.get(beanName);
	******
	// 将bean对应的beanDefinition以键值对的方式放入容器
	this.beanDefinitionMap.put(beanName, beanDefinition);
	******
}

 beanDefinitionMap

// 为IOC容器存放bean信息的集合，可以看出它确实是线程安全的
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

 注意

本文是以注解放肆启动的spring，所以其IOC容器在DefaultListableBeanFactory类中。
不同的启动方式，其实现也不相同，对应的IOC容器也不同。所以，切莫以为spring的容器就在此处。
（PS:有些文章会记录IOC在某个类的第xxx行，这样其实是不准确的）