Spring 소스 코드 의 ContextLoaderListener 분석

우리 가 평소에 spring 프레임 워 크 개발 프로젝트 를 사용 할 때 설정 파일 웹. xml 에는 항상 이러한 설정 이 있 습 니 다. 예 를 들 어:

   contextConfigLocation
   
      classpath:config/spring-config.xml
      classpath:config/spring-cxf.xml    
   

   
      org.springframework.web.context.ContextLoaderListener
   

이 설정 들 은 도대체 어떤 역할 을 합 니까?우 리 는 소스 코드 의 측면 에서 분석 해 보 자.
1. 먼저 ContextLoaderListener 류 를 보고 ContextLoader 를 계승 하여 실현 합 니 다. ServletContextListener

public class ContextLoaderListener extends ContextLoader implements ServletContextListener

ContextLoaderListener 의 역할 은 웹 용 기 를 시작 할 때 contextConfigLocation 에서 정 의 된 xml 파일 을 읽 고 applicationContext 의 설정 정 보 를 자동 으로 설치 하 며 WebapplicationContext 대상 을 만 든 다음 에 이 대상 을 ServletContext 의 속성 에 배치 하 는 것 입 니 다. 그러면 우 리 는 Servlet 만 받 으 면 WebapplicationContext 대상 을 얻 을 수 있 습 니 다.이 대상 을 이용 하여 spring 용기 관리 bean 에 접근 합 니 다.  한 마디 로 하면 위의 이 설정 은 프로젝트 에 spring 지원 을 제공 하고 Ioc 용 기 를 초기 화 했 습 니 다.
ContextLoader 는 부모 클래스 로 지정 한 웹 프로그램 이 시 작 될 때 해당 하 는 Ioc 용 기 를 불 러 와 실제 웹 애플 리 케 이 션 Context, 즉 Ioc 용기 의 초기 화 작업 이 여기 서 완료 되 고 나중에 소스 코드 가 표 시 됩 니 다.
ServletContextListener 인터페이스 계승 EventListener

public interface ServletContextListener extends EventListener

ServletContextListener 는 ServletContext 의 감청 자 입 니 다. 인터페이스 에 있 는 방법 은 웹 용기 의 생명주기 와 결합 하여 호출 됩 니 다. ServletContext 에 어떤 변화 가 발생 하면 해당 하 는 사건 을 촉발 합 니 다. 웹 서버 가 시 작 될 때, ServletContext 가 생 성 될 때, 웹 서비스 가 닫 힐 때, ServletContext 가 소 각 될 때 등 은 해당 사건 을 촉발 하여 미리 설 계 된 해당 동작 을 합 니 다.예 를 들 어 이 중: 모니터 의 응답 동작 은 서버 가 시 작 될 때 contextInitialized 가 호출 되 고 닫 힐 때 contextDestroyed 가 호출 되 는 것 입 니 다.

/**
 * Initialize the root web application context.
             ，           
 */
@Override
public void contextInitialized(ServletContextEvent event) {
   initWebApplicationContext(event.getServletContext());//    
}

2. 입장 ContextLoader 클래스

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
  //  servletContext      spring context，     
   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!");
   }

   servletContext.log("Initializing Spring root WebApplicationContext");
   Log logger = LogFactory.getLog(ContextLoader.class);
   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) {
         //  WebApplicationContext         ConfigurableWebApplicationContext  
         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);
            }
            //  spring    ,    
            configureAndRefreshWebApplicationContext(cwac, servletContext);
         }
      }// web    servlet   
      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.isInfoEnabled()) {
         long elapsedTime = System.currentTimeMillis() - startTime;
         logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
      }

      return this.context;
   }
   catch (RuntimeException | Error ex) {
      logger.error("Context initialization failed", ex);
      servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
      throw ex;
   }
}

configure and Refresh 웹 애플 리 케 이 션 Context 방법 에 왔 습 니 다.

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
      //   web.xml      contextId     ，   
      String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
      if (idParam != null) {
         wac.setId(idParam);
      }
      else {
         // Generate default id...         id
         wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
               ObjectUtils.getDisplayString(sc.getContextPath()));
      }
   }

   wac.setServletContext(sc);//    servletContext   
   //   web.xml      contextConfiLocation        ，   
   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
   //              Servlet             
   ConfigurableEnvironment env = wac.getEnvironment();
   if (env instanceof ConfigurableWebEnvironment) {
      ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
   }
   ///   web.xml               
   customizeContext(sc, wac);
   wac.refresh();//WebApplicationContext    ,    ，         ，ctr+t   
}

3. 이 방법 에 들 어가 면 매우 익숙 합 니 다. 앞의 몇 편 은 상세 하 게 해석 되 었 고 spring 소스 코드 의 중점 방법 입 니 다. 여 기 는 소개 하지 않 겠 습 니 다.

public abstract class AbstractApplicationContext extends DefaultResourceLoader
      implements ConfigurableApplicationContext {

@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();
      }
   }
}

4. 이것 은 spring 의 용기 초기 화 입 니 다. 다음은 springMVC 용기 초기 화 를 소개 합 니 다.그들 둘 은 부자 용기 관계 다.기대 해 주세요!