精华内容
下载资源
问答
  • js 获取当前web应用的上下文路径实现方法 //js webcontext var webroot=[removed].href; webroot=webroot.substring(webroot.indexOf('//')+2,webroot.length); webroot=webroot.substring(webroot.indexOf('/')+...
  • 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. }







    展开全文
  • Eclipse –如何更改Web项目上下文

    千次阅读 2020-06-02 02:42:04
    如果您在Eclipse运行或调试Web项目,则项目名称将是默认的上下文根。 例如,一个名为“ springmvc”的项目,默认上下文根为 http://localhost:8080/springmvc 测试技术: Eclipse 4.4 Eclipse Tomcat...

    如果您在Eclipse中运行或调试Web项目,则项目名称将是默认的上下文根。 例如,一个名为“ springmvc”的项目,默认上下文根为

    http://localhost:8080/springmvc

    测试技术:

    1. Eclipse 4.4
    2. Eclipse Tomcat服务器插件
    3. Maven 3
    4. Gradle 2.0

    注意
    上下文根告诉您已部署的Web应用程序的URL。

    http://localhost:8080/{context_root}

    在本教程中,我们将向您展示几种在Eclipse IDE中更新Web项目上下文根的方法。

    1. Eclipse – Web项目设置

    eclipse-context-root-solution1

    1.1右键单击项目,选择“ Properties ,“ Web Project Settings ,然后在此处更新上下文根。
    1.2从服务器中删除Web应用程序,然后将其重新添加。 上下文根应该被更新。
    1.3如果步骤2失败,则删除服务器,创建新服务器,然后重新添加Web应用程序。

    新上下文根: http:// localhost:8080 / abc

    2. Eclipse – Web模块

    eclipse-context-root-solution2

    2.1双击Eclipse服务器插件。
    2.2单击“ Modules选项卡。
    2.3更新Path
    2.4完成。 重新启动服务器。

    新上下文根: http:// localhost:8080 / abc

    3. Maven Eclipse插件

    3.1在wtpContextName定义新的上下文根。

    pom.xml
    <plugin>
    		<groupId>org.apache.maven.plugins</groupId>
    		<artifactId>maven-eclipse-plugin</artifactId>
    		<version>2.9</version>
    		<configuration>
    			<wtpversion>2.0</wtpversion>
    			<wtpContextName>abc</wtpContextName>
    		</configuration>
    	</plugin>

    3.2发出以下命令以重新创建Eclipse设置。

    $ mvn eclipse:cleanEclipse eclipse:eclipse

    4. Gradle Eclipse插件

    4.1定义蚀wtp设置。

    build.gradle
    apply plugin: 'java'
    apply plugin: 'war'
    apply plugin: 'eclipse-wtp'
     
    //For Eclipse IDE only
    eclipse {
     
      wtp {
        component {
          contextPath = 'abc'
        }
     
      }
    }

    4.2发出以下命令以重新创建Eclipse设置。

    $ gradle clenEclipse eclipse

    参考文献

    1. Gradle Eclipse插件
    2. Gradle EclipseWtpComponent示例
    3. Maven Eclipse插件

    翻译自: https://mkyong.com/eclipse/eclipse-how-to-change-web-project-context-root/

    展开全文
  • 为了解决Web数据库多查询结果问题,提出了一种基于上下文偏好的查询结果Top-<em>k排序方法。首先提出了一种带偏好程度的上下文偏好模型:<em>i</em>1 <em>i</em>2, <em>d</em> | <em>X,表示在上下文条件<em>X下,项...
  • Johnny换上Win7已经有几个月的时间,不过前几天重装了系统,依旧用的是Win7,只是今天在打开VS2009工程后在IE中测试时一打开便出现一个错误如下: 请求在此上下文中不可用 说明: 执行当前 Web 请求期间,出现未处理...
  • 之前有人在我的项目提出issue,咨询在SpringBoot的bean是不是由谁来管理的问题(SpringMvc还是Spring)来管理...在Web环境,是分为SpringMvc管理的子容器

    之前有人在我的项目中提出issue,咨询在SpringBoot中的bean是不是由谁来管理的问题(SpringMvc还是Spring)来管理(https://github.com/cmlbeliever/SpringBootLearning/issues/2

    其实一开始我也是挺懵逼的,之前没有怎么了解过这些细节,既然提出问题了,当然要找出个所以然。


    在Web环境中,是分为SpringMvc管理的子容器,和Spring管理的父容器。父子容器的关系就像类的继承一样,子容器可以获取父容器的bean,反之则是不可以的。

    如何验证是两个容器呢?
    只要在Controller与Service中实现ApplicationContextAware接口,就可已得知对应的管理容器:
    Controller中:
    这里写图片描述
    Service中:
    这里写图片描述

    那么在SpringBoot中则是同一个容器管理的(AnnotationConfigEmbeddedWebApplicationContext):
    Controller:
    这里写图片描述
    Service:
    这里写图片描述

    可以看出在boot环境中使用的是相同的容器管理的,因为AnnotationConfigEmbeddedWebApplicationContext是在包org.springframework.boot.context.embedded中的,那么就可以理解为boot容器管理bean。(当然也可以理解为Spring管理,因为AnnotationConfigEmbeddedWebApplicationContext也只是拓展WebApplicationContext)。


    由于SpringMvc的入口都是DispatcherServlet,那是什么原因造成在Web环境中有父子容器,在boot环境中只有一个容器呢?这个当然需要剖析源码咯:

    直接debug就可以了,在FrameworkServlet.initWebApplicationContext方法中初始化web上下文环境。

        protected WebApplicationContext initWebApplicationContext() {
            WebApplicationContext rootContext =
                    WebApplicationContextUtils.getWebApplicationContext(getServletContext());
            WebApplicationContext wac = null;
    //因为调用时Spring容器不是webApplicationContext类型的,所以在webApplicationContext对象时为空
            if (this.webApplicationContext != null) {
                // A context instance was injected at construction time -> use it
                wac = this.webApplicationContext;
                if (wac instanceof ConfigurableWebApplicationContext) {
                    ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
                    if (!cwac.isActive()) {
                        // The context has not yet been refreshed -> provide services such as
                        // setting the parent context, setting the application context id, etc
                        if (cwac.getParent() == null) {
                            // The context instance was injected without an explicit parent -> set
                            // the root application context (if any; may be null) as the parent
                            cwac.setParent(rootContext);
                        }
                        configureAndRefreshWebApplicationContext(cwac);
                    }
                }
            }
            if (wac == null) {
                // No context instance was injected at construction time -> see if one
                // has been registered in the servlet context. If one exists, it is assumed
                // that the parent context (if any) has already been set and that the
                // user has performed any initialization such as setting the context id
                wac = findWebApplicationContext();
            }
            //这里是重点,从这里新建SpringMvc容器
            if (wac == null) {
                // No context instance is defined for this servlet -> create a local one
                wac = createWebApplicationContext(rootContext);
            }
    
            if (!this.refreshEventReceived) {
                // Either the context is not a ConfigurableApplicationContext with refresh
                // support or the context injected at construction time had already been
                // refreshed -> trigger initial onRefresh manually here.
                onRefresh(wac);
            }
    
            if (this.publishContext) {
                // Publish the context as a servlet context attribute.
                String attrName = getServletContextAttributeName();
                getServletContext().setAttribute(attrName, wac);
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
                            "' as ServletContext attribute with name [" + attrName + "]");
                }
            }
    
            return wac;
        }
    

    当web容器文不存在时,会去创建一个新的web容器:

    protected WebApplicationContext createWebApplicationContext(ApplicationContext parent) {
            Class<?> contextClass = getContextClass();
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Servlet with name '" + getServletName() +
                        "' will try to create custom WebApplicationContext context of class '" +
                        contextClass.getName() + "'" + ", using parent context [" + parent + "]");
            }
            if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
                throw new ApplicationContextException(
                        "Fatal initialization error in servlet with name '" + getServletName() +
                        "': custom WebApplicationContext class [" + contextClass.getName() +
                        "] is not of type ConfigurableWebApplicationContext");
            }
            ConfigurableWebApplicationContext wac =
                    (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
    
            wac.setEnvironment(getEnvironment());
            //设置父容器,这里的parent即为spring上下文
            wac.setParent(parent);
            wac.setConfigLocation(getContextConfigLocation());
    
            configureAndRefreshWebApplicationContext(wac);
    
            return wac;
        }

    当web容器初始化成功后,发出ContextRefreshedEvent事件,
    DispatcherServlet接收到事件后调用initStrategies方法进行web相关的mapping和adapter设置

    protected void initStrategies(ApplicationContext context) {
            initMultipartResolver(context);
            initLocaleResolver(context);
            initThemeResolver(context);
            initHandlerMappings(context);
            initHandlerAdapters(context);
            initHandlerExceptionResolvers(context);
            initRequestToViewNameTranslator(context);
            initViewResolvers(context);
            initFlashMapManager(context);
        }

    在SpringBoot环境中,其他流程都是一致的,但是用的容器是AnnotationConfigEmbeddedWebApplicationContext而且还是WebApplicationContext子类,在FrameworkServlet.setApplicationContext时,就对webApplicationContext 进行了赋值

        public void setApplicationContext(ApplicationContext applicationContext) {
            if (this.webApplicationContext == null && applicationContext instanceof WebApplicationContext) {
                this.webApplicationContext = (WebApplicationContext) applicationContext;
                this.webApplicationContextInjected = true;
            }
        }
    

    所以在initWebApplicationContext方法初始化的时候用的就是这个全局的上下文,没有新建一个SpringMvc专用的Web上下文
    这里写图片描述


    总结:
    在Web环境中是由Spring和SpringMvc两个容器组成的,在SpringBoot环境中只有一个容器AnnotationConfigEmbeddedWebApplicationContext。也就是可以说是由SpringBoot容器管理的。


    SpringBootLearning是对springboot学习与研究项目,是根据实际项目的形式对进行配置与处理,欢迎star与fork。
    [oschina 地址]
    http://git.oschina.net/cmlbeliever/SpringBootLearning
    [github 地址]
    https://github.com/cmlbeliever/SpringBootLearning


    展开全文
  • JavaWeb获取web应用上下文地址

    千次阅读 2018-09-03 14:30:32
    import javax.servlet.ServletContext; import org.springframework.stereotype....import org.springframework.web.context.ServletContextAware; @Component public class ApplicationContext implements ...
  • 关于web应用上下文Context

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

    千次阅读 2017-08-15 15:53:14
    获取原因:在一方法类需要用到另一个变量实例,尝试多种方法均失败,故而采用获取spring上下文方法,在需要的地方从spring容器获取该Bean的方法。注:不是最好的方法,但是是管用的 public class Main ...
  • Web组件的上下文实现 产品特点 ✓小巧,快速,灵活✓无需专门的“提供者”或“消费者”元素✓能够为每个元素提供一个或多个上下文✓与lit-element和Skatejs集成✓不支持Internet Explorer 用法 警告:公共界面将来...
  • 一、先说ServletContext javaee标准规定了,servlet容器需要在应用项目启动时,给...举例: 通过自定义contextListener获取web.xml配置的参数 1.容器启动时,找到配置文件的context-param作为键值对放到Servle
  • WebLogic创建根上下文

    2013-10-23 15:50:12
    WEB-INF下面创建weblogic.xml
  • 在Spring web环境,spring 上下文和spring mvc上下文web应用上下文servletContext之间的关系,要想很好理解这三个上下文的关系,需要先熟悉spring是怎样在web容器启动起来的。spring的启动过程其实就是其IoC...
  • 上下文服务 基于上下文提供内容的 Web 服务 启动服务 php -S 0.0.0.0:8787 -t web Now open http://localhost:8787 in your brower
  • 实用Web驱动的上下文感知系统设计
  • 最近在做web项目,需要写一些工具方法,涉及到通过Java代码来获取spring配置的bean,并对该bean进行操作的情形。而最关键的一步就是获取ApplicationContext,过程纠结和错误了很久,总结一下获取...
  • 这是官方教程,我边学边汉化。适合初学者。这是第二篇。
  • 文章为Web Services提出移动环境的优化方案——基于上下文的移动Web Services。根据获得的客户端的上下文信息处理SOAP消息,得到精确的结果;上下文类型的扩展无需根据下层结构的差异进行修改。由基于上下文Web ...
  • 当使用地图作为上下文时,一个频繁使用的案例是插件或处理步骤的临时“本地”上下文,需要在一个或多个寿命较长的其他上下文(例如,跨处理步骤的整个工作流)之上分层或堆叠,或使用全局设置。 JSP将其与页面/请求...
  • 所以要用来Servlet上下文来保存,在服务器开始时,就访问数据库,将物品信息存入Servlet上下文中,这样,每个用户只用从上下文中读入物品信息就行了。 获取ServletContext的方法: HttpSession session = ...
  • 传统的Web服务推荐模型仅仅...提出了一个新的基于上下文的组合服务推荐模型,该模型不仅考虑到服务层和业务层的质量特征,而且进一步考虑了服务的上下文信息,包括用户兴趣、喜好等等,能够更好地对Web服务进行推荐。
  • web应用上下文

    千次阅读 2009-07-20 17:26:00
    关于web应用上下文Context 很多朋友都对Context不太了解,他们说"项目没看到这个对象啊""但是老是听人提起Context","经常看到ServletContext,PageContext.EJBContext, 还有Spring里面的ApplicationContext等等" ...
  • JEE从未停止让我惊奇。 即使当我认为自己处于领先地位并且我知道关于webapp的所有知识... 事实是:web应用上下文根可以包含/ characte,这意味着一个URL如http://localhost/multipart/context可以指的根multipart/co...
  • 介绍了觉察上下文计算的基本概念和上下文以及上下文服务器的定义,阐述了实现上下文服务器所需要解决的问题,介绍一个上下文服务器原型系统(Context Server for Web-based Mobile Service,CS4WMS)的系统架构、设计...
  • DDD—上下文映射图

    千次阅读 2019-11-17 16:34:22
    该框图表示了不同的限界上下文在解决方案空间是如何通过集成相互关联的。 (2)另一种更详细的方式通过限界上下文集成的源代码实现来表示。 1、上下文映射图为什么重要 在开始采用DDD时,首先应该为你当前的项目...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 308,438
精华内容 123,375
关键字:

web中上下文