/*

  * Copyright 2002-2015 the original author or authors.

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.springframework.web.context;

 import javax.servlet.ServletContextEvent;

 import javax.servlet.ServletContextListener;

 /**

  * Bootstrap listener to start up and shut down Spring's root {@link WebApplicationContext}.

  * Simply delegates to {@link ContextLoader} as well as to {@link ContextCleanupListener}.

  *

  * <p>This listener should be registered after {@link org.springframework.web.util.Log4jConfigListener}

  * in {@code web.xml}, if the latter is used.

  *

  * <p>As of Spring 3.1, {@code ContextLoaderListener} supports injecting the root web

  * application context via the {@link #ContextLoaderListener(WebApplicationContext)}

  * constructor, allowing for programmatic configuration in Servlet 3.0+ environments.

  * See {@link org.springframework.web.WebApplicationInitializer} for usage examples.

  *

  * @author Juergen Hoeller

  * @author Chris Beams

  * @since 17.02.2003

  * @see org.springframework.web.WebApplicationInitializer

  * @see org.springframework.web.util.Log4jConfigListener

  */

 public class ContextLoaderListener extends ContextLoader implements ServletContextListener {

     /**

      * Create a new {@code ContextLoaderListener} that will create a web application

      * context based on the "contextClass" and "contextConfigLocation" servlet

      * context-params. See {@link ContextLoader} superclass documentation for details on

      * default values for each.

      * <p>This constructor is typically used when declaring {@code ContextLoaderListener}

      * as a {@code <listener>} within {@code web.xml}, where a no-arg constructor is

      * required.

      * <p>The created application context will be registered into the ServletContext under

      * the attribute name {@link WebApplicationContext#ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE}

      * and the Spring application context will be closed when the {@link #contextDestroyed}

      * lifecycle method is invoked on this listener.

      * @see ContextLoader

      * @see #ContextLoaderListener(WebApplicationContext)

      * @see #contextInitialized(ServletContextEvent)

      * @see #contextDestroyed(ServletContextEvent)

      */

     public ContextLoaderListener() {

     }

     /**

      * Create a new {@code ContextLoaderListener} with the given application context. This

      * constructor is useful in Servlet 3.0+ environments where instance-based

      * registration of listeners is possible through the {@link javax.servlet.ServletContext#addListener}

      * API.

      * <p>The context may or may not yet be {@linkplain

      * org.springframework.context.ConfigurableApplicationContext#refresh() refreshed}. If it

      * (a) is an implementation of {@link ConfigurableWebApplicationContext} and

      * (b) has <strong>not</strong> already been refreshed (the recommended approach),

      * then the following will occur:

      * <ul>

      * <li>If the given context has not already been assigned an {@linkplain

      * org.springframework.context.ConfigurableApplicationContext#setId id}, one will be assigned to it</li>

      * <li>{@code ServletContext} and {@code ServletConfig} objects will be delegated to

      * the application context</li>

      * <li>{@link #customizeContext} will be called</li>

      * <li>Any {@link org.springframework.context.ApplicationContextInitializer ApplicationContextInitializer}s

      * specified through the "contextInitializerClasses" init-param will be applied.</li>

      * <li>{@link org.springframework.context.ConfigurableApplicationContext#refresh refresh()} will be called</li>

      * </ul>

      * If the context has already been refreshed or does not implement

      * {@code ConfigurableWebApplicationContext}, none of the above will occur under the

      * assumption that the user has performed these actions (or not) per his or her

      * specific needs.

      * <p>See {@link org.springframework.web.WebApplicationInitializer} for usage examples.

      * <p>In any case, the given application context will be registered into the

      * ServletContext under the attribute name {@link

      * WebApplicationContext#ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE} and the Spring

      * application context will be closed when the {@link #contextDestroyed} lifecycle

      * method is invoked on this listener.

      * @param context the application context to manage

      * @see #contextInitialized(ServletContextEvent)

      * @see #contextDestroyed(ServletContextEvent)

      */

     public ContextLoaderListener(WebApplicationContext context) {

         super(context);

     }

     /**

      * Initialize the root web application context.

      */

     @Override

     public void contextInitialized(ServletContextEvent event) {

         initWebApplicationContext(event.getServletContext());

     }

     /**

      * Close the root web application context.

      */

     @Override

     public void contextDestroyed(ServletContextEvent event) {

         closeWebApplicationContext(event.getServletContext());

         ContextCleanupListener.cleanupAttributes(event.getServletContext());

     }

 }

     /**

      * Customize the {@link ConfigurableWebApplicationContext} created by this

      * ContextLoader after config locations have been supplied to the context

      * but before the context is <em>refreshed</em>.

      * <p>The default implementation {@linkplain #determineContextInitializerClasses(ServletContext)

      * determines} what (if any) context initializer classes have been specified through

      * {@linkplain #CONTEXT_INITIALIZER_CLASSES_PARAM context init parameters} and

      * {@linkplain ApplicationContextInitializer#initialize invokes each} with the

      * given web application context.

      * <p>Any {@code ApplicationContextInitializers} implementing

      * {@link org.springframework.core.Ordered Ordered} or marked with @{@link

      * org.springframework.core.annotation.Order Order} will be sorted appropriately.

      *

      * @param sc  the current servlet context

      * @param wac the newly created application context

      * @see #CONTEXT_INITIALIZER_CLASSES_PARAM

      * @see ApplicationContextInitializer#initialize(ConfigurableApplicationContext)

      */

     protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {

         // 找到 web.xml里配置的 globalInitializerClasses 和 contextInitializerClasses 对应的class

         List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =

                 determineContextInitializerClasses(sc);

         // 一般情况下没人配置,所以是empty.

         if (initializerClasses.isEmpty()) {

             // no ApplicationContextInitializers have been declared -> nothing to do

             return;

         }

         // 如果这些ApplicationContextInitializer存在的话就调用他们的initialize方法.

         ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerInstances =

                 new ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>>();

         for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {

             Class<?> initializerContextClass =

                     GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);

             if (initializerContextClass != null) {

                 Assert.isAssignable(initializerContextClass, wac.getClass(), String.format(

                         "Could not add context initializer [%s] since its generic parameter [%s] " +

                                 "is not assignable from the type of application context used by this " +

                                 "context loader [%s]: ", initializerClass.getName(), initializerContextClass.getName(),

                         wac.getClass().getName()));

             }

             initializerInstances.add(BeanUtils.instantiateClass(initializerClass));

         }

         AnnotationAwareOrderComparator.sort(initializerInstances);

         for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : initializerInstances) {

             initializer.initialize(wac);

         }

     }