From d9f4016c35e0a12fe6ee1b9aec0b9fe7d7de2242 Mon Sep 17 00:00:00 2001 From: Brian Clozel Date: Fri, 29 Aug 2014 15:36:51 +0200 Subject: [PATCH] Update resource handler XML Namespace This change introduces a new tag that mirrors the ResourceChainRegistration java config counterpart. Resolvers and Transformers can be registered with bean/ref tags, and specific tags have been created for and in order to make common configurations easier. Note that a specific "auto-configuration" attribute on the resource-chain allows to completely disable default registration of Resolvers and Transformers (sane defaults considered by the Framework). This also fixes a typo in the class name of AppCacheManifestResourceTransfo*r*mer. Issue: SPR-12129 --- .../config/ResourcesBeanDefinitionParser.java | 175 +++++++++++++++--- ....java => AppCacheManifestTransformer.java} | 8 +- .../web/servlet/config/spring-mvc-4.1.xsd | 91 ++++++++- .../web/servlet/config/MvcNamespaceTests.java | 64 ++++++- .../ResourceHandlerRegistryTests.java | 8 +- .../AppCacheManifestTransformerTests.java | 6 +- .../mvc-config-resources-chain-no-auto.xml | 34 ++++ .../config/mvc-config-resources-chain.xml | 42 +++++ ...onfig-resources-resolvers-transformers.xml | 26 --- 9 files changed, 386 insertions(+), 68 deletions(-) rename spring-webmvc/src/main/java/org/springframework/web/servlet/resource/{AppCacheManifestTransfomer.java => AppCacheManifestTransformer.java} (97%) create mode 100644 spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain-no-auto.xml create mode 100644 spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain.xml delete mode 100644 spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-resolvers-transformers.xml diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/config/ResourcesBeanDefinitionParser.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/config/ResourcesBeanDefinitionParser.java index a916651afb..a3d377bc5d 100644 --- a/spring-webmvc/src/main/java/org/springframework/web/servlet/config/ResourcesBeanDefinitionParser.java +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/config/ResourcesBeanDefinitionParser.java @@ -22,6 +22,7 @@ import java.util.Map; import org.w3c.dom.Element; import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.config.ConstructorArgumentValues; import org.springframework.beans.factory.config.RuntimeBeanReference; import org.springframework.beans.factory.parsing.BeanComponentDefinition; import org.springframework.beans.factory.support.ManagedList; @@ -29,25 +30,43 @@ import org.springframework.beans.factory.support.ManagedMap; import org.springframework.beans.factory.support.RootBeanDefinition; import org.springframework.beans.factory.xml.BeanDefinitionParser; import org.springframework.beans.factory.xml.ParserContext; +import org.springframework.cache.concurrent.ConcurrentMapCache; import org.springframework.core.Ordered; import org.springframework.util.StringUtils; import org.springframework.util.xml.DomUtils; import org.springframework.web.servlet.handler.SimpleUrlHandlerMapping; import org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter; +import org.springframework.web.servlet.resource.CachingResourceResolver; +import org.springframework.web.servlet.resource.CachingResourceTransformer; +import org.springframework.web.servlet.resource.ContentVersionStrategy; +import org.springframework.web.servlet.resource.CssLinkResourceTransformer; +import org.springframework.web.servlet.resource.FixedVersionStrategy; +import org.springframework.web.servlet.resource.PathResourceResolver; import org.springframework.web.servlet.resource.ResourceHttpRequestHandler; +import org.springframework.web.servlet.resource.ResourceResolver; +import org.springframework.web.servlet.resource.ResourceTransformer; +import org.springframework.web.servlet.resource.VersionResourceResolver; /** * {@link org.springframework.beans.factory.xml.BeanDefinitionParser} that parses a - * {@code resources} element to register a {@link ResourceHttpRequestHandler}. - * Will also register a {@link SimpleUrlHandlerMapping} for mapping resource requests, + * {@code resources} element to register a {@link ResourceHttpRequestHandler} and + * register a {@link SimpleUrlHandlerMapping} for mapping resource requests, * and a {@link HttpRequestHandlerAdapter}. + * Will also create a resource handling chain with {@link ResourceResolver}s and {@link ResourceTransformer}s. * * @author Keith Donald * @author Jeremy Grelle + * @author Brian Clozel * @since 3.0.4 */ class ResourcesBeanDefinitionParser implements BeanDefinitionParser { + private static final String RESOURCE_CHAIN_CACHE = "spring-resource-chain-cache"; + private static final String VERSION_RESOLVER_ELEMENT = "version-resolver"; + private static final String VERSION_STRATEGY_ELEMENT = "version-strategy"; + private static final String FIXED_VERSION_STRATEGY_ELEMENT = "fixed-version-strategy"; + private static final String CONTENT_VERSION_STRATEGY_ELEMENT = "content-version-strategy"; + @Override public BeanDefinition parse(Element element, ParserContext parserContext) { Object source = parserContext.extractSource(element); @@ -109,14 +128,9 @@ class ResourcesBeanDefinitionParser implements BeanDefinitionParser { resourceHandlerDef.getPropertyValues().add("cacheSeconds", cacheSeconds); } - ManagedList resourceResolvers = parseResourceResolvers(parserContext, element, source); - if (!resourceResolvers.isEmpty()) { - resourceHandlerDef.getPropertyValues().add("resourceResolvers", resourceResolvers); - } - - ManagedList resourceTransformers = parseResourceTransformers(parserContext, element, source); - if (!resourceTransformers.isEmpty()) { - resourceHandlerDef.getPropertyValues().add("resourceTransformers", resourceTransformers); + Element resourceChainElement = DomUtils.getChildElementByTagName(element, "resource-chain"); + if(resourceChainElement != null) { + parseResourceChain(resourceHandlerDef, parserContext, resourceChainElement, source); } String beanName = parserContext.getReaderContext().generateBeanName(resourceHandlerDef); @@ -125,30 +139,145 @@ class ResourcesBeanDefinitionParser implements BeanDefinitionParser { return beanName; } - private ManagedList parseResourceResolvers(ParserContext parserContext, Element element, Object source) { - Element resolversElement = DomUtils.getChildElementByTagName(element, "resolvers"); + + private void parseResourceChain(RootBeanDefinition resourceHandlerDef, ParserContext parserContext, + Element element, Object source) { + + String autoRegistration = element.getAttribute("auto-registration"); + boolean isAutoRegistration = !(StringUtils.hasText(autoRegistration) && "false".equals(autoRegistration)); + ManagedList resourceResolvers = new ManagedList(); - if (resolversElement != null) { - resourceResolvers.setSource(source); - for (Element beanElement : DomUtils.getChildElementsByTagName(resolversElement, "bean", "ref")) { - Object object = parserContext.getDelegate().parsePropertySubElement(beanElement, null); - resourceResolvers.add(object); - } + resourceResolvers.setSource(source); + ManagedList resourceTransformers = new ManagedList(); + resourceTransformers.setSource(source); + + parseResourceCache(resourceResolvers, resourceTransformers, element, source); + parseResourceResolversTransformers(isAutoRegistration, resourceResolvers + , resourceTransformers, parserContext, element, source); + + if (!resourceResolvers.isEmpty()) { + resourceHandlerDef.getPropertyValues().add("resourceResolvers", resourceResolvers); + } + if (!resourceTransformers.isEmpty()) { + resourceHandlerDef.getPropertyValues().add("resourceTransformers", resourceTransformers); } - return resourceResolvers; } - private ManagedList parseResourceTransformers(ParserContext parserContext, Element element, Object source) { + private void parseResourceCache(ManagedList resourceResolvers, + ManagedList resourceTransformers, + Element element, Object source) { + + Element resourceCacheElement = DomUtils.getChildElementByTagName(element, "resource-cache"); + if(resourceCacheElement != null) { + ConstructorArgumentValues cavs = new ConstructorArgumentValues(); + + RootBeanDefinition cachingResolverDef = new RootBeanDefinition(CachingResourceResolver.class); + cachingResolverDef.setSource(source); + cachingResolverDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + cachingResolverDef.setConstructorArgumentValues(cavs); + + RootBeanDefinition cachingTransformerDef = new RootBeanDefinition(CachingResourceTransformer.class); + cachingTransformerDef.setSource(source); + cachingTransformerDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + cachingTransformerDef.setConstructorArgumentValues(cavs); + + String cacheBeanName = resourceCacheElement.getAttribute("cache"); + if (StringUtils.hasText(cacheBeanName)) { + RuntimeBeanReference cacheRef = new RuntimeBeanReference(cacheBeanName); + cavs.addIndexedArgumentValue(0, cacheRef); + } + else { + ConstructorArgumentValues cacheCavs = new ConstructorArgumentValues(); + cacheCavs.addIndexedArgumentValue(0, RESOURCE_CHAIN_CACHE); + + RootBeanDefinition cacheDef = new RootBeanDefinition(ConcurrentMapCache.class); + cacheDef.setSource(source); + cacheDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + cacheDef.setConstructorArgumentValues(cacheCavs); + cavs.addIndexedArgumentValue(0, cacheDef); + } + resourceResolvers.add(cachingResolverDef); + resourceTransformers.add(cachingTransformerDef); + } + } + + + private void parseResourceResolversTransformers(boolean isAutoRegistration, + ManagedList resourceResolvers, ManagedList resourceTransformers, + ParserContext parserContext, Element element, Object source) { + + Element resolversElement = DomUtils.getChildElementByTagName(element, "resolvers"); + if (resolversElement != null) { + for (Element beanElement : DomUtils.getChildElements(resolversElement)) { + if(VERSION_RESOLVER_ELEMENT.equals(beanElement.getLocalName())) { + RootBeanDefinition versionResolverDef = parseVersionResolver(parserContext, beanElement, source); + versionResolverDef.setSource(source); + resourceResolvers.add(versionResolverDef); + + if(isAutoRegistration) { + RootBeanDefinition cssLinkTransformerDef = new RootBeanDefinition(CssLinkResourceTransformer.class); + cssLinkTransformerDef.setSource(source); + cssLinkTransformerDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + resourceTransformers.add(cssLinkTransformerDef); + } + } else { + Object object = parserContext.getDelegate().parsePropertySubElement(beanElement, null); + resourceResolvers.add(object); + } + } + } + + if(isAutoRegistration) { + RootBeanDefinition pathResolverDef = new RootBeanDefinition(PathResourceResolver.class); + pathResolverDef.setSource(source); + pathResolverDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + resourceResolvers.add(pathResolverDef); + } + Element transformersElement = DomUtils.getChildElementByTagName(element, "transformers"); - ManagedList resourceTransformers = new ManagedList(); if (transformersElement != null) { - resourceTransformers.setSource(source); for (Element beanElement : DomUtils.getChildElementsByTagName(transformersElement, "bean", "ref")) { Object object = parserContext.getDelegate().parsePropertySubElement(beanElement, null); resourceTransformers.add(object); } } - return resourceTransformers; } + private RootBeanDefinition parseVersionResolver(ParserContext parserContext, Element element, Object source) { + ManagedMap strategyMap = new ManagedMap(); + strategyMap.setSource(source); + RootBeanDefinition versionResolverDef = new RootBeanDefinition(VersionResourceResolver.class); + versionResolverDef.setSource(source); + versionResolverDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + versionResolverDef.getPropertyValues().addPropertyValue("strategyMap", strategyMap); + + for (Element beanElement : DomUtils.getChildElements(element)) { + String[] patterns = StringUtils.commaDelimitedListToStringArray(beanElement.getAttribute("patterns")); + Object strategy = null; + if(FIXED_VERSION_STRATEGY_ELEMENT.equals(beanElement.getLocalName())) { + ConstructorArgumentValues cavs = new ConstructorArgumentValues(); + cavs.addIndexedArgumentValue(0, beanElement.getAttribute("version")); + RootBeanDefinition strategyDef = new RootBeanDefinition(FixedVersionStrategy.class); + strategyDef.setSource(source); + strategyDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + strategyDef.setConstructorArgumentValues(cavs); + strategy = strategyDef; + } + else if (CONTENT_VERSION_STRATEGY_ELEMENT.equals(beanElement.getLocalName())) { + RootBeanDefinition strategyDef = new RootBeanDefinition(ContentVersionStrategy.class); + strategyDef.setSource(source); + strategyDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); + strategy = strategyDef; + } + else if (VERSION_STRATEGY_ELEMENT.equals(beanElement.getLocalName())) { + Element childElement = DomUtils.getChildElementsByTagName(beanElement, "bean", "ref").get(0); + strategy = parserContext.getDelegate().parsePropertySubElement(childElement, null); + } + for(String pattern : patterns) { + strategyMap.put(pattern, strategy); + } + } + + return versionResolverDef; + } } diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/AppCacheManifestTransfomer.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/AppCacheManifestTransformer.java similarity index 97% rename from spring-webmvc/src/main/java/org/springframework/web/servlet/resource/AppCacheManifestTransfomer.java rename to spring-webmvc/src/main/java/org/springframework/web/servlet/resource/AppCacheManifestTransformer.java index 5284420662..da6634fd86 100644 --- a/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/AppCacheManifestTransfomer.java +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/resource/AppCacheManifestTransformer.java @@ -58,13 +58,13 @@ import org.springframework.util.StringUtils; * applications spec * @since 4.1 */ -public class AppCacheManifestTransfomer implements ResourceTransformer { +public class AppCacheManifestTransformer implements ResourceTransformer { private static final String MANIFEST_HEADER = "CACHE MANIFEST"; private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8"); - private static final Log logger = LogFactory.getLog(AppCacheManifestTransfomer.class); + private static final Log logger = LogFactory.getLog(AppCacheManifestTransformer.class); private final Map sectionTransformers = new HashMap(); @@ -74,7 +74,7 @@ public class AppCacheManifestTransfomer implements ResourceTransformer { /** * Create an AppCacheResourceTransformer that transforms files with extension ".manifest" */ - public AppCacheManifestTransfomer() { + public AppCacheManifestTransformer() { this("manifest"); } @@ -82,7 +82,7 @@ public class AppCacheManifestTransfomer implements ResourceTransformer { * Create an AppCacheResourceTransformer that transforms files with the extension * given as a parameter. */ - public AppCacheManifestTransfomer(String fileExtension) { + public AppCacheManifestTransformer(String fileExtension) { this.fileExtension = fileExtension; SectionTransformer noOpSection = new NoOpSection(); diff --git a/spring-webmvc/src/main/resources/org/springframework/web/servlet/config/spring-mvc-4.1.xsd b/spring-webmvc/src/main/resources/org/springframework/web/servlet/config/spring-mvc-4.1.xsd index 5332453ac1..8c9f43155a 100644 --- a/spring-webmvc/src/main/resources/org/springframework/web/servlet/config/spring-mvc-4.1.xsd +++ b/spring-webmvc/src/main/resources/org/springframework/web/servlet/config/spring-mvc-4.1.xsd @@ -338,6 +338,77 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/config/MvcNamespaceTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/config/MvcNamespaceTests.java index 742367ef92..5975bc3ffb 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/config/MvcNamespaceTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/config/MvcNamespaceTests.java @@ -16,6 +16,8 @@ package org.springframework.web.servlet.config; +import static org.junit.Assert.*; + import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.reflect.Method; @@ -30,6 +32,7 @@ import org.junit.Test; import org.springframework.beans.DirectFieldAccessor; import org.springframework.beans.TypeMismatchException; import org.springframework.beans.factory.xml.XmlBeanDefinitionReader; +import org.springframework.cache.concurrent.ConcurrentMapCache; import org.springframework.context.i18n.LocaleContextHolder; import org.springframework.core.Ordered; import org.springframework.core.convert.ConversionService; @@ -76,14 +79,19 @@ import org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter; import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter; import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; import org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder; +import org.springframework.web.servlet.resource.AppCacheManifestTransformer; +import org.springframework.web.servlet.resource.CachingResourceResolver; import org.springframework.web.servlet.resource.CachingResourceTransformer; +import org.springframework.web.servlet.resource.ContentVersionStrategy; import org.springframework.web.servlet.resource.CssLinkResourceTransformer; import org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler; +import org.springframework.web.servlet.resource.FixedVersionStrategy; import org.springframework.web.servlet.resource.GzipResourceResolver; import org.springframework.web.servlet.resource.PathResourceResolver; import org.springframework.web.servlet.resource.ResourceHttpRequestHandler; import org.springframework.web.servlet.resource.ResourceResolver; import org.springframework.web.servlet.resource.ResourceTransformer; +import org.springframework.web.servlet.resource.VersionResourceResolver; import org.springframework.web.servlet.theme.ThemeChangeInterceptor; import org.springframework.web.servlet.view.groovy.GroovyMarkupConfigurer; import org.springframework.web.servlet.view.groovy.GroovyMarkupViewResolver; @@ -96,8 +104,6 @@ import org.springframework.web.servlet.view.tiles3.TilesViewResolver; import org.springframework.web.servlet.view.velocity.VelocityConfigurer; import org.springframework.web.servlet.view.velocity.VelocityViewResolver; -import static org.junit.Assert.*; - /** * Tests loading actual MVC namespace configuration. * @@ -328,7 +334,7 @@ public class MvcNamespaceTests { @Test public void testResourcesWithResolversTransformers() throws Exception { - loadBeanDefinitions("mvc-config-resources-resolvers-transformers.xml", 10); + loadBeanDefinitions("mvc-config-resources-chain.xml", 8); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); @@ -338,14 +344,54 @@ public class MvcNamespaceTests { assertNotNull(handler); List resolvers = handler.getResourceResolvers(); - assertThat(resolvers, Matchers.hasSize(2)); - assertThat(resolvers.get(0), Matchers.instanceOf(PathResourceResolver.class)); + assertThat(resolvers, Matchers.hasSize(3)); + assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class)); + assertThat(resolvers.get(1), Matchers.instanceOf(VersionResourceResolver.class)); + assertThat(resolvers.get(2), Matchers.instanceOf(PathResourceResolver.class)); + + CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0); + assertThat(cachingResolver.getCache(), Matchers.instanceOf(TestResourceCache.class)); + + VersionResourceResolver versionResolver = (VersionResourceResolver) resolvers.get(1); + assertThat(versionResolver.getStrategyMap().get("/**/*.js"), + Matchers.instanceOf(FixedVersionStrategy.class)); + assertThat(versionResolver.getStrategyMap().get("/**"), + Matchers.instanceOf(ContentVersionStrategy.class)); + + List transformers = handler.getResourceTransformers(); + assertThat(transformers, Matchers.hasSize(3)); + assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); + assertThat(transformers.get(1), Matchers.instanceOf(CssLinkResourceTransformer.class)); + assertThat(transformers.get(2), Matchers.instanceOf(AppCacheManifestTransformer.class)); + } + + @Test + public void testResourcesWithResolversTransformersCustom() throws Exception { + loadBeanDefinitions("mvc-config-resources-chain-no-auto.xml", 9); + + SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); + assertNotNull(mapping); + assertNotNull(mapping.getUrlMap().get("/resources/**")); + ResourceHttpRequestHandler handler = appContext.getBean((String)mapping.getUrlMap().get("/resources/**"), + ResourceHttpRequestHandler.class); + assertNotNull(handler); + + List resolvers = handler.getResourceResolvers(); + assertThat(resolvers, Matchers.hasSize(3)); + assertThat(resolvers.get(0), Matchers.instanceOf(VersionResourceResolver.class)); assertThat(resolvers.get(1), Matchers.instanceOf(GzipResourceResolver.class)); + assertThat(resolvers.get(2), Matchers.instanceOf(PathResourceResolver.class)); + + VersionResourceResolver versionResolver = (VersionResourceResolver) resolvers.get(0); + assertThat(versionResolver.getStrategyMap().get("/**/*.js"), + Matchers.instanceOf(FixedVersionStrategy.class)); + assertThat(versionResolver.getStrategyMap().get("/**"), + Matchers.instanceOf(ContentVersionStrategy.class)); List transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(2)); assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); - assertThat(transformers.get(1), Matchers.instanceOf(CssLinkResourceTransformer.class)); + assertThat(transformers.get(1), Matchers.instanceOf(AppCacheManifestTransformer.class)); } @Test @@ -823,5 +869,11 @@ public class MvcNamespaceTests { public static class TestPathHelper extends UrlPathHelper { } + public static class TestResourceCache extends ConcurrentMapCache { + public TestResourceCache(String name) { + super(name); + } + } + } diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/config/annotation/ResourceHandlerRegistryTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/config/annotation/ResourceHandlerRegistryTests.java index baee5ad8e0..7cc4f28900 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/config/annotation/ResourceHandlerRegistryTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/config/annotation/ResourceHandlerRegistryTests.java @@ -30,7 +30,7 @@ import org.springframework.mock.web.test.MockServletContext; import org.springframework.web.context.support.GenericWebApplicationContext; import org.springframework.web.servlet.HandlerMapping; import org.springframework.web.servlet.handler.SimpleUrlHandlerMapping; -import org.springframework.web.servlet.resource.AppCacheManifestTransfomer; +import org.springframework.web.servlet.resource.AppCacheManifestTransformer; import org.springframework.web.servlet.resource.CachingResourceResolver; import org.springframework.web.servlet.resource.CachingResourceTransformer; import org.springframework.web.servlet.resource.CssLinkResourceTransformer; @@ -145,7 +145,7 @@ public class ResourceHandlerRegistryTests { .addContentVersionStrategy("/**"); this.registration.resourceChain(true).addResolver(versionResolver) - .addTransformer(new AppCacheManifestTransfomer()); + .addTransformer(new AppCacheManifestTransformer()); ResourceHttpRequestHandler handler = getHandler("/resources/**"); List resolvers = handler.getResourceResolvers(); @@ -158,7 +158,7 @@ public class ResourceHandlerRegistryTests { assertThat(transformers, Matchers.hasSize(3)); assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); assertThat(transformers.get(1), Matchers.instanceOf(CssLinkResourceTransformer.class)); - assertThat(transformers.get(2), Matchers.instanceOf(AppCacheManifestTransfomer.class)); + assertThat(transformers.get(2), Matchers.instanceOf(AppCacheManifestTransformer.class)); } @Test @@ -167,7 +167,7 @@ public class ResourceHandlerRegistryTests { VersionResourceResolver versionResolver = Mockito.mock(VersionResourceResolver.class); PathResourceResolver pathResourceResolver = new PathResourceResolver(); CachingResourceTransformer cachingTransformer = Mockito.mock(CachingResourceTransformer.class); - AppCacheManifestTransfomer appCacheTransformer = Mockito.mock(AppCacheManifestTransfomer.class); + AppCacheManifestTransformer appCacheTransformer = Mockito.mock(AppCacheManifestTransformer.class); CssLinkResourceTransformer cssLinkTransformer = new CssLinkResourceTransformer(); this.registration.setCachePeriod(3600) diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/resource/AppCacheManifestTransformerTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/resource/AppCacheManifestTransformerTests.java index 8f97c19c3f..a8406b5c10 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/resource/AppCacheManifestTransformerTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/resource/AppCacheManifestTransformerTests.java @@ -34,13 +34,13 @@ import static org.mockito.BDDMockito.*; /** * Unit tests for - * {@link AppCacheManifestTransfomer}. + * {@link AppCacheManifestTransformer}. * * @author Brian Clozel */ public class AppCacheManifestTransformerTests { - private AppCacheManifestTransfomer transformer; + private AppCacheManifestTransformer transformer; private ResourceTransformerChain chain; @@ -48,7 +48,7 @@ public class AppCacheManifestTransformerTests { @Before public void setup() { - this.transformer = new AppCacheManifestTransfomer(); + this.transformer = new AppCacheManifestTransformer(); this.chain = mock(ResourceTransformerChain.class); this.request = mock(HttpServletRequest.class); } diff --git a/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain-no-auto.xml b/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain-no-auto.xml new file mode 100644 index 0000000000..02ba0b6284 --- /dev/null +++ b/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain-no-auto.xml @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain.xml b/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain.xml new file mode 100644 index 0000000000..ebda2c5857 --- /dev/null +++ b/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-chain.xml @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-resolvers-transformers.xml b/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-resolvers-transformers.xml deleted file mode 100644 index 183907c4eb..0000000000 --- a/spring-webmvc/src/test/resources/org/springframework/web/servlet/config/mvc-config-resources-resolvers-transformers.xml +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - -