Web.xml - Servlet与Filter的url-pattern

 <url-pattern>/</url-pattern>:将servlet定义为容器默认servlet，当没有其他servlet能够处理当前请求时，由该servlet进行处理。
 <url-pattern>/*</url-pattern>:会匹配所有url - 路径型的和后缀型的url(包括/login , *.jsp , *.js 和 *.html 等)

 /**
     * Return <code>true</code> if the context-relative request path
     * matches the requirements of the specified filter mapping;
     * otherwise, return <code>false</code>.
     *
     * @param filterMap Filter mapping being checked
     * @param requestPath Context-relative request path of this request
     */
    private boolean matchFiltersURL(FilterMap filterMap, String requestPath) {
        // Check the specific "*" special URL pattern, which also matches
        // named dispatches
        if (filterMap.getMatchAllUrlPatterns())
            return (true);
        if (requestPath == null)
            return (false);
        // Match on context relative request path
        String[] testPaths = filterMap.getURLPatterns();
        for (int i = 0; i < testPaths.length; i++) {
            if (matchFiltersURL(testPaths[i], requestPath)) {
                return (true);
            }
        }
        // No match
        return (false);
    }
    /**
     * Return <code>true</code> if the context-relative request path
     * matches the requirements of the specified filter mapping;
     * otherwise, return <code>false</code>.
     *
     * @param testPath URL mapping being checked
     * @param requestPath Context-relative request path of this request
     */
    private boolean matchFiltersURL(String testPath, String requestPath) {
        if (testPath == null)
            return (false);
        // Case 1 - Exact Match
        if (testPath.equals(requestPath))
            return (true);
        // Case 2 - Path Match ("/.../*")
        if (testPath.equals("/*"))
            return (true);
        if (testPath.endsWith("/*")) {
            if (testPath.regionMatches(0, requestPath, 0, 
                                       testPath.length() - 2)) {
                if (requestPath.length() == (testPath.length() - 2)) {
                    return (true);
                } else if ('/' == requestPath.charAt(testPath.length() - 2)) {
                    return (true);
                }
            }
            return (false);
        }
        // Case 3 - Extension Match
        if (testPath.startsWith("*.")) {
            int slash = requestPath.lastIndexOf('/');
            int period = requestPath.lastIndexOf('.');
            if ((slash >= 0) && (period > slash) 
                && (period != requestPath.length() - 1)
                && ((requestPath.length() - period) 
                    == (testPath.length() - 1))) {
                return (testPath.regionMatches(2, requestPath, period + 1,
                                               testPath.length() - 2));
            }
        }
        // Case 4 - "Default" Match
        return (false); // NOTE - Not relevant for selecting filters
    }

<url-pattern>/*</url-pattern>
<url-pattern>*.do</url-pattern>
<url-pattern>/emp/*</url-pattern>
第二种为扩展名映射，其他两种为路径映射。特定功能的filter可使用具体路径匹配。

<url-pattern>/</url-pattern> // 一定不可设置成该方式！
<url-pattern>/emp/</url-pattern>

Servlet1为/foo.htm,Servlet2是/* ;
请求URL为http://localhost/foo.htm;
那么只有Servlet1匹配成功;

如Servlet1为/foo/*,Servlet2为/* ;
请求的URL为:http://localhost/foo/foo.htm;
那么Servlet1匹配成功；

精确匹配>路径匹配>后缀匹配(扩展匹配)>default servlet

http://stackoverflow.com/questions/4140448/difference-between-and-in-servlet-mapping-url-pattern

The /* on a servlet overrides all other servlets, 
including all servlets provided by the servletcontainer such as the default servlet and the JSP servlet.
Whatever request you fire, it will end up in that servlet. 
This is thus a bad URL pattern for servlets.
Usually, you'd like to use /* on a Filter only. 
It is able to let the request continue to any of the servlets 
listening on a more specific URL pattern by calling FilterChain#doFilter().

The / doesn't override any other servlet. 
It only replaces the servletcontainer's builtin default servlet for all requests which doesn't match any other registered servlet. 
This is normally only invoked on static resources (CSS/JS/image/etc) and directory listings. 
The servletcontainer's builtin default servlet is also capable of dealing with HTTP cache requests,
media (audio/video) streaming and file download resumes.
Usually, you don't want to override the default servlet as you would otherwise have to take care of all its tasks, 
which is not exactly trivial (JSF utility library OmniFaces has an open source example). 
/*下面的说法我并不赞同*/
This is thus also a bad URL pattern for servlets.
As to why JSP pages doesn't hit this servlet, it's because the servletcontainer's builtin JSP servlet will be invoked, 
which is already by default mapped on the more specific URL pattern *.jsp.

Then there's also the empty string URL pattern . 
This will be invoked when the context root is requested. 
This is different from the <welcome-file> approach that it isn't invoked when any subfolder is requested.
This is most likely the URL pattern you're actually looking for in case you want a "home page servlet". 
I only have to admit that I'd intuitively expect the empty string URL pattern  
and the slash URL pattern / be defined exactly the other way round, 
so I can understand that a lot of starters got confused on this. 
But it is what it is.