精华内容
下载资源
问答
  • 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>

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

    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'));
        }
    
    }
    

    执行流程:

      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>
    

    该监听器,默认读取/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.为什么要在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覆盖掉而已,待解决.

    展开全文
  • 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上下文

    2014-01-21 16:20:05
    Thread.currentThread().getContextClassLoader().getResource(").toString().substring(6).splite("/WEB-INFO")[0];
    Thread.currentThread().getContextClassLoader().getResource(").toString().substring(6).splite("/WEB-INFO")[0];
    展开全文
  • 1)获取web上下文路径 public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //获取ServletContext对象 //this.getServletConfig().get...

     

    1)获取web上下文路径

     

    public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		//获取ServletContext对象
    		//this.getServletConfig().getServletContext();
    		//等同于下面一句,因为创建getServletContext必须要通过getServletConfig对象
    		ServletContext context = this.getServletContext();
    		
    		//获取web的上下文路径,
    		String path = context.getContextPath();
    		
    		//请求重定向,这样的好处可以让获取的路径更加灵活。不用考虑项目名是否发生了变化。
    		response.sendRedirect(context.getContextPath()+"/index.jsp");
    	}
    }
    


    2)获取全局参数

     

     

    public class ServletContextDemo1 extends HttpServlet {
    	/**
    	 * 获取全局参数
    	 */
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		 ServletContext context = this.getServletContext();
    		 //根据参数名获取参数值
    		 System.out.println(context.getInitParameter("MMM"));
    		 //获取所有的参数名,返回枚举类型
    		 Enumeration<String> emn = context.getInitParameterNames();
    		 while(emn.hasMoreElements()){
    			 String paramName = emn.nextElement();
    			 String paramValue = context.getInitParameter(paramName);
    			 System.out.println(paramName+"="+paramValue);
    		 }
    	}
    
    }
    

     

     

    3)和域相关

    域:域对象在不同的资源之间来共享数据,保存数据,获取数据。

    这个我使用了三个Servlet来说明这个问题,ScopeDemo1用于获取Attribute,ScopeDemo2用于设置Attribute,ScopeDemo3用于删除Attribute。

     

    保存共享数据:

     

    public class ScopeDemo2 extends HttpServlet {
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		//首先创建ServletContext对象
    	ServletContext context = 	this.getServletContext();
    	//保存共享数据
    	context.setAttribute("name", "zhangsan");//第一个参数为字符串,第二个是Object(也就是任意类型)
    	System.out.println("设置成功");
    	
    	}
    
    }

     

    获取共享数据:

     

    public class ScopeDemo1 extends HttpServlet {
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		//创建ServletContext对象
    		ServletContext context = this.getServletContext();
    		//获取共享数据内容
    		String name = (String)context.getAttribute("nnn");
    		System.out.println(name);
    	}
    }


    删除共享数据:

     

     

    public class ScopeDemo3 extends HttpServlet {
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		//获取ServletContext对象
    		ServletContext context = 	this.getServletContext();
    		//删除共享数据
    		context.removeAttribute("name");
    		System.out.println("删除成功");		
    	}
    }
    

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 一、先说ServletContext javaee标准规定了,servlet容器需要在应用项目启动时,给...举例: 通过自定义contextListener获取web.xml中配置的参数 1.容器启动时,找到配置文件中的context-param作为键值对放到Servle
  • 上下文对象。 org.thymeleaf.context.IContext或org.thymeleaf.context.IWebContext的实现取决于我们的环境(独立或Web)。 /* * ====================================================================== *...
  • tomcat是一个servlet容器,也就是一个服务器,servlet一个服务类,用于提供服务。servlet需要servlet容器来启动,不能脱离容器独自运行。 你发一个http请求到服务器... web上下文可以看成web应用的运行环境,一般用cont
  • 虽然AAS是最常见也是实施最多的产品,但是,实际中使用到的往往是最常见的一些配置内容,遇到某些特殊情况,往往...实际应用中,配置应用的上下文根是最常见也是看起来信手拈来的操作与配置(需求往往是设置默认应用,
  • web spring springmvc上下文关系

    千次阅读 2017-02-17 12:45:44
    web上下文(Servlet context),spring上下文(WebApplication Context),springmvc上下文(mlWebApplicationCont)之间区别. 上下文:可以简单的理解为容器,配置文件 web上下文目标对象是所有web应用,...
  • Spring MVC Web应用上下文

    千次阅读 2016-07-02 17:29:36
    Spring MVC是建立在Spring IoC容器的基础上,然而Spring IoC是一个独立的模块,因此并不能直接在Web环境中发挥作用。为了在Web环境中使用Ioc,就需要Spring提供一个适合于Web环境的...下面着重介绍Web应用上下文
  • 关于web应用上下文Context

    千次阅读 2015-07-31 11:51:28
    关于web应用上下文Context     很多朋友都对Context不太了解,他们说"项目中没看到这个对象啊""但是老是听人提起Context","经常看到ServletContext,PageContext.EJBContext, 还有Spring里面的...
  • js 获取当前web应用的上下文路径实现方法 //js webcontext var webroot=[removed].href; webroot=webroot.substring(webroot.indexOf('//')+2,webroot.length); webroot=webroot.substring(webroot.indexOf('/')+...
  • web应用上下文

    千次阅读 2009-07-20 17:26:00
    关于web应用上下文Context 很多朋友都对Context不太了解,他们说"项目中没看到这个对象啊""但是老是听人提起Context","经常看到ServletContext,PageContext.EJBContext, 还有Spring里面的ApplicationContext等等" ...
  • 实用Web驱动的上下文感知系统设计
  • 基于上下文Web服务推荐模型

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 294,869
精华内容 117,947
关键字:

web上下文