`
kavy
  • 浏览: 891853 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Spring MVC中的IoC容器初始化

    博客分类：
  • web
 
阅读更多

 Spring Framework本身没有Web功能，Spring MVC使用WebApplicationContext类扩展ApplicationContext，使得拥有web功能。那么，Spring MVC是如何在web环境中创建IoC容器呢？web环境中的IoC容器的结构又是什么结构呢？web环境中，spring IoC容器是怎么启动呢？

      先看一下WebApplicationContext是如何扩展ApplicationContext来添加对Web环境的支持的。WebApplicationContext接口定义如下：

 

[java] view plaincopyprint?
  1. public interface WebApplicationContext extends ApplicationContext {  
  2.     //根上下文在ServletContext中的名称  
  3.         String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";  
  4.         //取得web容器的ServletContext  
  5.     ServletContext getServletContext();  
  6. }  

 

      对于web容器中创建IoC容器的过程，我们从web.xml配置文件讲起。看一下Spring MVC的web.xml中的相关配置：

 

[xhtml] view plaincopyprint?
  1. <context-param>  
  2.         <param-name>contextConfigLocation</param-name>  
  3.         <param-value>/WEB-INF/applicationContext.xml</param-value>  
  4.     </context-param>  
  5.       
  6.     <listener>  
  7.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  8.     </listener>  
  9.   
  10.     <!-- Handles all requests into the application -->  
  11.     <servlet>  
  12.         <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>  
  13.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  14.         <init-param>  
  15.             <param-name>contextConfigLocation</param-name>  
  16.             <param-value>  
  17.                 /WEB-INF/spring/*.xml  
  18.             </param-value>  
  19.         </init-param>  
  20.         <load-on-startup>1</load-on-startup>  
  21.     </servlet>  
  22.           
  23.     <!-- Maps all /app requests to the DispatcherServlet for handling -->  
  24.     <servlet-mapping>  
  25.         <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>  
  26.         <url-pattern>/app/*</url-pattern>  
  27.     </servlet-mapping>  

 

      在web.xml配置文件中，有两个主要的配置：ContextLoaderListener和DispatcherServlet。同样的关于spring配置文件的相关配置也有两部分：context-param和DispatcherServlet中的init-param。那么，这两部分的配置有什么区别呢？它们都担任什么样的职责呢？

      在Spring MVC中，Spring Context是以父子的继承结构存在的。Web环境中存在一个ROOT Context，这个Context是整个应用的根上下文，是其他context的双亲Context。同时Spring MVC也对应的持有一个独立的Context，它是ROOT Context的子上下文。

      对于这样的Context结构在Spring MVC中是如何实现的呢？下面就先从ROOT Context入手，ROOT Context是在ContextLoaderListener中配置的，ContextLoaderListener读取context-param中的contextConfigLocation指定的配置文件，创建ROOT Context。下面看一下ContextLoaderListener中创建context的源码：

 

[java] view plaincopyprint?
  1. /** 
  2.      * Initialize Spring's web application context for the given servlet context, 
  3.      * according to the "{@link #CONTEXT_CLASS_PARAM contextClass}" and 
  4.      * "{@link #CONFIG_LOCATION_PARAM contextConfigLocation}" context-params. 
  5.      * @param servletContext current servlet context 
  6.      * @return the new WebApplicationContext 
  7.      * @see #CONTEXT_CLASS_PARAM 
  8.      * @see #CONFIG_LOCATION_PARAM 
  9.      */  
  10.     public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {  
  11.                 //PS : ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE=WebApplicationContext.class.getName() + ".ROOT" 根上下文的名称  
  12.                   //PS : 默认情况下，配置文件的位置和名称是： DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml"  
  13.                   //在整个web应用中，只能有一个根上下文  
  14.         if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {  
  15.             throw new IllegalStateException(  
  16.                     "Cannot initialize context because there is already a root application context present - " +  
  17.                     "check whether you have multiple ContextLoader* definitions in your web.xml!");  
  18.         }  
  19.   
  20.         Log logger = LogFactory.getLog(ContextLoader.class);  
  21.         servletContext.log("Initializing Spring root WebApplicationContext");  
  22.         if (logger.isInfoEnabled()) {  
  23.             logger.info("Root WebApplicationContext: initialization started");  
  24.         }  
  25.         long startTime = System.currentTimeMillis();  
  26.   
  27.         try {  
  28.             // Determine parent for root web application context, if any.  
  29.             ApplicationContext parent = loadParentContext(servletContext);  
  30.   
  31.             // Store context in local instance variable, to guarantee that  
  32.             // it is available on ServletContext shutdown.  
  33.                         // 在这里执行了创建WebApplicationContext的操作  
  34.             this.context = createWebApplicationContext(servletContext, parent);  
  35.   
  36.                         //PS: 将根上下文放置在servletContext中  
  37.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);  
  38.   
  39.             ClassLoader ccl = Thread.currentThread().getContextClassLoader();  
  40.             if (ccl == ContextLoader.class.getClassLoader()) {  
  41.                 currentContext = this.context;  
  42.             }  
  43.             else if (ccl != null) {  
  44.                 currentContextPerThread.put(ccl, this.context);  
  45.             }  
  46.   
  47.             if (logger.isDebugEnabled()) {  
  48.                 logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +  
  49.                         WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");  
  50.             }  
  51.             if (logger.isInfoEnabled()) {  
  52.                 long elapsedTime = System.currentTimeMillis() - startTime;  
  53.                 logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");  
  54.             }  
  55.   
  56.             return this.context;  
  57.         }  
  58.         catch (RuntimeException ex) {  
  59.             logger.error("Context initialization failed", ex);  
  60.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);  
  61.             throw ex;  
  62.         }  
  63.         catch (Error err) {  
  64.             logger.error("Context initialization failed", err);  
  65.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);  
  66.             throw err;  
  67.         }  
  68.     }  

 

        再看一下WebApplicationContext对象是如何创建的：

 

[java] view plaincopyprint?
  1. protected WebApplicationContext createWebApplicationContext(ServletContext sc, ApplicationContext parent) {  
  2.                 //根据web.xml中的配置决定使用何种WebApplicationContext。默认情况下使用XmlWebApplicationContext  
  3.                 //web.xml中相关的配置context-param的名称“contextClass”  
  4.         Class<?> contextClass = determineContextClass(sc);  
  5.         if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {  
  6.             throw new ApplicationContextException("Custom context class [" + contextClass.getName() +  
  7.                     "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");  
  8.         }  
  9.   
  10.                 //实例化WebApplicationContext的实现类  
  11.         ConfigurableWebApplicationContext wac =  
  12.                 (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);  
  13.   
  14.         // Assign the best possible id value.  
  15.         if (sc.getMajorVersion() == 2 && sc.getMinorVersion() < 5) {  
  16.             // Servlet <= 2.4: resort to name specified in web.xml, if any.  
  17.             String servletContextName = sc.getServletContextName();  
  18.             if (servletContextName != null) {  
  19.                 wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + servletContextName);  
  20.             }  
  21.             else {  
  22.                 wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX);  
  23.             }  
  24.         }  
  25.         else {  
  26.             // Servlet 2.5's getContextPath available!  
  27.             wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + sc.getContextPath());  
  28.         }  
  29.   
  30.         wac.setParent(parent);  
  31.   
  32.         wac.setServletContext(sc);  
  33.                 //设置spring的配置文件  
  34.         wac.setConfigLocation(sc.getInitParameter(CONFIG_LOCATION_PARAM));  
  35.         customizeContext(sc, wac);  
  36.                 //spring容器初始化  
  37.         wac.refresh();  
  38.         return wac;  
  39.     }  

 

 

       以上是web容器中根上下文的加载与初始化，下面介绍一下Spring MVC对应的上下文是如何加载的。

     

       Spring MVC中核心的类是DispatcherServlet，在这个类中完成Spring context的加载与创建，并且能够根据Spring Context的内容将请求分发给各个Controller类。DispatcherServlet继承自HttpServlet，关于Spring Context的配置文件加载和创建是在init()方法中进行的，主要的调用顺序是init-->initServletBean-->initWebApplicationContext。

       先来看一下initWebApplicationContext的实现

 

[java] view plaincopyprint?
  1. /** 
  2.      * Initialize and publish the WebApplicationContext for this servlet. 
  3.      * <p>Delegates to {@link #createWebApplicationContext} for actual creation 
  4.      * of the context. Can be overridden in subclasses. 
  5.      * @return the WebApplicationContext instance 
  6.      * @see #setContextClass 
  7.      * @see #setContextConfigLocation 
  8.      */  
  9.     protected WebApplicationContext initWebApplicationContext() {  
  10.                 //先从web容器的ServletContext中查找WebApplicationContext  
  11.         WebApplicationContext wac = findWebApplicationContext();  
  12.         if (wac == null) {  
  13.             // No fixed context defined for this servlet - create a local one.  
  14.                         //从ServletContext中取得根上下文  
  15.             WebApplicationContext parent =  
  16.                     WebApplicationContextUtils.getWebApplicationContext(getServletContext());  
  17.                         //创建Spring MVC的上下文，并将根上下文作为起双亲上下文  
  18.             wac = createWebApplicationContext(parent);  
  19.         }  
  20.   
  21.         if (!this.refreshEventReceived) {  
  22.             // Apparently not a ConfigurableApplicationContext with refresh support:  
  23.             // triggering initial onRefresh manually here.  
  24.             onRefresh(wac);  
  25.         }  
  26.   
  27.         if (this.publishContext) {  
  28.             // Publish the context as a servlet context attribute.  
  29.                         // 取得context在ServletContext中的名称  
  30.             String attrName = getServletContextAttributeName();  
  31.                         //将Spring MVC的Context放置到ServletContext中  
  32.             getServletContext().setAttribute(attrName, wac);  
  33.             if (this.logger.isDebugEnabled()) {  
  34.                 this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +  
  35.                         "' as ServletContext attribute with name [" + attrName + "]");  
  36.             }  
  37.         }  
  38.   
  39.         return wac;  
  40.     }  

 

        通过initWebApplicationContext方法的调用，创建了DispatcherServlet对应的context，并将其放置到ServletContext中，这样就完成了在web容器中构建Spring IoC容器的过程。

 

        最后，在分别给出ContextLoaderListener和DispatcherServlet构建context的时序。

 

        ContextLoaderListener构建Root Context时序图：

 ContextLoaderListener

         DispatcherServlet创建context时序图：

 DispatcherServlet创建context时序图

 

 

 

 

 

 

 

 

 http://blog.csdn.net/prince2270/article/details/5889117

分享到：
| 构建服务器集群感知的 Java 应用程序
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring ioc+mvc代码

    1.1 容器的构建与初始化 在实现中，我们可以创建一个`ApplicationContext`类作为容器，它负责读取配置文件（如XML或Java注解），解析并生成bean的定义。 1.2 Bean的定义与实例化 bean的定义通常包含类名、属性和...

    Spring IOC AOP MVC 简单例子

    通过XML或注解方式声明bean，Spring可以自动管理bean的实例化、初始化和销毁，从而简化了代码并提高了可测试性。 其次，Spring的面向切面编程（AOP）允许开发者将关注点分离，比如日志、事务管理等横切关注点，从...

    springIoc实现原理

    4. **初始化**：Spring容器调用Bean的初始化方法，完成对象的初始化。 5. **Bean管理**：Spring容器负责Bean的生命周期管理，包括销毁等操作。 **六、应用场景** Spring Ioc广泛应用于各种项目中，如： - 数据...

    Spring源代码解析(二)：IoC容器在Web容器中的启动.doc

    这个过程涉及到一系列的初始化步骤，确保Spring能够正确地与Web容器集成。 首先，`WebApplicationContext`是`ApplicationContext`的一个扩展，专门针对Web应用设计。它增加了对`ServletContext`的访问和管理，使得...

    Spring3.1.3 Ioc在Web容器中的建立

    标题 "Spring3.1.3 Ioc在Web容器中的建立" 涉及的是Spring框架的一个关键特性——依赖注入（Dependency Injection，简称DI），以及如何在Web应用环境中配置和使用它。Spring是Java开发中最流行的轻量级框架之一，...

    Spring-MVC+Spring-IOC+Spring-JdbcTemple

    2. **Spring Bean的生命周期**：了解Bean的初始化、销毁方法，以及如何自定义Bean的生命周期。 3. **注解驱动的Spring MVC**：使用@Controller、@RequestMapping等注解来定义控制器及URL映射。 4. **Spring JDBC ...

    Spring实现一个简单的SpringIOC容器

    Spring的IOC（Inversion of Control，控制反转）容器是其核心特性之一，它负责管理和装配应用程序中的对象。本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计...

    Spring MVC框架简介和使用

    - 在 Web 容器启动时，会调用 `HttpServletBean` 的 `init()` 方法，初始化 Servlet 初始化参数。 - 接着调用 `FrameworkServlet` 的 `initServletBean()` 方法进行 Web 上下文初始化。 - 最后，`...

    helloworld spring mvc

    1. **web.xml**：这是部署描述符，定义了DispatcherServlet的配置，包括Servlet的映射路径和初始化参数。例如，配置DispatcherServlet的servlet-name、url-pattern以及加载Spring MVC的配置文件。 2. **spring-mvc-...

    Java EE企业级应用开发教程（Spring+Spring MVC+MyBatis）所有实验及实验报告.zip

    1. Spring框架的配置和使用，包括IoC容器的初始化、bean的定义和依赖注入。 2. Spring MVC的控制器定义、模型绑定、视图解析，以及处理HTTP请求的方法。 3. MyBatis的配置，SQL映射文件的编写，以及如何通过MyBatis...

    Spring mvc整合mybatis例子

    - `web.xml`：配置DispatcherServlet和ContextLoaderListener，前者处理HTTP请求，后者初始化Spring的ApplicationContext。 - `spring-mvc.xml`：配置ViewResolver，比如InternalResourceViewResolver，用于解析...

    Spring MVCSpring MVC基础.ppt

    DispatcherServlet也初始化了一个WebApplicationContext，它是Spring容器的一个特殊版本，专门用于Web应用。 2. **IoC（Inversion of Control）容器**：Spring MVC中的Controller组件是JavaBean，它们的实例化、...

    搭建Spring+Spring MVC+Hibernate开发框架

    然后，配置Spring的IoC容器，包括定义bean的实例化方式、初始化参数等。接着，设置Spring MVC的配置，如处理器映射器、视图解析器等。最后，配置Hibernate连接数据库的相关信息，包括数据源、实体类、映射文件等。 ...

    Spring,Spring MVC所需的jar包

    6. **spring-beans-4.1.5.RELEASE.jar**：包含Spring Bean的定义和管理，包括bean的创建、初始化、配置和销毁。它是Spring容器的核心，负责读取配置文件并管理bean的生命周期。 7. **spring-test-4.1.5.RELEASE.jar...

    spring MVC中文教程

    它是Spring IoC容器的基础，负责实例化、定位、配置应用程序中的对象。 - **ApplicationContext**：扩展了BeanFactory的功能，提供了对国际化支持、事件发布、资源访问等服务。它是面向整个应用的IoC容器。 - **Web ...

    《Java EE企业级应用开发教程Spring+Spring MVC+MyBatis》_源代码.zip

    10. **Chapter 17** - Spring Boot：简述Spring Boot快速开发框架，如何简化Spring应用的初始化和配置。包括自动配置、起步依赖和命令行界面等内容。 这些章节覆盖了Java EE开发中的关键技术和最佳实践，从基础到...

    Spring IoC讲解PPT

    Spring IoC 容器通过 XML 配置文件或注解方式实现对象的初始化和依赖注入。开发者可以定义bean的配置，如类名、属性值等，并声明bean之间的依赖关系。容器根据这些配置信息创建并管理bean，自动完成对象的实例化和...

    Spring-IoC.rar_容器

    - **Web应用**：在Spring MVC中，Controller层的bean通过IoC容器管理，方便进行依赖注入和AOP增强。 总之，Spring IoC容器作为核心组件，极大地提高了软件设计的灵活性和可维护性，通过解耦和管理对象的生命周期，...

    spring mvc案例+配置+原理详解+架包

    1. **web.xml**：配置DispatcherServlet，包括初始化参数、拦截器、监听器等。 2. **spring-mvc.xml**：定义Bean、数据源、事务管理器、视图解析器、HandlerMapping和HandlerAdapter等。 四、Spring MVC 原理 1. *...

    Java Web 案例实践，基于（spring，spring mvc，hibernate）框架实现的

    在这个案例实践中，你将会看到如何配置这三个框架，从初始化Spring上下文，到设置Spring MVC的DispatcherServlet，再到配置Hibernate的数据源和实体映射。你将学习到如何在Spring中声明和使用Service层，这些Service...

Magicbox
Global site tag (gtag.js) - Google Analytics