public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
 this();
 register(componentClasses);
 refresh();
}
 
 
public AnnotationConfigApplicationContext() {
 this.reader = new AnnotatedBeanDefinitionReader(this);
 this.scanner = new ClassPathBeanDefinitionScanner(this);
}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
 BeanDefinitionRegistry registry, @Nullable Object source) {
 
 
 DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
 if (beanFactory != null) {
 if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
 beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
 }
 if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
 beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
 }
 }
 
 
 Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
 
 
 if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
 }
 
 
 if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
 }
 ...
}

DefaultListableBeanFactory.java類中
 
 
 public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
 ...
 this.beanDefinitionMap.put(beanName, beanDefinition);
 ...
 }

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
 void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry var1) throws BeansException;
}
 
 
@FunctionalInterface
public interface BeanFactoryPostProcessor {
 void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

@Repository
public class OrderDao {
 
 
 public void query() {
 System.out.println("OrderDao query...");
 }
}
public class OrderService {
 
 
 private OrderDao orderDao;
 
 
 public void setDao(OrderDao orderDao) {
 this.orderDao = orderDao;
 }
 
 
 public void init() {
 System.out.println("OrderService init...");
 }
 
 
 public void query() {
 orderDao.query();
 }
}
 
 
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
 
 
 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
 //向Spring容器中注冊OrderService
 BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(OrderService.class)
 //這里的屬性名是根據(jù)setter方法
 .addPropertyReference("dao", "orderDao")
 .setInitMethodName("init")
 .setScope(BeanDefinition.SCOPE_SINGLETON)
 .getBeanDefinition();
 
 
 registry.registerBeanDefinition("orderService", beanDefinition);
 
 
 }
 
 
 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 // 在這里修改orderService bean的scope為PROTOTYPE
 BeanDefinition beanDefinition = beanFactory.getBeanDefinition("orderService");
 beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
 }
}

private void loadBeanDefinitionsForConfigurationClass(
 ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
 
 
 if (trackedConditionEvaluator.shouldSkip(configClass)) {
 String beanName = configClass.getBeanName();
 if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
 this.registry.removeBeanDefinition(beanName);
 }
 this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
 return;
 }
 
 
 if (configClass.isImported()) {
 registerBeanDefinitionForImportedConfigurationClass(configClass);
 }
 for (BeanMethod beanMethod : configClass.getBeanMethods()) {
 loadBeanDefinitionsForBeanMethod(beanMethod);
 }
 
 
 loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
 loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

if (configClass.isImported()) {
 registerBeanDefinitionForImportedConfigurationClass(configClass);
 }

if (configClass.isImported()) {
 registerBeanDefinitionForImportedConfigurationClass(configClass);
 }

