ApplicationContext相关接口架构分析

public interface WebApplicationContext extends ApplicationContext {
    ServletContext getServletContext();
}

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
 // 为 ApplicationContext 设置唯一 ID
 void setId(String id);

 // 为 ApplicationContext 设置 parent
 // 父类不应该被修改：如果创建的对象不可用时，则应该在构造函数外部设置它
 void setParent(@Nullable ApplicationContext parent);

 // 设置 Environment
 void setEnvironment(ConfigurableEnvironment environment);

 // 获取 Environment
 @Override
 ConfigurableEnvironment getEnvironment();

 // 添加 BeanFactoryPostProcessor
 void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);

 // 添加 ApplicationListener
 void addApplicationListener(ApplicationListener<?> listener);

 // 添加 ProtocolResolver
 void addProtocolResolver(ProtocolResolver resolver);

 // 加载或者刷新配置
 // 这是一个非常重要的方法
 void refresh() throws BeansException, IllegalStateException;

 // 注册 shutdown hook
 void registerShutdownHook();

 // 关闭 ApplicationContext
 @Override
 void close();

 // ApplicationContext 是否处于激活状态
 boolean isActive();

 // 获取当前上下文的 BeanFactory
 ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
}

public interface ConfigurableWebApplicationContext extends WebApplicationContext, ConfigurableApplicationContext {
 void setServletContext(@Nullable ServletContext servletContext);

 void setServletConfig(@Nullable ServletConfig servletConfig);

 ServletConfig getServletConfig();

 void setNamespace(@Nullable String namespace);

 String getNamespace();

 void setConfigLocation(String configLocation);

 void setConfigLocations(String... configLocations);

 String[] getConfigLocations();
}

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
StudentService studentService = (StudentService)ac.getBean("studentService");

org.springframework.context.support.AbstractApplicationContext
      org.springframework.context.support.AbstractRefreshableApplicationContext
            org.springframework.context.support.AbstractRefreshableConfigApplicationContext
                  org.springframework.context.support.AbstractXmlApplicationContext
                        org.springframework.context.support.ClassPathXmlApplicationContext

private MessageSource messageSource;

// 实现 getMessage()
public String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale) {
   // 委托给 messageSource 实现
 return getMessageSource().getMessage(code, args, defaultMessage, locale);
}

private MessageSource getMessageSource() throws IllegalStateException {
 if (this.messageSource == null) {
  throw new IllegalStateException("MessageSource not initialized - " +
    "call 'refresh' before accessing messages via the context: " + this);
 }
 return this.messageSource;
}

public final String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale) {
 String msg = getMessageInternal(code, args, locale);
 if (msg != null) {
  return msg;
 }
 if (defaultMessage == null) {
  return getDefaultMessage(code);
 }
 return renderDefaultMessage(defaultMessage, args, locale);
}

@Override
public void publishEvent(Object event) {
  publishEvent(event, null);
}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
  Assert.notNull(event, "Event must not be null");
  if (logger.isTraceEnabled()) {
    logger.trace("Publishing event in " + getDisplayName() + ": " + event);
  }

  ApplicationEvent applicationEvent;
  if (event instanceof ApplicationEvent) {
    applicationEvent = (ApplicationEvent) event;
  }
  else {
    applicationEvent = new PayloadApplicationEvent<>(this, event);
    if (eventType == null) {
      eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
    }
  }

  if (this.earlyApplicationEvents != null) {
    this.earlyApplicationEvents.add(applicationEvent);
  }
  else {
    getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
  }

  if (this.parent != null) {
    if (this.parent instanceof AbstractApplicationContext) {
      ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
    }
    else {
      this.parent.publishEvent(event);
    }
  }
}

public Resource[] getResources(String locationPattern) throws IOException {
 return this.resourcePatternResolver.getResources(locationPattern);
}

public ConfigurableEnvironment getEnvironment() {
 if (this.environment == null) {
  this.environment = createEnvironment();
 }
 return this.environment;
}

protected ConfigurableEnvironment createEnvironment() {
 return new StandardEnvironment();
}

@Override
public void start() {
  getLifecycleProcessor().start();
  publishEvent(new ContextStartedEvent(this));
}

@Override
public void stop() {
  getLifecycleProcessor().stop();
  publishEvent(new ContextStoppedEvent(this));
}

@Override
public boolean isRunning() {
  return (this.lifecycleProcessor != null && this.lifecycleProcessor.isRunning());
}

public void close() {
  synchronized (this.startupShutdownMonitor) {
    doClose();
    // If we registered a JVM shutdown hook, we don't need it anymore now:
    // We've already explicitly closed the context.
    if (this.shutdownHook != null) {
      try {
        Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
      }
      catch (IllegalStateException ex) {
        // ignore - VM is already shutting down
      }
    }
  }
}

protected void doClose() {
  // 省略部分代码
  try {
    // Publish shutdown event.
    publishEvent(new ContextClosedEvent(this));
  }
  catch (Throwable ex) {
    logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
  }

  // 省略部分代码
  destroyBeans();
  closeBeanFactory();
  onClose();

  this.active.set(false);
}
}

public void afterPropertiesSet() {
  if (!isActive()) {
    refresh();
  }
}

public void setBeanName(String name) {
  if (!this.setIdCalled) {
    super.setId(name);
    setDisplayName("ApplicationContext '" + name + "'");
  }
}