精华内容
下载资源
问答
  • Web上下文Web上下文又称为ServletContext,ServletContext是Servlet容器上下文环境对象,定义了一组方法,servlet 使用这些方法与其 servlet 容器进行通信,例如,获取文件的 MIME 类型、分发请求或写入日志...

     

    Web上下文:

                   Web上下文又称为ServletContext,ServletContext是Servlet容器上下文环境对象,定义了一组方法,servlet 使用这些方法与其 servlet 容器进行通信,例如,获取文件的 MIME 类型、分发请求或写入日志文件。每个web应用都有且仅有一个ServletContext对象,这个对象在所有的Servlet都可以使用。

    web 容器提供的全局上下文环境,为后面的 Spring IOC 提供宿主环境。

    Spring上下文:

    继承自BeanFactory接口,除了包含BeanFactory的所有功能之外,在国际化支持、资源访问(如URL和文件)、事件传播等方面进行了良好的支持,被推荐为Java EE应用之首选,可应用在Java APP与Java Web中。 
    由web.xml中提供的 contextLoaderListener,在web容器启动时触发容器初始化事件,其中的 contextInitialized 方法被调用时创建的根上下文(即:WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,)。采用 XmlWebApplicationContext 实现方法,作为 Spring IOC 容器,对应的 Bean 定义的配置由 web.xml 中的 context-param 标签指定。会被存储在 ServletContext 中。

    SpringMvc上下文

    获取根上下文(WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE ) 作为自己上下文的parent上下文,再初始化自己持有的上下文(默认实现类也是 xmlWebApplicationContext)。之后将该上下文以key-value的方式设置在 ServletContex中,以便后续使用。至此,每个 Servlet 既有自己的上下文(即独立的bean空间),又各个 Servlet 可以共享根上下文中定义的 bean。 
    例如:DispatcherServlet 维持自己的 ApplicationContext,默认会读取/WEB-INFO/-servlet.xml 文件,也可以在 /WEB-INF/web.xml 中的 Servlet 模块 重新配置。

    参考博客:https://blog.csdn.net/cathar/article/details/54880875

    我自己的理解是:

    在应用项目启动的时候呢,web容器给项目初始化一个ervletContext作为公共环境容器存放公共信息。ServletContext中的信息都是由容器提供的。

    执行流程:

    web.xml在<context-param></context-param>标签中声明应用范围内的初始化参数

    1.启动一个WEB项目的时候,容器(如:Tomcat)会去读它的配置文件web.xml.读两个节点: <listener></listener> 和 <context-param></context-param> 2.紧接着,容器创建一个ServletContext(上下文)。在该应用内全局共享。

    3.容器将<context-param></context-param>转化为键值对,并交给ServletContext.

    4.容器创建<listener></listener>中的类实例,即创建监听.该监听器必须实现自ServletContextListener接口

    5.在监听中会有contextInitialized(ServletContextEvent event)初始化方法,在这个方法中获得                               ServletContext=ServletContextEvent.getServletContext(); “context-param的值” = ServletContext.getInitParameter('context-param的键');

    6.得到这个context-param的值之后,你就可以做一些操作了.注意,这个时候你的WEB项目还没有完全启动完成.这个动作会比所有的Servlet都要早.换句话说,这个时候,你对<context-param>中的键值做的操作,将在你的WEB项目完全启动之前被执行.web.xml中可以定义两种参数:

    (1)一个是全局参数(ServletContext),通过<context-param></context-param> 

    例如:

    <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    一个是servlet参数,通过在servlet中  <init-param> 标签中通过<param-name><param-value>     

    例如:                           

    <servlet>
      <servlet-name>SpringMVC</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <!-- 配置springMVC需要加载的配置文件-->
      <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-*.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
      <async-supported>true</async-supported>
    </servlet>

          第一种参数在servlet里面可以通过getServletContext().getInitParameter('context/param')得到

           第二种参数只能在servlet的init()方法中通过this.getInitParameter('param1')取得

    初始化Spring上下文:

    然后Spring为我们提供了一个接口来初始化Spring上下文:org.springframework.web.context.ContextLoaderListener

    使用方法:

    <!-- spring的配置文件-->
    <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    该监听器,默认读取/WEB-INF/下的applicationContext.xml文件。但是通过context-param指定配置文件路径后,便会去你指定的路径下读取对应的配置文件,并进行初始化。

    即从上述的第二步开始:

    容器调用web.xml中配置的contextLoaderListener,初始化WebApplicationContext上下文环境(即IOC容器),加载context-param指定的配置文件信息到IOC容器中。WebApplicationContext在ServletContext中以键值对的形式保存

    这时候我们的web应用就有了我们的SpringIOC容器

    还没完呢,不是还有SpringMVC容器吗?

    初始化SpringMvc上下文:

    <!-- 配置DispatcherServlet -->
    <servlet>
      <servlet-name>SpringMVC</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <!-- 配置springMVC需要加载的配置文件-->
      <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-*.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
      <async-supported>true</async-supported>
    </servlet>

    容器为其初始化自己的上下文信息servletContext,并加载其设置的配置信息到该上下文中。将WebApplicationContext设置为它的父容器,即springmvc以及后面的servlet都是springIoc容器的子容器。

    这三者的关系就像我下面画的这副图

    最后借博客总结:https://blog.csdn.net/cathar/article/details/54880875 

    1.功能而言:ContextLoaderListener中创建ApplicationContext(SpringIoc上下文)主要用于整个Web应用程序需要共享的一些组件,不管是使用什么表现层技术,一般如DAO层、Service层Bean、数据库的ConnectionFactory等。而由DispatcherServlet创建的ApplicationContext 只加载对Spring Web MVC有效的Bean,如Controller、HandlerMapping、HandlerAdapter等等,该初始化上下文应该只加载Web相关组件。


    2.范围而言:在DispatcherServlet(SpringMVC上下文)中可以引用由ContextLoaderListener所创建的ApplicationContext(SpringIoc上下文),而反过来不行。
    实现顺序:这两个ApplicationContext都是通过ServletContext的setAttribute方法放到ServletContext中的。但是,ContextLoaderListener会先于DispatcherServlet(SpringMVC上下文)创建ApplicationContext,DispatcherServlet在创建ApplicationContext时会先找到由ContextLoaderListener所创建的ApplicationContext(SpringIoc上下文),再将后者的ApplicationContext(SpringIoc上下文)作为参数传给DispatcherServlet的ApplicationContext的setParent()方法。此后,框架又会调用ServletContext的setAttribute()方法将wac加入到ServletContext中。


    3.查找顺序:当Springmvc在执行ApplicationContext的getBean时,如果在自己context中找不到对应的bean,则会在父ApplicationContext中去找。这也解释了为什么我们可以在DispatcherServlet中获取到由ContextLoaderListener对应的ApplicationContext中的bean。 spring mvc的上下文继承了spring的上下文

    展开全文
  • spring中的web上下文,spring上下文,springmvc上下文区别 Spring容器和应用上下文理解 SpringMVC理解之一:应用上下文webApplicationContext
    展开全文
  • web上下文(Servlet context),spring上下文(WebApplication Context),springmvc上下文(mlWebApplicationCont)之间区别. 上下文:可以简单的理解为容器,配置文件 web上下文目标对象是所有web应用,spring上下文...

    web上下文(Servlet context),spring上下文(WebApplication Context),springmvc上下文(mlWebApplicationCont)之间区别.

    上下文:可以简单的理解为容器,配置文件

    web上下文目标对象是所有web应用,spring上下文目标对象是单个web应用,spring mvc目标对象是单个web应用的spring mvc框架(是spring上下文的子上下文,即继承自spring上下文,所以子能够调用父的东西,反之,不可)。

    以上感觉自己理解有偏差,看到一篇不错的,先markdow

    原文链接

    一、先说ServletContext

      javaee标准规定了,servlet容器需要在应用项目启动时,给应用项目初始化一个ServletContext作为公共环境容器存放公共信息。ServletContext中的信息都是由容器提供的。

    举例: 
    通过自定义contextListener获取web.xml中配置的参数 1.容器启动时,找到配置文件中的context-param作为键值对放到ServletContext中 2.然后找到listener,容器调用它的contextInitialized(ServletContextEvent event)方法,执行其中的操作 例如:在web.xml中配置

    <context-param>
       <param-name>key</param-name>
       <param-value>value123</param-value>
    </context-param>
    <listener> 
       <listener-class>com.brolanda.contextlistener.listener.ContextListenerTest</listener-class>
    </listener>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    配置好之后,在该类中获取对应的参数信息

    package com.brolanda.contextlistener.listener;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    
    public class ContextListenerTest implements ServletContextListener {
    
        public void contextDestroyed(ServletContextEvent event) {
            System.out.println('*************destroy ContextListener*************');
        }
    
        @SuppressWarnings('unused')
        public void contextInitialized(ServletContextEvent event) {
            System.out.println('*************init ContextListener*************');
            ServletContext servletContext = event.getServletContext();
            System.out.println('key:'+servletContext.getInitParameter('key'));
        }
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    执行流程:

      web.xml在标签中声明应用范围内的初始化参数 
    1.启动一个WEB项目的时候,容器(如:Tomcat)会去读它的配置文件web.xml.读两个节点: 和 2.紧接着,容器创建一个ServletContext(上下文)。在该应用内全局共享。

    3.容器将转化为键值对,并交给ServletContext. 
    4.容器创建中的类实例,即创建监听.该监听器必须实现自ServletContextListener接口

    5.在监听中会有contextInitialized(ServletContextEvent event)初始化方法 
    在这个方法中获得ServletContext = ServletContextEvent.getServletContext(); 
    “context-param的值” = ServletContext.getInitParameter(‘context-param的键’); 6.得到这个context-param的值之后,你就可以做一些操作了.注意,这个时候你的WEB项目还没有完全启动完成.这个动作会比所有的Servlet都要早.换句话说,这个时候,你对中的键值做的操作,将在你的WEB项目完全启动之前被执行. web.xml中可以定义两种参数: 一个是全局参数(ServletContext),通过 一个是servlet参数,通过在servlet中声明    param1 avalible in servlet init() 第一种参数在servlet里面可以通过getServletContext().getInitParameter(‘context/param’)得到 第二种参数只能在servlet的init()方法中通过this.getInitParameter(‘param1’)取得

    二、spring上下文容器配置

      spring为我们提供了实现ServletContextListener接口的上下文初始化监听器:org.springframework.web.context.ContextLoaderListener

      spring为我们提供的IOC容器,需要我们指定容器的配置文件,然后由该监听器初始化并创建该容器。要求你指定配置文件的地址及文件名称,一定要使用:contextConfigLocation作为参数名称。

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml,/WEB-INF/action-servlet.xml,/WEB-INF/jason-servlet.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    该监听器,默认读取/WEB-INF/下的applicationContext.xml文件。但是通过context-param指定配置文件路径后,便会去你指定的路径下读取对应的配置文件,并进行初始化。

    三、spring上下文容器配置后,初始化了什么?

      既然,ServletContext是由Servlet容器初始化的,那spring的ContextLoaderListener又做了什么初始化呢? 
    1、servlet容器启动,为应用创建一个“全局上下文环境”:ServletContext 2、容器调用web.xml中配置的contextLoaderListener,初始化WebApplicationContext上下文环境(即IOC容器),加载context-param指定的配置文件信息到IOC容器中。WebApplicationContext在ServletContext中以键值对的形式保存 3、容器初始化web.xml中配置的servlet,为其初始化自己的上下文信息servletContext,并加载其设置的配置信息到该上下文中。将WebApplicationContext设置为它的父容器。 4、此后的所有servlet的初始化都按照3步中方式创建,初始化自己的上下文环境,将WebApplicationContext设置为自己的父上下文环境。

    对于作用范围而言,在DispatcherServlet中可以引用由ContextLoaderListener所创建的ApplicationContext中的内容,而反过来不行。 当Spring在执行ApplicationContext的getBean时,如果在自己context中找不到对应的bean,则会在父ApplicationContext中去找。这也解释了为什么我们可以在DispatcherServlet中获取到由ContextLoaderListener对应的ApplicationContext中的bean。

    四、spring配置时:的使用原因,为什么在applicationContext.xml中排除controller,而在spring-mvc.xml中incloud这个controller 
    既然知道了spring的启动流程,那么web容器初始化webApplicationContext时作为公共的上下文环境,只需要将service、dao等的配置信息在这里加载,而servlet自己的上下文环境信息不需要加载。故,在applicationContext.xml中将@Controller注释的组件排除在外,而在dispatcherServlet加载的配置文件中将@Controller注释的组件加载进来,方便dispatcherServlet进行控制和查找。故,配置如下: applicationContext.mxl中:

      <context:component-scan 
      base-package='com.linkage.edumanage'>      
       <context:exclude-filter expression='org.springframework.stereotype.Controller'    type='annotation' />   </context:component-scan>   
    
    
    
    spring-mvc.xml中:   
    
    
    <context:component-scan 
    base-package='com.brolanda.cloud'   use-default-filters='false'>        
    <context:include-filter expression='org.springframework.stereotype.Controller'    type='annotation' />   
    </context:component-scan> 

    1

    2

    • 3
    • 4
    • 5
    • 6
    • 7

     

     

    package com.brolanda.contextlistener.listener; import javax.servlet.ServletContext; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class ContextListenerTest implements ServletContextListener { public void contextDestroyed(ServletContextEvent event) { System.out.println('*************destroy ContextListener*************'); } @SuppressWarnings('unused') public void contextInitialized(ServletContextEvent event) { System.out.println('*************init ContextListener*************'); ServletContext servletContext = event.getServletContext(); System.out.println('key:'+servletContext.getInitParameter('key'));

    小知识: 
    1.为什么要在spring-mvc.xml过滤器添加 use-default-filters=’false’。 
    答:因为use-default-filters用来指示是否自动扫描带有 
    @Component、@Repository、@Service和@Controller的类。默认为true,即默认扫描。而我们要求只是扫描Controller.

    相关链接

    2.为什么spring中的扫包要除去controller,spring mvc中只扫controller(pring MVC管理Controller,Spring 管理Controller之外的Bean)。 
    答:这个跟spring mvc的工作流程有关,spring mvc主要bean就是实现了Controller接口的controller类.看图:

    其中Handler Mapping是一个xxx-servlet.xml文件,这个是DispatchServlet上下文(注意是DispatchServlet的)配置文件,里面配置了对于不同url即请求对应的控制器.

    相关JSP学习推荐人民邮电出版社的JSP程序设计(page 230有spring mvc内容)。

    不过我自身残留个疑问,既然spring mvc的上下文继承了spring的上下文,那么其实spring mvc把全部包都扫了好像也不会出问题,只不过把继承至父类的bean覆盖掉而已,待解决.

    转载于:https://www.cnblogs.com/writeLessDoMore/p/6986011.html

    展开全文
  • java web上下文理解

    2019-02-18 10:46:05
    1.context就是“容器”,放的就是应用程序的所有资源,要用时候就...web上下文可以看成web应用的运行环境,一般用context名字来修饰,里面保存了web应用相关的一些设置和全局变量2.ServletContext,是一个全局的储...

    转载链接: https://www.baidu.com/link?url=MkBIER1kCNFO5gZI6GRZ_6Cj6XTaJFZyFiLhnVbc96t_o_Tt2ZXZtIwKaKO4Alm-riSGGZLfvzyoxRbPP3E5L8h6VHqdRBsvScS4uZgMRi_&wd=&eqid=ccfc6b8200059771000000025c6a1735

    1.context就是“容器”,放的就是应用程序的所有资源,要用时候就访问它,所以context里面的东西,在同一个应用程序里面是全局的;web上下文可以看成web应用的运行环境,一般用context名字来修饰,里面保存了web应用相关的一些设置和全局变量

    2.ServletContext,是一个全局的储存信息的空间,服务器开始,其就存在,服务器关闭,其才释放。request,一个用户可有多个;session,一个用户一个;而servletContext,所有用户共用一个。所以,为了节省空间,提高效率,ServletContext中,要放必须的、重要的、所有用户需要共享的线程又是安全的一些信息;

    1. HttpSession session =request.getSession();
    2. session.getServletContext();

    3.avaWeb中的上下文环境概念就是:一个web服务启动后的整个服务中的所有内存对象和他们之间的关系组成的一种环境

    spring 上下文和spring mvc上下文和web应用上下文servletContext之间的关系

    要想很好理解这三个上下文的关系,需要先熟悉spring是怎样在web容器中启动起来的。spring的启动过程其实就是其IoC容器的启动过程,对于web程序,IoC容器启动过程即是建立上下文的过程。

    spring的启动过程:

    1. 首先,对于一个web应用,其部署在web容器中,web容器提供其一个全局的上下文环境,这个上下文就是ServletContext,其为后面的spring IoC容器提供宿主环境;

    2. 其次,在web.xml中会提供有contextLoaderListener。在web容器启动时,会触发容器初始化事件,此时contextLoaderListener会监听到这个事件,其contextInitialized方法会被调用,在这个方法中,spring会初始化一个启动上下文,这个上下文被称为根上下文,即WebApplicationContext,这是一个接口类,确切的说,其实际的实现类是XmlWebApplicationContext。这个就是spring的IoC容器,其对应的Bean定义的配置由web.xml中的context-param标签指定。在这个IoC容器初始化完毕后,spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key,将其存储到ServletContext中,便于获取;

    3. 再次,contextLoaderListener监听器初始化完毕后,开始初始化web.xml中配置的Servlet,这个servlet可以配置多个,以最常见的DispatcherServlet为例,这个servlet实际上是一个标准的前端控制器,用以转发、匹配、处理每个servlet请求。DispatcherServlet上下文在初始化的时候会建立自己的IoC上下文,用以持有spring mvc相关的bean。在建立DispatcherServlet自己的IoC上下文时,会利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE先从ServletContext中获取之前的根上下文(即WebApplicationContext)作为自己上下文的parent上下文。有了这个parent上下文之后,再初始化自己持有的上下文。这个DispatcherServlet初始化自己上下文的工作在其initStrategies方法中可以看到,大概的工作就是初始化处理器映射、视图解析等。这个servlet自己持有的上下文默认实现类也是mlWebApplicationContext。初始化完毕后,spring以与servlet的名字相关(此处不是简单的以servlet名为Key,而是通过一些转换,具体可自行查看源码)的属性为属性Key,也将其存到ServletContext中,以便后续使用。这样每个servlet就持有自己的上下文,即拥有自己独立的bean空间,同时各个servlet共享相同的bean,即根上下文(第2步中初始化的上下文)定义的那些bean。

    servletContext 是web应用程序的大环境,用于存储整个web应用程序级别的对象.

    1. Spring上下文(ApplicationContext)
    2. 方法一:ClassPathXmlApplicationContext --从classpath路径加载配置文件,创建Bean对象
    3. ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    4. ClassName clazz =(ClassName)ctx.getBean("beanName");
    5. 方法二:FileSystemXmlApplicationContext --从指定的目录中加载
    6. ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");
    7. ClassName clazz =(ClassName)ctx.getBean("beanName");
    8. 方法三:Spring提供的工具类WebApplicationContextUtils获取ApplicationContext对象(通过ServletContext对象获得ApplicationContext对象,然后根据它获得需要的类实例)
    9. HttpSession session =request.getSession();
    10. ServletContext context = session.getServletContext(); //arg0.getSession().getServletContext();
    11. ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(context);
    12. ClassName clazz =(ClassName)ctx.getBean("beanName");
    13. 上面两个工具方式的区别是,前者在获取失败时抛出异常,后者返回null。
    14. 方法四:继承自抽象类ApplicationObjectSupport
    15. 说明:抽象类ApplicationObjectSupport提供getApplicationContext()方法,可以方便的获取到ApplicationContext。
    16. Spring初始化时,会通过该抽象类的setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象注入。
    17. 例如:
    18. import org.springframework.context.support.ApplicationObjectSupport;
    19. public class ContextOne extends ApplicationObjectSupport
    20. {
    21. ......
    22. }
    23. ........
    24. ContextOne one = new ContextOne();
    25. one.getApplicationContext();
    26. 方法五:继承自抽象类WebApplicationObjectSupport
    27. 说明:类似上面方法,调用getWebApplicationContext()获取WebApplicationContext
    28. 例如:
    29. import org.springframework.web.context.support.WebApplicationObjectSupport;
    30. public class ContextOne extends WebApplicationObjectSupport {
    31. .......
    32. }
    33. ........
    34. ContextOne one = new ContextOne();
    35. one.getApplicationContext();
    36. 方法六:实现接口ApplicationContextAware
    37. http://blog.csdn.net/kaiwii/article/details/6872642
    38. 当一个类实现了ApplicationContextAware接口后,这个类就可以获得Spring配置文件中的所引用到的bean对象。
    39. 说明:实现该接口的setApplicationContext(ApplicationContext context)方法,并保存ApplicationContext 对象。
    40. Spring初始化时,会通过该方法将ApplicationContext对象注入。
    41. 例如:
    42. package com.auth.util;
    43. import org.springframework.beans.BeansException;
    44. import org.springframework.context.ApplicationContext;
    45. import org.springframework.context.ApplicationContextAware;
    46. //通过接口ApplicationContextAware获得spring上下文
    47. public class Context implements ApplicationContextAware {
    48. private static ApplicationContext ctx;
    49. //设置ApplicationContext对象
    50. public void setApplicationContext(ApplicationContext context)
    51. throws BeansException {
    52. // TODO Auto-generated method stub
    53. ctx=context;
    54. }
    55. //通过beanName获得实例
    56. public static Object getBean(String beanName)
    57. {
    58. return ctx.getBean(beanName);
    59. }
    60. }







    展开全文
  • 第五章:Web上下文 第1节:ServletContext接口 知识点1:上下文对象的概念、作用 1.什么是上下文对象 ​ 用来存储全局范围信息的对象,一个web应用只有唯一的一个上下文对象. 2.上下文对象的作用 ​ 存储全局...
  • 原文链接 一、先说ServletContext  javaee标准规定了,servlet容器需要在应用项目启动时,给应用项目初始化一个...通过自定义contextListener获取web.xml中配置的参数 1.容器启动时,找到配置文件中的context-
  • 1)获取web上下文路径 public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //获取ServletContext对象 //this.getServletConfig().get...
  • SpringMVC4零配置--Web上下文配置【MvcConfig】
  • web容器更准确的说应该叫web服务器,它是来管理和部署 web应用的。web容器最典型的就是tomcat了,Tomcat是web容器也是servlet容器。所谓容器(服务器、中间件等),就是提供一些底层的、业务无关的基本功能,为真正...
  • SpringWeb上下文环境

    2019-03-30 17:43:14
    如果使用DispatcherServlet,则不需要增加其他任何配置 <servlet> <servlet-name>SpringServlet<...org.springframework.web.<servlet-class/> <init-param> &l...
  • 一、先说ServletContext  javaee标准规定了,servlet容器需要在应用项目启动时,给应用项目...通过自定义contextListener获取web.xml中配置的参数 1.容器启动时,找到配置文件中的context-param作为键值对放到S...
  • 获取web上下文

    2014-01-21 16:20:05
    Thread.currentThread().getContextClassLoader().getResource(").toString().substring(6).splite("/WEB-INFO")[0];
  • web上下文监听器ServletContextListener

    千次阅读 2015-05-25 10:41:06
    这个事件类作为Web应用服务的一部分,处理Web应用的 servlet上下文(context)的变化的通知。这可以解释为,好像有个人在服务器旁不断地通知我们服务器在发生什么事件。那当然需要监听者了。因此,在通知上下文...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,540
精华内容 3,416
关键字:

web上下文