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

    展开全文
  • 原文链接:http://www.cnblogs.com/panxuejun/p/5898540.html要想很好理解这三个上下文的关系,需要先熟悉spring是怎样在web容器启动起来的。spring的启动过程其实就是其IoC容器的启动过程,对于web程序,IoC容器...

    原文链接:http://www.cnblogs.com/panxuejun/p/5898540.html

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

    spring的启动过程:

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

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

    再次,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。

    说完了spring上下文的初始化过程,这三个上下文的关系应该就了解了。如还是不太清楚,我就爱莫能助了,只能自行看代码去了。

    本文转自https://segmentfault.com/q/1010000000210417 感谢作者,很经典

    servletContext 是web应用程序的大环境,用于存储整个web应用程序级别的对象,不知道这样说法是否对.

    ApplicationContext,WebApplicationContext 是Spring的BeanFactory,从名字中就可以知道区别拉,一个是支持web特性的BeanFactory。

    Spring获取WebApplicationContext与ApplicationContext的几种方法:

    方法一:在初始化时保存ApplicationContext对象

    代码:

    ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");

    ac.getBean("beanId");

    说明:这种方式适用于采用Spring框架的独立应用程序,需要程序通过配置文件手工初始化Spring的情况。

    方法二:通过Spring提供的工具类获取ApplicationContext对象

    代码:

    import org.springframework.web.context.support.WebApplicationContextUtils;

    ApplicationContext ac1 = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc);

    ApplicationContext ac2 = WebApplicationContextUtils.getWebApplicationContext(ServletContext sc);

    ac1.getBean("beanId");

    ac2.getBean("beanId");

    说明:

    这种方式适合于采用Spring框架的B/S系统,通过ServletContext对象获取ApplicationContext对象,然后在通过它获取需要的类实例。

    展开全文
  • 在 java , 常见的 Context 有很多,像: ServletContext, ActionContext, ServletActionContext, ApplicationContext, ... 直译是上下文、环境的意思。比如像: "今天我收到了一束花, 男朋友送的!" 又或者 "今天...

    在 java 中, 常见的 Context 有很多,

    像: ServletContext, ActionContext, ServletActionContext, ApplicationContext, PageContext, SessionContext ...

    那么, Context 究竟是什么东西呢? 直译是上下文、环境的意思。比如像: "今天我收到了一束花, 男朋友送的!" 又或者 "今天我收到了一束花, 送花的人送错了的!"

    同样是收到一束花, 在不同的上下文环境中表达的意义是不一样的。

    同样的, Context 其实也是一样, 它离不开所在的上下文环境, 否则就是断章取义了。

    另外, 在网络上也有些人把 Context 看成是一些公用信息或者把它看做是一个容器的, 个人觉得这种解释稍好。

    接下来说说 ServletContext, ActionContext, ServletActionContext。

    1> ServletContext

    一个 WEB 运用程序只有一个 ServletContext 实例, 它是在容器(包括 JBoss, Tomcat 等)完全启动 WEB 项目之前被创建, 生命周期伴随整个 WEB 运用。

    当在编写一个 Servlet 类的时候, 首先是要去继承一个抽象类 HttpServlet, 然后可以直接通过 getServletContext() 方法来获得 ServletContext 对象。

    这是因为 HttpServlet 类中实现了 ServletConfig 接口, 而 ServletConfig 接口中维护了一个 ServletContext 的对象的引用。

    利用 ServletContext 能够获得 WEB 运用的配置信息, 实现在多个 Servlet 之间共享数据等。

    eg:

    url

    jdbc:oracle:thin:@localhost:1521:ORC

    username

    scott

    password

    tigger

    ConnectionServlet

    net.yeah.fancydeepin.servlet.ConnectionServlet

    ConnectionServlet

    /ConnectionServlet.action

    PrepareConnectionServlet

    net.yeah.fancydeepin.servlet.PrepareConnectionServlet

    PrepareConnectionServlet

    /PrepareConnectionServlet.action

    package net.yeah.fancydeepin.servlet;import java.io.IOException;

    import javax.servlet.ServletContext;

    import javax.servlet.ServletException;

    import javax.servlet.http.HttpServlet;

    import javax.servlet.http.HttpServletRequest;

    import javax.servlet.http.HttpServletResponse;

    public class PrepareConnectionServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    public void init() throws ServletException {

    ServletContext context = getServletContext();

    String url = context.getInitParameter("url");

    String username = context.getInitParameter("username");

    String password = context.getInitParameter("password");

    context.setAttribute("url", url);

    context.setAttribute("username", username);

    context.setAttribute("password", password);

    }

    protected void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{

    doPost(request, response);

    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    response.sendRedirect("ConnectionServlet.action");

    }

    }

    package net.yeah.fancydeepin.servlet;

    import java.io.IOException;

    import javax.servlet.ServletContext;

    import javax.servlet.ServletException;

    import javax.servlet.ServletRequest;

    import javax.servlet.ServletResponse;

    import javax.servlet.http.HttpServlet;

    public class ConnectionServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

    ServletContext context = getServletContext();

    System.out.println("***************************************");

    System.out.println("URL: " + context.getAttribute("url"));

    System.out.println("Username: " + context.getAttribute("username"));

    System.out.println("Password: " + context.getAttribute("password"));

    System.out.println("***************************************");

    super.service(request, response);

    }

    }

    当访问 PrepareConnectionServlet.action 时, 后台打印输出:

    ***********************************************

    URL:  jdbc:oracle:thin:@localhost:1521:ORC

    Username:  scott

    Password:  tigger

    ***********************************************

    2> ActionContext

    ActionContext 是当前 Action 执行时的上下文环境, ActionContext 中维护了一些与当前 Action 相关的对象的引用,

    如: Parameters (参数), Session (会话), ValueStack (值栈), Locale (本地化信息) 等。

    在 Struts1 时期, Struts1 的 Action 与 Servlet API 和 JSP 技术的耦合度都很紧密, 属于一个侵入式框架:

    public ActionForward execute(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response){

    // TODO Auto-generated method stub

    return null;

    }

    到了 Struts2 时期, Struts2 的体系结构与 Struts1 之间存在很大的不同。Struts2 在 Struts1 的基础上与 WebWork 进行了整合, 成为了一个全新的框架。

    在 Struts2 里面, 则是通过 WebWork 来将与 Servlet 相关的数据信息转换成了与 Servlet API 无关的对象, 即 ActionContext 对象。

    这样就使得了业务逻辑控制器能够与 Servlet API 分离开来。另外, 由于 Struts2 的 Action 是每一次用户请求都产生一个新的实例, 因此,

    ActionContext 不存在线程安全问题, 可以放心使用。

    package net.yeah.fancydeepin.action;

    import java.util.Map;

    import com.opensymphony.xwork2.ActionContext;

    import com.opensymphony.xwork2.ActionSupport;

    import com.opensymphony.xwork2.util.ValueStack;

    public class ContextAction extends ActionSupport {

    private static final long serialVersionUID = 1L;

    private String username;

    private String password;

    public String execute(){

    ActionContext context = ActionContext.getContext();

    ValueStack value = context.getValueStack();

    value.set("username", username);

    value.set("password", password);

    Map session = context.getSession();

    session.put("url", "http://www.blogjava.net/fancydeepin");

    return SUCCESS;

    }

    public void setUsername(String username) {

    this.username = username;

    }

    public void setPassword(String password) {

    this.password = password;

    }

    }

    当访问 context.action 并传给相应的参数的时候, 在浏览器中会输出相应的信息。

    留意到上面 Struts2 的 Action 中并有没添加属性的 getting 方法, 而是手动的将参数值放到值栈(ValueStack)中的, 否则页面是得不到参数来输出的。

    3> ServletActionContext

    首先, ServletActionContext 是 ActionContext 的一个子类。ServletActionContext 从名字上来看, 意味着它与 Servlet API 紧密耦合。

    ServletActionContext 的构造子是私有的, 主要是提供了一些静态的方法, 可以用来获取: ActionContext, ActionMapping, PageContext,

    HttpServletRequest, HttpServletResponse, ServletContext, ValueStack, HttpSession 对象的引用。public String execute(){

    //或 implements ServletRequestAware

    HttpServletRequest request = ServletActionContext.getRequest();

    //或 implements ServletResponseAware

    HttpServletResponse response = ServletActionContext.getResponse();

    //或 implements SessionAware

    HttpSession session = request.getSession();

    //或 implements ServletContextAware

    ServletContext context = ServletActionContext.getServletContext();

    return SUCCESS;

    }

    好文分享

    转发自http://www.blogjava.net/fancydeepin/archive/2013/03/31/java-ee-context.html

    展开全文
  • javaweb的request,session,application对象,其基本作用是充当“共享区”的角色,即数据的传递存放区,但其共享的范围不尽相同,其名称代表着共享的范围。为了说明其范围的不同,先一张图:1、当Tomcat启动时...
  • 要想很好理解这三个上下文的关系,需要先熟悉spring是怎样在web容器启动起来的。spring的启动过程其实就是其IoC容器的启动过程,对于web程序,IoC容器启动过程即是建立上下文的过程。 spring的启动过程: ...
  • spring 上下文和spring mvc上下文web应用上下文servletContext之间的关系 spring的启动过程: 总结 问题:web.xml 配置文件需要监听器(contextLoaderListener)吗? 为什么探究这个问题...
  • javaweb的request,session,application对象,其基本作用是充当“共享区”的角色,即数据的传递存放区,但其共享的范围不尽相同,其名称代表着共享的范围。 为了说明其范围的不同,先一张图: 1、当Tomcat启动...
  • web.xml中上下文参数

    2015-07-30 20:15:39
    启动一个WEB项目的时候,容器(如:Tomcat)会去读它的配置文件web.xml,读两个节点<listener>...紧接着,容器创建一个ServletContext(上下文),这个web项目所有部分都将共享这个上下文容器<context...
  • 一、先说ServletContext  javaee标准规定了,servlet容器需要在应用项目启动时,给应用项目...通过自定义contextListener获取web.xml配置的参数 1.容器启动时,找到配置文件的context-param作为键值对放到S...
  • Spring MVC Web应用上下文

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

    千次阅读 2009-07-20 17:26:00
    关于web应用上下文Context 很多朋友都对Context不太了解,他们说"项目没看到这个对象啊""但是老是听人提起Context","经常看到ServletContext,PageContext.EJBContext, 还有Spring里面的ApplicationContext等等" ...
  • 原文链接 一、先说ServletContext  javaee标准规定了,servlet容器需要在应用项目启动时,给应用项目初始化一个...通过自定义contextListener获取web.xml配置的参数 1.容器启动时,找到配置文件的context-
  • web容器更准确的说应该叫web服务器,它是来管理和部署 web应用的。web容器最典型的就是tomcat了,Tomcat是web容器也是servlet容器。所谓容器(服务器、中间件等),就是提供一些底层的、业务无关的基本功能,为真正...
  • 在Spring web环境,spring 上下文和spring mvc上下文web应用上下文servletContext之间的关系,要想很好理解这三个上下文的关系,需要先熟悉spring是怎样在web容器启动起来的。spring的启动过程其实就是其IoC...
  • web.xml 上下文参数

    千次阅读 2011-01-20 11:16:00
    2.紧接着,容器创建一个ServletContext(上下文),这个WEB项目所有部分都将共享这个上下文. 3.容器将转化为键值对,并交给ServletContext. 4.容器创建的类实例,即创建监听. 5.在监听会有contextInitialized...
  • 关于web应用上下文Context

    千次阅读 2015-07-31 11:51:28
    关于web应用上下文Context     很多朋友都对Context不太了解,他们说"项目没看到这个对象啊""但是老是听人提起Context","经常看到ServletContext,PageContext.EJBContext, 还有Spring里面的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,204
精华内容 2,481
关键字:

web中上下文