AnnotationConfigApplicationContext初始化过程

实例化的方式：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
   this(); //详解 1    
   register(annotatedClasses); //详解 2
   refresh(); //详见Spring容器启动流程
}

详解 1

public AnnotationConfigApplicationContext() {
   this.reader = new AnnotatedBeanDefinitionReader(this); //详解1.1
   this.scanner = new ClassPathBeanDefinitionScanner(this);//详解1.2
}

详解1.1

protected AnnotatedBeanDefinitionReader getAnnotatedBeanDefinitionReader(DefaultListableBeanFactory beanFactory) {
   return new AnnotatedBeanDefinitionReader(beanFactory, getEnvironment());
}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
   this(registry, getOrCreateEnvironment(registry));
}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   Assert.notNull(environment, "Environment must not be null");
   this.registry = registry;
   //完成条件注解的判断condition
   this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    //初始化了关于注解相关的处理器internalConfigurationAnnotationProcessor（对@Configuration、@Import、@Bean等注解的支持）、internalAutowiredAnnotationProcessor（@Value和@Autowired的处理）、internalCommonAnnotationProcessor（支持JSR-250的一些注解：@Resource、@PostConstruct、@PreDestroy等)、PersistenceAnnotationBeanPostProcessor（对JPA的支持）
        // 下面两个类，是Spring4.2之后加入进来的，为了更好的使用Spring的事件而提供支持
        // 支持了@EventListener注解，我们可以通过此注解更方便的监听事件了（Spring4.2之后）
        // 具体这个Processor和ListenerFactory怎么起作用的详见 对应处理器相关分析
internalEventListenerProcessor、internalEventListenerFactory。

   AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

详解1.2

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
   this(registry, true);
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
   this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
      Environment environment) {
   this(registry, useDefaultFilters, environment,
         (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
      Environment environment, @Nullable ResourceLoader resourceLoader) {
   this.registry = registry;
   if (useDefaultFilters) {
      //设置为ture，则会执行，指定扫描指定的Filter。
      registerDefaultFilters();
   }
   setEnvironment(environment);
   setResourceLoader(resourceLoader);
}

@SuppressWarnings("unchecked")
protected void registerDefaultFilters() {
    //指定扫描@Component注解的Filter，对于@Service和@Controller等下面都包含@Component注解。
   this.includeFilters.add(new AnnotationTypeFilter(Component.class));
   ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
   try {
    //指定扫描@ManagedBean注解的Filter
      this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
      logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
   }
   catch (ClassNotFoundException ex) {
      // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
   }
   try {
    //指定扫描@Named注解的Filter
      this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
      logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
   }
   catch (ClassNotFoundException ex) {
      // JSR-330 API not available - simply skip.
   }
}

扩展：

    如果你想Spring连你自定义的注解都扫描，自己实现一个AnnotationTypeFilter就可以。在容器的处理器中对此Filter进行应用。

 或者在@ComponentScan中可以指定Filter

详解2

public void register(Class<?>... annotatedClasses) {
   Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
   this.reader.register(annotatedClasses);
}
public void register(Class<?>... annotatedClasses) {
   for (Class<?> annotatedClass : annotatedClasses) {
      registerBean(annotatedClass);
   }
}

public void registerBean(Class<?> annotatedClass) {
   doRegisterBean(annotatedClass, null, null, null);
}

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
      @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    //必须有@Configuration修饰。然后解析一些Condition注解，看是否排除
   if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
      return;
   }
   abd.setInstanceSupplier(instanceSupplier);
    // 解析Scope也就是作用域
   ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
   abd.setScope(scopeMetadata.getScopeName());
   String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    // 设定一些注解默认值，对@Lazy、@DependsOn、@Role、@Description 处理
   AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);//详见下边
   if (qualifiers != null) {
    // 解析传入的qualifiers，若有此注解 则primary都成为true了。 
      for (Class<? extends Annotation> qualifier : qualifiers) {
         if (Primary.class == qualifier) {
            abd.setPrimary(true);
         }
         else if (Lazy.class == qualifier) {
            abd.setLazyInit(true);
         }
         else {
            abd.addQualifier(new AutowireCandidateQualifier(qualifier));
         }
      }
   }
// 自定义定制信息(一般都不需要)
   for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
      customizer.customize(abd);
   }
// 下面位解析Scope是否需要代理，最后把这个Bean注册进去
   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
   processCommonDefinitionAnnotations(abd, abd.getMetadata());
}

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
   AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
   if (lazy != null) {
      abd.setLazyInit(lazy.getBoolean("value"));
   }
   else if (abd.getMetadata() != metadata) {
      lazy = attributesFor(abd.getMetadata(), Lazy.class);
      if (lazy != null) {
         abd.setLazyInit(lazy.getBoolean("value"));
      }
   }

   if (metadata.isAnnotated(Primary.class.getName())) {
      abd.setPrimary(true);
   }
   AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
   if (dependsOn != null) {
      abd.setDependsOn(dependsOn.getStringArray("value"));
   }


   AnnotationAttributes role = attributesFor(metadata, Role.class);
   if (role != null) {
      abd.setRole(role.getNumber("value").intValue());
   }
   AnnotationAttributes description = attributesFor(metadata, Description.class);
   if (description != null) {
      abd.setDescription(description.getString("value"));
   }
}