StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
15825207
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
6
CommunityOwnedDate
CreationDate
2013-04-05T03:04:12.220
FavoriteCount
0
LastActivityDate
2016-05-18T15:45:41.983
LastEditDate
2017-05-23T12:02:16.157
LastEditorUserId
-1
OwnerUserId
814702
ParentId
15818047
PostTypeId
2
Score
160
ViewCount
0
LastEditorDisplayName
text
Body
<h1>TL;DR</h1> Just set the value(s) for the <code>contextConfigLocation</code> whenever you need to specify custom config files. This way you will be specifying both the config file names and their locations. The <code>namespace</code> is essentially an alternative way of telling Spring container context loader class what config file to use. I never bother with it, but just use <code>contextConfigLocation</code> whenever I need to configure custom config files. Here is an example from one of my previous Spring projects (some of the configurations omitted for the sake of brevity): web.xml <pre class="lang-xml prettyprint-override"><code><?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"> <display-name>Spring Web Application example</display-name>  <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/spring/jdbc/spring-jdbc.xml /WEB-INF/spring/security/spring-security-context.xml </param-value> </context-param>  <servlet> <servlet-name>spring-mvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/spring/mvc/spring-mvc-servlet.xml </param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>spring-mvc</servlet-name> <url-pattern>/admin/*</url-pattern> </servlet-mapping> </web-app> </code></pre> <hr> <h1>Long answer</h1> OK, first let's get some important moments clear. There are two types of contexts we are dealing with: <ol> <li>root context (parent)</li> <li>individual servlet context (child)</li> </ol> Quote from the Spring Framework API (version 3.2.2 at the moment of writing this) for the <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/javadoc-api/org/springframework/web/context/WebApplicationContext.html" rel="noreferrer">WebApplicationContext</a> (emphasis mine): <blockquote> Like generic application contexts, web application contexts are hierarchical. There is a single root context per application, while each servlet in the application (including a dispatcher servlet in the MVC framework) has its own child context. </blockquote> Also here: <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/spring-framework-reference/html/testing.html#testcontext-ctx-management-ctx-hierarchies" rel="noreferrer">Context hierarchies</a>: <blockquote> For example, if you are developing a Spring MVC web application you will typically have a root WebApplicationContext loaded via Spring's ContextLoaderListener and a child WebApplicationContext loaded via Spring's DispatcherServlet. This results in a parent-child context hierarchy where shared components and infrastructure configuration are declared in the root context and consumed in the child context by web-specific components. </blockquote> And here: <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/spring-framework-reference/html/mvc.html#mvc-servlet" rel="noreferrer">17.2 The DispatcherServlet</a>: <blockquote> ApplicationContext instances in Spring can be scoped. In the Web MVC framework, each DispatcherServlet has its own WebApplicationContext, which inherits all the beans already defined in the root WebApplicationContext. These inherited beans can be overridden in the servlet-specific scope, and you can define new scope-specific beans local to a given Servlet instance. </blockquote> Now let's see the root application context configuration. Here is an example: web.xml <pre class="lang-xml prettyprint-override"><code><?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/spring/daoContext.xml /WEB-INF/spring/applicationContext.xml </param-value> </context-param> </web-app> </code></pre> From the official Spring documentation (emphasis mine): <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/spring-framework-reference/html/beans.html#context-create" rel="noreferrer">5.14.4 Convenient ApplicationContext instantiation for web applications</a>: <blockquote> You can create ApplicationContext instances declaratively by using, for example, a ContextLoader. Of course you can also create ApplicationContext instances programmatically by using one of the ApplicationContext implementations. You can register an ApplicationContext using the ContextLoaderListener (see the example above) The listener inspects the contextConfigLocation parameter. If the parameter does not exist, the listener uses /WEB-INF/applicationContext.xml as a default. When the parameter does exist, the listener separates the String by using predefined delimiters (comma, semicolon and whitespace) and uses the values as locations where application contexts will be searched. Ant-style path patterns are supported as well. Examples are /WEB-INF/*Context.xml for all files with names ending with "Context.xml", residing in the "WEB-INF" directory, and /WEB-INF/**/*Context.xml, for all such files in any subdirectory of "WEB-INF". </blockquote> Quite often Spring configuration is split across multiple files. It's more logical and convenient, especially in the large-scale projects. In our example we explicitly defined two configuration XML files: daoContext.xml and applicationContext.xml in the custom location: <code>/WEB-INF/spring/</code>. Again, had we not defined contextConfigLocation, the ContextLoaderListener would try to locate the default config file: <code>/WEB-INF/applicationContext.xml</code>. NOTE: The root context is optional. Also see this answer: <a href="https://stackoverflow.com/a/7451389/814702">https://stackoverflow.com/a/7451389/814702</a> So if the default <code>/WEB-INF/applicationContext.xml</code> config file does not suit your needs, use ContextLoaderListener along with <code><context-param></code> contextConfigLocation where you can define custom config file(s) to define root application context. Next let's see the individual (child) application context. From the official Spring documentation (emphasis mine): <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/spring-framework-reference/html/mvc.html#mvc-servlet" rel="noreferrer">17.2 The DispatcherServlet</a> <blockquote> Upon initialization of a DispatcherServlet, Spring MVC looks for a file named [servlet-name]-servlet.xml in the WEB-INF directory of your web application and creates the beans defined there, overriding the definitions of any beans defined with the same name in the global scope. Consider the following DispatcherServlet Servlet configuration (in the web.xml file): </blockquote> <pre class="lang-xml prettyprint-override"><code><web-app> <servlet> <servlet-name>golfing</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>golfing</servlet-name> <url-pattern>/golfing/*</url-pattern> </servlet-mapping> </web-app> </code></pre> <h2>About contextConfigLocation and namespace</h2> From the documentation (emphasis mine): <blockquote> With the above Servlet configuration in place, you will need to have a file called <code>/WEB-INF/golfing-servlet.xml</code> in your application; this file will contain all of your Spring Web MVC-specific components (beans). You can change the exact location of this configuration file through a Servlet initialization parameter (see below for details). ... You can customize individual DispatcherServlet instances by adding Servlet initialization parameters (init-param elements) to the Servlet declaration in the web.xml file. See the following table for the list of supported parameters. <ul> <li>contextClass: Class that implements WebApplicationContext, which instantiates the context used by this Servlet. By default, the XmlWebApplicationContext is used.</li> <li>contextConfigLocation: String that is passed to the context instance (specified by contextClass) to indicate where context(s) can be found. The string consists potentially of multiple strings (using a comma as a delimiter) to support multiple contexts. In case of multiple context locations with beans that are defined twice, the latest location takes precedence.</li> <li>namespace: Namespace of the WebApplicationContext. Defaults to [servlet-name]-servlet.</li> </ul> </blockquote> Now let's research the API documentation for the related classes. The class <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/javadoc-api/org/springframework/web/servlet/DispatcherServlet.html" rel="noreferrer">DispatcherServlet</a> extends abstract class <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/javadoc-api/org/springframework/web/servlet/FrameworkServlet.html" rel="noreferrer">FrameworkServlet</a>. From the FrameworkServlet API docs (emphasis mine): <blockquote> Passes a "contextConfigLocation" servlet init-param to the context instance, parsing it into potentially multiple file paths which can be separated by any number of commas and spaces, like "test-servlet.xml, myServlet.xml". If not explicitly specified, the context implementation is supposed to build a default location from the namespace of the servlet. The default namespace is "'servlet-name'-servlet", e.g. "test-servlet" for a servlet-name "test" (leading to a "/WEB-INF/test-servlet.xml" default location with XmlWebApplicationContext). The namespace can also be set explicitly via the "namespace" servlet init-param. </blockquote> This is the excerpt from the FrameworkServlet source code: <a href="http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.web.servlet/3.2.2/org/springframework/web/servlet/FrameworkServlet.java#FrameworkServlet" rel="noreferrer">FrameworkServlet.java</a> <pre class="lang-java prettyprint-override"><code>.... /** * Suffix for WebApplicationContext namespaces. If a servlet of this class is * given the name "test" in a context, the namespace used by the servlet will * resolve to "test-servlet". */ public static final String DEFAULT_NAMESPACE_SUFFIX = "-servlet"; .... </code></pre> The default context class for FrameworkServlet is <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/javadoc-api/org/springframework/web/context/support/XmlWebApplicationContext.html" rel="noreferrer">XmlWebApplicationContext</a>. From the XmlWebApplicationContext API docs (emphasis mine): <blockquote> By default, the configuration will be taken from "/WEB-INF/applicationContext.xml" for the root context, and "/WEB-INF/test-servlet.xml" for a context with the namespace "test-servlet" (like for a DispatcherServlet instance with the servlet-name "test"). The config location defaults can be overridden via the "contextConfigLocation" context-param of ContextLoader and servlet init-param of FrameworkServlet. Config locations can either denote concrete files like "/WEB-INF/context.xml" or Ant-style patterns like "/WEB-INF/*-context.xml" (see PathMatcher javadoc for pattern details). </blockquote> Overriding default config locations using <code>contextConfigLocation</code> is the same as in the above example for the root application context. As for the overriding the default namespace there are some important moments. When you set a new namespace, don't prepend it with <code>/WEB-INF</code> and don't append <code>.xml</code> to it. The reason for that can be discovered if we look in the source file for the XmlWebApplicationContext class: <a href="http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.web/3.2.2/org/springframework/web/context/support/XmlWebApplicationContext.java#XmlWebApplicationContext" rel="noreferrer">XmlWebApplicationContext.java</a> <pre class="lang-java prettyprint-override"><code>... /** Default config location for the root context */ public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml"; /** Default prefix for building a config location for a namespace */ public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/"; /** Default suffix for building a config location for a namespace */ public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml"; ... /** * The default location for the root context is "/WEB-INF/applicationContext.xml", * and "/WEB-INF/test-servlet.xml" for a context with the namespace "test-servlet" * (like for a DispatcherServlet instance with the servlet-name "test"). */ @Override protected String[] getDefaultConfigLocations() { if (getNamespace() != null) { return new String[] {DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX}; } else { return new String[] {DEFAULT_CONFIG_LOCATION}; } } </code></pre> As you can see, the source code says it all. <h2>Example of specifying custom namespace</h2> web.xml <pre class="lang-xml prettyprint-override"><code><?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">  <servlet> <servlet-name>spring-mvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>namespace</param-name> <param-value>spring/mvc/spring-mvc</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>spring-mvc</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> </web-app> </code></pre> The result is that, instead of using the default namespace for constructing the path to the config file, that would otherwise be <code>/WEB-INF/spring-mvc-servlet.xml</code>, the container will look for <code>/WEB-INF/spring/mvc/spring-mvc.xml</code>. NOTE: The above explanations related to the setting custom namespace are for the default <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/javadoc-api/org/springframework/web/context/support/XmlWebApplicationContext.html" rel="noreferrer">XmlWebApplicationContext</a> context class. One can specify an alternative class, like <a href="http://docs.spring.io/spring/docs/3.2.2.RELEASE/javadoc-api/org/springframework/web/context/support/AnnotationConfigWebApplicationContext.html" rel="noreferrer">AnnotationConfigWebApplicationContext</a>, so there will be some special moments for that. <hr> <h2>CONCLUSION</h2> It is (IMHO) much more easier to use <code>contextConfigLocation</code> parameter to define custom config files, both for the root application context and for the individual contexts. The only difference is that for the root application context you use <code><context-param></code> within <code><web-app></code> element, but NOT within a specific servlet (also don't forget the listener class). And for the child context you use <code><init-param></code> nested inside the <code><servlet></code> element for each specific servlet. See my example configurations (web.xml) in the very beginning of this post. Additional sources (as if the above was not enough :-)): <ul> <li><a href="http://docs.spring.io/spring/docs/current/spring-framework-reference/html/" rel="noreferrer">Spring Framework Reference Documentation</a></li> <li><a href="http://www.jroller.com/latenightdev/entry/spring_mvc_context_loading" rel="noreferrer">Spring MVC Context Loading</a> </li> </ul> Also see these answers: <ul> <li><a href="https://stackoverflow.com/a/3652125/814702">Difference between applicationContext.xml and spring-servlet.xml in Spring</a></li> <li><a href="https://stackoverflow.com/a/11709272/814702">What is the difference between ApplicationContext and WebApplicationContext in Spring MVC?</a></li> <li><a href="https://stackoverflow.com/a/7451389/814702">Spring-MVC: What are a “context” and “namespace”?</a></li> </ul>
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POSpring: namespace vs contextConfigLocation init parameters in web.xml
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USCommunity
UserOwnerUserId
1. USinformatik01
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POSpring: namespace vs contextConfigLocation init parameters in web.xml
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTAcceptedByOriginator
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. COAwesome, thank you very much!:)
 singulars
 PostPostId
 PO
 UserUserId
 USLuckyLuke
2. CO@LuckyLuke You are welcome!
 singulars
 PostPostId
 PO
 UserUserId
 USinformatik01

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.