@Test public void resourceChain() throws Exception { ResourceResolver mockResolver = Mockito.mock(ResourceResolver.class); ResourceTransformer mockTransformer = Mockito.mock(ResourceTransformer.class); this.registration.resourceChain(true).addResolver(mockResolver).addTransformer(mockTransformer); ResourceHttpRequestHandler handler = getHandler("/resources/**"); List<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers.toString(), resolvers, Matchers.hasSize(4)); assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class)); CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0); assertThat(cachingResolver.getCache(), Matchers.instanceOf(ConcurrentMapCache.class)); assertThat(resolvers.get(1), Matchers.equalTo(mockResolver)); assertThat(resolvers.get(2), Matchers.instanceOf(WebJarsResourceResolver.class)); assertThat(resolvers.get(3), Matchers.instanceOf(PathResourceResolver.class)); List<ResourceTransformer> transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(2)); assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); assertThat(transformers.get(1), Matchers.equalTo(mockTransformer)); }
@Test public void resourceChainWithVersionResolver() throws Exception { VersionResourceResolver versionResolver = new VersionResourceResolver() .addFixedVersionStrategy("fixed", "/**/*.js") .addContentVersionStrategy("/**"); this.registration.resourceChain(true).addResolver(versionResolver) .addTransformer(new AppCacheManifestTransformer()); ResourceHttpRequestHandler handler = getHandler("/resources/**"); List<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers.toString(), resolvers, Matchers.hasSize(4)); assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class)); assertThat(resolvers.get(1), Matchers.sameInstance(versionResolver)); assertThat(resolvers.get(2), Matchers.instanceOf(WebJarsResourceResolver.class)); assertThat(resolvers.get(3), Matchers.instanceOf(PathResourceResolver.class)); List<ResourceTransformer> 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 resourceHandlerFixedStrategyEnabled() throws Exception { load("spring.resources.chain.strategy.fixed.enabled:true", "spring.resources.chain.strategy.fixed.version:test", "spring.resources.chain.strategy.fixed.paths:/**/*.js"); assertThat(getResourceResolvers("/webjars/**")).hasSize(3); assertThat(getResourceTransformers("/webjars/**")).hasSize(2); assertThat(getResourceResolvers("/**")).extractingResultOf("getClass") .containsOnly(CachingResourceResolver.class, VersionResourceResolver.class, PathResourceResolver.class); assertThat(getResourceTransformers("/**")).extractingResultOf("getClass") .containsOnly(CachingResourceTransformer.class, CssLinkResourceTransformer.class); VersionResourceResolver resolver = (VersionResourceResolver) getResourceResolvers( "/**").get(1); assertThat(resolver.getStrategyMap().get("/**/*.js")) .isInstanceOf(FixedVersionStrategy.class); }
@Test public void resourceHandlerContentStrategyEnabled() throws Exception { load("spring.resources.chain.strategy.content.enabled:true", "spring.resources.chain.strategy.content.paths:/**,/*.png"); assertThat(getResourceResolvers("/webjars/**")).hasSize(3); assertThat(getResourceTransformers("/webjars/**")).hasSize(2); assertThat(getResourceResolvers("/**")).extractingResultOf("getClass") .containsOnly(CachingResourceResolver.class, VersionResourceResolver.class, PathResourceResolver.class); assertThat(getResourceTransformers("/**")).extractingResultOf("getClass") .containsOnly(CachingResourceTransformer.class, CssLinkResourceTransformer.class); VersionResourceResolver resolver = (VersionResourceResolver) getResourceResolvers( "/**").get(1); assertThat(resolver.getStrategyMap().get("/*.png")) .isInstanceOf(ContentVersionStrategy.class); }
@Test public void resourceHandlerFixedStrategyEnabled() throws Exception { load("spring.resources.chain.strategy.fixed.enabled:true", "spring.resources.chain.strategy.fixed.version:test", "spring.resources.chain.strategy.fixed.paths:/**/*.js"); assertThat(getResourceResolvers("/webjars/**").size(), equalTo(3)); assertThat(getResourceTransformers("/webjars/**").size(), equalTo(2)); assertThat(getResourceResolvers("/**").size(), equalTo(3)); assertThat(getResourceTransformers("/**").size(), equalTo(2)); assertThat(getResourceResolvers("/**"), containsInstances(CachingResourceResolver.class, VersionResourceResolver.class, PathResourceResolver.class)); assertThat(getResourceTransformers("/**"), containsInstances( CachingResourceTransformer.class, CssLinkResourceTransformer.class)); VersionResourceResolver resolver = (VersionResourceResolver) getResourceResolvers( "/**").get(1); assertThat(resolver.getStrategyMap().get("/**/*.js"), instanceOf(FixedVersionStrategy.class)); }
@Test public void resourceHandlerContentStrategyEnabled() throws Exception { load("spring.resources.chain.strategy.content.enabled:true", "spring.resources.chain.strategy.content.paths:/**,/*.png"); assertThat(getResourceResolvers("/webjars/**").size(), equalTo(3)); assertThat(getResourceTransformers("/webjars/**").size(), equalTo(2)); assertThat(getResourceResolvers("/**").size(), equalTo(3)); assertThat(getResourceTransformers("/**").size(), equalTo(2)); assertThat(getResourceResolvers("/**"), containsInstances(CachingResourceResolver.class, VersionResourceResolver.class, PathResourceResolver.class)); assertThat(getResourceTransformers("/**"), containsInstances( CachingResourceTransformer.class, CssLinkResourceTransformer.class)); VersionResourceResolver resolver = (VersionResourceResolver) getResourceResolvers( "/**").get(1); assertThat(resolver.getStrategyMap().get("/*.png"), instanceOf(ContentVersionStrategy.class)); }
public ResourceChainRegistration(boolean cacheResources, Cache cache) { Assert.isTrue(!cacheResources || cache != null, "'cache' is required when cacheResources=true"); if (cacheResources) { this.resolvers.add(new CachingResourceResolver(cache)); this.transformers.add(new CachingResourceTransformer(cache)); } }
private void parseResourceCache(ManagedList<? super Object> resourceResolvers, ManagedList<? super Object> resourceTransformers, Element element, Object source) { String resourceCache = element.getAttribute("resource-cache"); if ("true".equals(resourceCache)) { 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 cacheManagerName = element.getAttribute("cache-manager"); String cacheName = element.getAttribute("cache-name"); if (StringUtils.hasText(cacheManagerName) && StringUtils.hasText(cacheName)) { RuntimeBeanReference cacheManagerRef = new RuntimeBeanReference(cacheManagerName); cavs.addIndexedArgumentValue(0, cacheManagerRef); cavs.addIndexedArgumentValue(1, cacheName); } 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); } }
@Test public void testResourcesWithResolversTransformers() throws Exception { loadBeanDefinitions("mvc-config-resources-chain.xml", 11); 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<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers, Matchers.hasSize(4)); assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class)); assertThat(resolvers.get(1), Matchers.instanceOf(VersionResourceResolver.class)); assertThat(resolvers.get(2), Matchers.instanceOf(WebJarsResourceResolver.class)); assertThat(resolvers.get(3), Matchers.instanceOf(PathResourceResolver.class)); CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0); assertThat(cachingResolver.getCache(), Matchers.instanceOf(ConcurrentMapCache.class)); assertEquals("test-resource-cache", cachingResolver.getCache().getName()); VersionResourceResolver versionResolver = (VersionResourceResolver) resolvers.get(1); assertThat(versionResolver.getStrategyMap().get("/**/*.js"), Matchers.instanceOf(FixedVersionStrategy.class)); assertThat(versionResolver.getStrategyMap().get("/**"), Matchers.instanceOf(ContentVersionStrategy.class)); List<ResourceTransformer> 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)); CachingResourceTransformer cachingTransformer = (CachingResourceTransformer) transformers.get(0); assertThat(cachingTransformer.getCache(), Matchers.instanceOf(ConcurrentMapCache.class)); assertEquals("test-resource-cache", cachingTransformer.getCache().getName()); }
@Test public void resourceChainWithOverrides() throws Exception { CachingResourceResolver cachingResolver = Mockito.mock(CachingResourceResolver.class); VersionResourceResolver versionResolver = Mockito.mock(VersionResourceResolver.class); PathResourceResolver pathResourceResolver = new PathResourceResolver(); CachingResourceTransformer cachingTransformer = Mockito.mock(CachingResourceTransformer.class); AppCacheManifestTransformer appCacheTransformer = Mockito.mock(AppCacheManifestTransformer.class); CssLinkResourceTransformer cssLinkTransformer = new CssLinkResourceTransformer(); this.registration.setCachePeriod(3600) .resourceChain(false) .addResolver(cachingResolver) .addResolver(versionResolver) .addResolver(pathResourceResolver) .addTransformer(cachingTransformer) .addTransformer(appCacheTransformer) .addTransformer(cssLinkTransformer); ResourceHttpRequestHandler handler = getHandler("/resources/**"); List<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers.toString(), resolvers, Matchers.hasSize(3)); assertThat(resolvers.get(0), Matchers.sameInstance(cachingResolver)); assertThat(resolvers.get(1), Matchers.sameInstance(versionResolver)); assertThat(resolvers.get(2), Matchers.sameInstance(pathResourceResolver)); List<ResourceTransformer> transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(3)); assertThat(transformers.get(0), Matchers.sameInstance(cachingTransformer)); assertThat(transformers.get(1), Matchers.sameInstance(appCacheTransformer)); assertThat(transformers.get(2), Matchers.sameInstance(cssLinkTransformer)); }
@Test public void resourceHandlerChainEnabled() throws Exception { load("spring.resources.chain.enabled:true"); assertThat(getResourceResolvers("/webjars/**")).hasSize(2); assertThat(getResourceTransformers("/webjars/**")).hasSize(1); assertThat(getResourceResolvers("/**")).extractingResultOf("getClass") .containsOnly(CachingResourceResolver.class, PathResourceResolver.class); assertThat(getResourceTransformers("/**")).extractingResultOf("getClass") .containsOnly(CachingResourceTransformer.class); }
@Test public void resourceHandlerChainEnabled() throws Exception { load("spring.resources.chain.enabled:true"); assertThat(getResourceResolvers("/webjars/**").size(), equalTo(2)); assertThat(getResourceTransformers("/webjars/**").size(), equalTo(1)); assertThat(getResourceResolvers("/**").size(), equalTo(2)); assertThat(getResourceTransformers("/**").size(), equalTo(1)); assertThat(getResourceResolvers("/**"), containsInstances( CachingResourceResolver.class, PathResourceResolver.class)); assertThat(getResourceTransformers("/**"), contains(instanceOf(CachingResourceTransformer.class))); }