Questions:

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class); 为我们做了什么？

看下列构造函数

i1:org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext

i2>org.springframework.context.support.GenericApplicationContext#GenericApplicationContext() 调用父类的构造方法
i3>org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext() 自己的构造方法

i3.1>org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader 为bean定义读取器赋值

i3.1.1>org.springframework.context.annotation.AnnotatedBeanDefinitionReader#getOrCreateEnvironment 创建环境
i3.2>org.springframework.context.annotation.ConditionEvaluator 创建一个条件计算器对象
i3.2.1>this.registry = registry; 初始条件计算器的bean定义注册器
i3.2.2> this.beanFactory = deduceBeanFactory(registry); 初始化bean工厂
i3.2.3>this.environment = (environment != null ? environment : deduceEnvironment(registry)); 为环境对象赋值
i3.2.4> this.resourceLoader = (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry)); 为资源加载器赋值
i3.3> AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);为容器中注册系统的bean定义信息
i4>: this.scanner = new ClassPathBeanDefinitionScanner(this); 创建类路径下的bean定义扫描器
i4.1>: org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#registerDefaultFilters注册包扫描默认的规则
i4.2>:org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#setEnvironment 设置环境
i4.3>org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#setResourceLoader 设置资源加载器
i5>org.springframework.context.annotation.AnnotatedBeanDefinitionReader#register 使用i3.1步生成的bean定义读取器注册配置类

详细源码解析:

i1:org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext

创建IOC容器对象

  1. //创建
  2. public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
  3.     //调用无参的构造器，会调用父类的无参构造器
  4.     this();
  5.     //注册配置类
  6.     register(annotatedClasses);
  7.     //容器刷新
  8.     refresh();
  9. }

i2>org.springframework.context.support.GenericApplicationContext#GenericApplicationContext()

调用父类的构造方法 生成一个IOC容器

  1. public GenericApplicationContext() {
  2.     //创建IOC容器
  3.     this.beanFactory = new DefaultListableBeanFactory();
  4. }

i3>org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext()

自己的构造方法

  1. public AnnotationConfigApplicationContext() {
  2.     //为IOC容器赋值 AnnotatedBeanDefinitionReader（注解的Bean定义读取器）
  3.     this.reader = new AnnotatedBeanDefinitionReader(this);
  4.     //为IOC容器赋值   类路径下的bean定义扫描器
  5.     this.scanner = new ClassPathBeanDefinitionScanner(this);
  6. }

i3.1>org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader

为bean定义读取器赋值

  1. public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
  2.     this(registry, getOrCreateEnvironment(registry));
  3. }

i3.1.1>org.springframework.context.annotation.AnnotatedBeanDefinitionReader#getOrCreateEnvironment

创建环境

  1. private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
  2.     Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  3.     if (registry instanceof EnvironmentCapable) {
  4.         return ((EnvironmentCapable) registry).getEnvironment();
  5.     }
  6.     return new StandardEnvironment();
  7. }

i3.2>org.springframework.context.annotation.ConditionEvaluator

创建一个条件计算器对象

  1. public ConditionContextImpl(BeanDefinitionRegistry registry, 
  2.                             Environment environment, ResourceLoader resourceLoader) {
  3.     this.registry = registry;
  4.     this.beanFactory = deduceBeanFactory(registry);
  5.     this.environment = (environment != null ? environment : deduceEnvironment(registry));
  6.     this.resourceLoader = 
  7.         (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry));
  8. }

i3.3> AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

为容器中注册系统的bean定义信息

  1. public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
  2.     BeanDefinitionRegistry registry, Object source) {
  4.     //获取一个IOC容器
  5.     DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
  6.     if (beanFactory != null) {
  7.         if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
  8.             beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
  9.         }
  11.         if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
  12.             beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  13.         }
  14.     }
  16.     Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(8);
  18.     //注册一个配置类解析器的bean定义（ConfigurationClassPostProcessor）
  19.     if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  20.         RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
  21.         def.setSource(source);
  22.         beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
  23.     }
  25.     //设置AutoWired注解解析器的bean定义信息
  26.     if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  27.         RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
  28.         def.setSource(source);
  29.         beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
  30.     }
  32.     注册解析@Required 注解的处理器
  33.         if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  34.             RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
  35.             def.setSource(source);
  36.             beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
  37.         }
  39.     //检查是否支持JSR250规范，如何支持注册 解析JSR250规范的注解
  40.     // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
  41.     if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  42.         RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
  43.         def.setSource(source);
  44.         beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
  45.     }
  47.     //检查是否支持jpa，若支持注册解析jpa规范的注解
  48.     // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
  49.     if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  50.         RootBeanDefinition def = new RootBeanDefinition();
  51.         try {
  52.             def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
  53.                                                 AnnotationConfigUtils.class.getClassLoader()));
  54.         }
  55.         catch (ClassNotFoundException ex) {
  56.             throw new IllegalStateException(
  57.                 "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
  58.         }
  59.         def.setSource(source);
  60.         beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
  61.     }
  63.     //注册解析@EventListener的注解
  64.     if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
  65.         RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  66.         def.setSource(source);
  67.         beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
  68.     }
  70.     if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
  71.         RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  72.         def.setSource(source);
  73.         beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
  74.     }
  76.     return beanDefs;
  77. }

i4>: this.scanner = new ClassPathBeanDefinitionScanner(this);

创建类路径下的bean定义扫描器

  1. public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, 
  2.     boolean useDefaultFilters, Environment environment, ResourceLoader resourceLoader) {
  3.     Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  4.     this.registry = registry;
  6.     //使用默认的扫描规则
  7.     if (useDefaultFilters) {
  8.         registerDefaultFilters();
  9.     }
  10.     //设置环境
  11.     setEnvironment(environment);
  12.     //设置资源加载器
  13.     setResourceLoader(resourceLoader);
  14. }

i4.1>: org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#registerDefaultFilters

注册包扫描默认的规则 

  1. protected void registerDefaultFilters() {
  2.     //可以谢谢@Compent  @Service @Repository @Controller @Aspectj
  3.     this.includeFilters.add(new AnnotationTypeFilter(Component.class));
  4.     ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
  5.     try {
  6.         //jsr250规范的组件
  7.         this.includeFilters.add(new AnnotationTypeFilter(
  8.             ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
  9.         logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
  10.     }
  11.     catch (ClassNotFoundException ex) {
  12.         // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
  13.     }
  14.     try {
  15.         //可以支持jsr330的注解
  16.         this.includeFilters.add(new AnnotationTypeFilter(
  17.             ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
  18.         logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
  19.     }
  20.     catch (ClassNotFoundException ex) {
  21.         // JSR-330 API not available - simply skip.
  22.     }
  23. }

i5>org.springframework.context.annotation.AnnotatedBeanDefinitionReader#register

使用i3.1步生成的bean定义读取器注册配置类

  1. public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
  2.     AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
  3.     if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
  4.         return;
  5.     }
  7.     ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
  8.     abd.setScope(scopeMetadata.getScopeName());
  9.     String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
  10.     AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
  11.     if (qualifiers != null) {
  12.         for (Class<? extends Annotation> qualifier : qualifiers) {
  13.             if (Primary.class == qualifier) {
  14.                 abd.setPrimary(true);
  15.             }
  16.             else if (Lazy.class == qualifier) {
  17.                 abd.setLazyInit(true);
  18.             }
  19.             else {
  20.                 abd.addQualifier(new AutowireCandidateQualifier(qualifier));
  21.             }
  22.         }
  23.     }
  24.     //注册自己传入的主配置类bean定义到容器中
  25.     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  26.     definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  27.     BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
  28. }