@Override
public void refresh() throws BeansException, IllegalStateException {
 synchronized (this.startupShutdownMonitor) {
 // Prepare this context for refreshing.
 prepareRefresh();
 
 
 // Tell the subclass to refresh the internal bean factory.
 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
 
 // Prepare the bean factory for use in this context.
 prepareBeanFactory(beanFactory);
 
 
 try {
 // Allows post-processing of the bean factory in context subclasses.
 postProcessBeanFactory(beanFactory);
 
 
 // Invoke factory processors registered as beans in the context.
 invokeBeanFactoryPostProcessors(beanFactory);
 
 
 // Register bean processors that intercept bean creation.
 registerBeanPostProcessors(beanFactory);
 
 
 // Initialize message source for this context.
 initMessageSource();
 
 
 // Initialize event multicaster for this context.
 initApplicationEventMulticaster();
 
 
 // Initialize other special beans in specific context subclasses.
 onRefresh();
 
 
 // Check for listener beans and register them.
 registerListeners();
 
 
 // Instantiate all remaining (non-lazy-init) singletons.
 finishBeanFactoryInitialization(beanFactory);
 
 
 // Last step: publish corresponding event.
 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 {
 // Reset common introspection caches in Spring's core, since we
 // might not ever need metadata for singleton beans anymore...
 resetCommonCaches();
 }
 }
}

 <!-- servlet定義：前端處理器，接受的HTTP請求和轉發(fā)請求的類 -->
 <servlet>
 <servlet-name>court</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <init-param>
  <!-- court-servlet.xml：定義WebAppliactionContext上下文中的bean -->
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath*:court-servlet.xml</param-value>
 </init-param>
 <load-on-startup>0</load-on-startup>
 </servlet>
 <servlet-mapping>
 <servlet-name>court</servlet-name>
 <url-pattern>/</url-pattern>
 </servlet-mapping>
 <!-- 配置contextConfigLocation初始化參數(shù)：指定Spring IoC容器需要讀取的定義了非web層的Bean（DAO/Service）的XML文件路徑 -->
 <context-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>/WEB-INF/court-service.xml</param-value>
 </context-param>
 <!-- 配置ContextLoaderListerner：Spring MVC在Web容器中的啟動類，負責Spring IoC容器在Web上下文中的初始化 -->
 <listener>
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>

public void contextInitialized(ServletContextEvent event) {
 this.initWebApplicationContext(event.getServletContext());
}
 
 
 
public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
 //PS : ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE=WebApplicationContext.class.getName() + ".ROOT" 根上下文的名稱
 //PS : 默認情況下，配置文件的位置和名稱是：DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml" 
 //在整個web應用中，只能有一個根上下文
 if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
  throw new IllegalStateException("Cannot initialize context because there is already a root application context present - " + "check whether you have multiple ContextLoader* definitions in your web.xml!");
 }
 
 Log logger = LogFactory.getLog(ContextLoader.class);
 servletContext.log("Initializing Spring root WebApplicationContext");
 if (logger.isInfoEnabled()) {
  logger.info("Root WebApplicationContext: initialization started");
 }
 long startTime = System.currentTimeMillis();
 
 try {
  // Store context in local instance variable, to guarantee that
  // it is available on ServletContext shutdown.
  if (this.context == null) {
  // 在這里執(zhí)行了創(chuàng)建WebApplicationContext的操作
  this.context = createWebApplicationContext(servletContext);
  }
  if (this.context instanceof ConfigurableWebApplicationContext) {
  ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
  if (!cwac.isActive()) {
   // The context has not yet been refreshed -> provide services such as
   // setting the parent context, setting the application context id, etc
   if (cwac.getParent() == null) {
   // The context instance was injected without an explicit parent ->
   // determine parent for root web application context, if any.
   ApplicationContext parent = loadParentContext(servletContext);
   cwac.setParent(parent);
   }
   configureAndRefreshWebApplicationContext(cwac, servletContext);
  }
  }
  // PS: 將根上下文放置在servletContext中
  servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
 
  ClassLoader ccl = Thread.currentThread().getContextClassLoader();
  if (ccl == ContextLoader.class.getClassLoader()) {
  currentContext = this.context;
  } else if (ccl != null) {
  currentContextPerThread.put(ccl, this.context);
  }
 
  if (logger.isDebugEnabled()) {
  logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
  }
  if (logger.isInfoEnabled()) {
  long elapsedTime = System.currentTimeMillis() - startTime;
  logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
  }
 
  return this.context;
 } catch (RuntimeException ex) {
  logger.error("Context initialization failed", ex);
  servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
  throw ex;
 } catch (Error err) {
  logger.error("Context initialization failed", err);
  servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
  throw err;
 }
 }
 
 

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
 if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
 // The application context id is still set to its original default value
 // -> assign a more useful id based on available information
 String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
 if (idParam != null) {
 wac.setId(idParam);
 }
 else {
 // Generate default id...
 wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
  ObjectUtils.getDisplayString(sc.getContextPath()));
 }
 }
 
 
 wac.setServletContext(sc);
 String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
 if (configLocationParam != null) {
 wac.setConfigLocation(configLocationParam);
 }
 
 
 // The wac environment's #initPropertySources will be called in any case when the context
 // is refreshed; do it eagerly here to ensure servlet property sources are in place for
 // use in any post-processing or initialization that occurs below prior to #refresh
 ConfigurableEnvironment env = wac.getEnvironment();
 if (env instanceof ConfigurableWebEnvironment) {
 ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
 }
 
 
 customizeContext(sc, wac);
 wac.refresh();
}

public final void refresh() throws BeansException, IllegalStateException {
 try {
 super.refresh();
 }
 catch (RuntimeException ex) {
 WebServer webServer = this.webServer;
 if (webServer != null) {
 webServer.stop();
 }
 throw ex;
 }
}

public static void main(String[] args) {
 SpringApplication.run(ConsulApplication.class, args);
 }

public ConfigurableApplicationContext run(String... args) {
 StopWatch stopWatch = new StopWatch();
 stopWatch.start();
 ConfigurableApplicationContext context = null;
 Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
 this.configureHeadlessProperty();
 SpringApplicationRunListeners listeners = this.getRunListeners(args);
 listeners.starting();
 
 
 Collection exceptionReporters;
 try {
  ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
  this.configureIgnoreBeanInfo(environment);
  Banner printedBanner = this.printBanner(environment);
  context = this.createApplicationContext();
  exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
  this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
  this.refreshContext(context);
  this.afterRefresh(context, applicationArguments);
  stopWatch.stop();
  if (this.logStartupInfo) {
  (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
  }
 
 
  listeners.started(context);
  this.callRunners(context, applicationArguments);
 } catch (Throwable var10) {
  this.handleRunFailure(context, var10, exceptionReporters, listeners);
  throw new IllegalStateException(var10);
 }
 
 
 try {
  listeners.running(context);
  return context;
 } catch (Throwable var9) {
  this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
  throw new IllegalStateException(var9);
 }
 }