diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.java
index abef0a7ff7e..16a333c2435 100644
--- a/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.java
+++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 package org.springframework.web.servlet.handler;
 
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Properties;
 
@@ -41,11 +41,10 @@ import org.springframework.util.CollectionUtils;
  * If the path doesn't begin with a slash, one is prepended.
  *
  * <p>Supports direct matches (given "/test" -> registered "/test") and "*"
- * matches (given "/test" -> registered "/t*"). Note that the default is
- * to map within the current servlet mapping if applicable; see the
- * {@link #setAlwaysUseFullPath "alwaysUseFullPath"} property for details.
- * For details on the pattern options, see the
- * {@link org.springframework.util.AntPathMatcher} javadoc.
+ * pattern matches (given "/test" -> registered "/t*"). Note that the default
+ * is to map within the current servlet mapping if applicable; see the
+ * {@link #setAlwaysUseFullPath "alwaysUseFullPath"} property. For details on the
+ * pattern options, see the {@link org.springframework.util.AntPathMatcher} javadoc.
 
  * @author Rod Johnson
  * @author Juergen Hoeller
@@ -55,7 +54,7 @@ import org.springframework.util.CollectionUtils;
  */
 public class SimpleUrlHandlerMapping extends AbstractUrlHandlerMapping {
 
-	private final Map<String, Object> urlMap = new HashMap<String, Object>();
+	private final Map<String, Object> urlMap = new LinkedHashMap<String, Object>();
 
 
 	/**
diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/ResourceUrlProvider.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/ResourceUrlProvider.java
index dcd29275675..a79000d881c 100644
--- a/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/ResourceUrlProvider.java
+++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/ResourceUrlProvider.java
@@ -19,7 +19,7 @@ package org.springframework.web.servlet.resource;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import javax.servlet.http.HttpServletRequest;
@@ -55,7 +55,7 @@ public class ResourceUrlProvider implements ApplicationListener<ContextRefreshed
 
 	private PathMatcher pathMatcher = new AntPathMatcher();
 
-	private final Map<String, ResourceHttpRequestHandler> handlerMap = new HashMap<String, ResourceHttpRequestHandler>();
+	private final Map<String, ResourceHttpRequestHandler> handlerMap = new LinkedHashMap<String, ResourceHttpRequestHandler>();
 
 	private boolean autodetect = true;
 
@@ -165,17 +165,17 @@ public class ResourceUrlProvider implements ApplicationListener<ContextRefreshed
 	 * URL path to expose for public use.
 	 * @param request the current request
 	 * @param requestUrl the request URL path to resolve
-	 * @return the resolved public URL path or {@code null} if unresolved
+	 * @return the resolved public URL path, or {@code null} if unresolved
 	 */
 	public final String getForRequestUrl(HttpServletRequest request, String requestUrl) {
 		if (logger.isTraceEnabled()) {
-			logger.trace("Getting resource URL for requestURL=" + requestUrl);
+			logger.trace("Getting resource URL for request URL \"" + requestUrl + "\"");
 		}
 		int index = getLookupPathIndex(request);
 		String prefix = requestUrl.substring(0, index);
 		String lookupPath = requestUrl.substring(index);
 		String resolvedLookupPath = getForLookupPath(lookupPath);
-		return (resolvedLookupPath != null) ? prefix + resolvedLookupPath : null;
+		return (resolvedLookupPath != null ? prefix + resolvedLookupPath : null);
 	}
 
 	private int getLookupPathIndex(HttpServletRequest request) {
@@ -198,14 +198,16 @@ public class ResourceUrlProvider implements ApplicationListener<ContextRefreshed
 	 */
 	public final String getForLookupPath(String lookupPath) {
 		if (logger.isTraceEnabled()) {
-			logger.trace("Getting resource URL for lookupPath=" + lookupPath);
+			logger.trace("Getting resource URL for lookup path \"" + lookupPath + "\"");
 		}
+
 		List<String> matchingPatterns = new ArrayList<String>();
 		for (String pattern : this.handlerMap.keySet()) {
 			if (getPathMatcher().match(pattern, lookupPath)) {
 				matchingPatterns.add(pattern);
 			}
 		}
+
 		if (!matchingPatterns.isEmpty()) {
 			Comparator<String> patternComparator = getPathMatcher().getPatternComparator(lookupPath);
 			Collections.sort(matchingPatterns, patternComparator);
@@ -213,7 +215,7 @@ public class ResourceUrlProvider implements ApplicationListener<ContextRefreshed
 				String pathWithinMapping = getPathMatcher().extractPathWithinPattern(pattern, lookupPath);
 				String pathMapping = lookupPath.substring(0, lookupPath.indexOf(pathWithinMapping));
 				if (logger.isTraceEnabled()) {
-					logger.trace("Invoking ResourceResolverChain for URL pattern=\"" + pattern + "\"");
+					logger.trace("Invoking ResourceResolverChain for URL pattern \"" + pattern + "\"");
 				}
 				ResourceHttpRequestHandler handler = this.handlerMap.get(pattern);
 				ResourceResolverChain chain = new DefaultResourceResolverChain(handler.getResourceResolvers());
@@ -222,12 +224,15 @@ public class ResourceUrlProvider implements ApplicationListener<ContextRefreshed
 					continue;
 				}
 				if (logger.isTraceEnabled()) {
-					logger.trace("Resolved public resource URL path=\"" + resolved + "\"");
+					logger.trace("Resolved public resource URL path \"" + resolved + "\"");
 				}
 				return pathMapping + resolved;
 			}
 		}
-		logger.debug("No matching resource mapping");
+
+		if (logger.isDebugEnabled()) {
+			logger.debug("No matching resource mapping for lookup path \"" + lookupPath + "\"");
+		}
 		return null;
 	}
 
diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/VersionResourceResolver.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/VersionResourceResolver.java
index 6a102287d38..45f831bfb3e 100644
--- a/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/VersionResourceResolver.java
+++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/VersionResourceResolver.java
@@ -19,7 +19,7 @@ package org.springframework.web.servlet.resource;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import javax.servlet.http.HttpServletRequest;
@@ -58,7 +58,7 @@ public class VersionResourceResolver extends AbstractResourceResolver {
 	private AntPathMatcher pathMatcher = new AntPathMatcher();
 
 	/** Map from path pattern -> VersionStrategy */
-	private final Map<String, VersionStrategy> versionStrategyMap = new HashMap<String, VersionStrategy>();
+	private final Map<String, VersionStrategy> versionStrategyMap = new LinkedHashMap<String, VersionStrategy>();
 
 
 	/**
@@ -146,14 +146,14 @@ public class VersionResourceResolver extends AbstractResourceResolver {
 		String candidateVersion = versionStrategy.extractVersion(requestPath);
 		if (StringUtils.isEmpty(candidateVersion)) {
 			if (logger.isTraceEnabled()) {
-				logger.trace("No version found in path=\"" + requestPath + "\"");
+				logger.trace("No version found in path \"" + requestPath + "\"");
 			}
 			return null;
 		}
 
 		String simplePath = versionStrategy.removeVersion(requestPath, candidateVersion);
 		if (logger.isTraceEnabled()) {
-			logger.trace("Extracted version from path, re-resolving without version, path=\"" + simplePath + "\"");
+			logger.trace("Extracted version from path, re-resolving without version: \"" + simplePath + "\"");
 		}
 
 		Resource baseResource = chain.resolveResource(request, simplePath, locations);
@@ -164,14 +164,14 @@ public class VersionResourceResolver extends AbstractResourceResolver {
 		String actualVersion = versionStrategy.getResourceVersion(baseResource);
 		if (candidateVersion.equals(actualVersion)) {
 			if (logger.isTraceEnabled()) {
-				logger.trace("resource matches extracted version");
+				logger.trace("Resource matches extracted version ["+ candidateVersion + "]");
 			}
 			return baseResource;
 		}
 		else {
 			if (logger.isTraceEnabled()) {
-				logger.trace("Potential resource found for [" + requestPath + "], but version [" +
-						candidateVersion + "] doesn't match.");
+				logger.trace("Potential resource found for \"" + requestPath + "\", but version [" +
+						candidateVersion + "] does not match");
 			}
 			return null;
 		}
@@ -186,12 +186,12 @@ public class VersionResourceResolver extends AbstractResourceResolver {
 				return null;
 			}
 			if (logger.isTraceEnabled()) {
-				logger.trace("Getting the original resource to determine version");
+				logger.trace("Getting the original resource to determine version for path \"" + resourceUrlPath + "\"");
 			}
 			Resource resource = chain.resolveResource(null, baseUrl, locations);
 			String version = versionStrategy.getResourceVersion(resource);
 			if (logger.isTraceEnabled()) {
-				logger.trace("Version=" + version);
+				logger.trace("Determined version [" + version + "] for " + resource);
 			}
 			return versionStrategy.addVersion(baseUrl, version);
 		}
@@ -204,17 +204,17 @@ public class VersionResourceResolver extends AbstractResourceResolver {
 	 */
 	protected VersionStrategy getStrategyForPath(String requestPath) {
 		String path = "/".concat(requestPath);
-        List<String> matchingPatterns = new ArrayList<String>();
+		List<String> matchingPatterns = new ArrayList<String>();
 		for (String pattern : this.versionStrategyMap.keySet()) {
 			if (this.pathMatcher.match(pattern, path)) {
-                matchingPatterns.add(pattern);
+				matchingPatterns.add(pattern);
 			}
 		}
-        if (!matchingPatterns.isEmpty()) {
-            Comparator<String> comparator = this.pathMatcher.getPatternComparator(path);
-            Collections.sort(matchingPatterns, comparator);
-            return this.versionStrategyMap.get(matchingPatterns.get(0));
-        }
+		if (!matchingPatterns.isEmpty()) {
+			Comparator<String> comparator = this.pathMatcher.getPatternComparator(path);
+			Collections.sort(matchingPatterns, comparator);
+			return this.versionStrategyMap.get(matchingPatterns.get(0));
+		}
 		return null;
 	}