@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)); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/index.html") .addResourceLocations("classpath:/public/", "classpath:/static/") .setCacheControl(createCacheConfig(maxIndexCacheAge)) .resourceChain(true) .addResolver(new PathResourceResolver()); final ResourceChainRegistration registration = registry.addResourceHandler("/**") .addResourceLocations("classpath:/public/", "classpath:/static/", "classpath:/META-INF/resources/") .setCacheControl(createCacheConfig(maxCacheAge)) .resourceChain(true) .addResolver(new PathResourceResolver()); if (propertyInjectionTransformer != null) { registration.addTransformer(propertyInjectionTransformer); } }
@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)); }
@Override public void addResourceHandlers(final ResourceHandlerRegistry registry) { Integer cachePeriod = resourceProperties.getCachePeriod(); final String[] staticLocations = resourceProperties.getStaticLocations(); final String[] indexLocations = new String[staticLocations.length]; for (int i = 0; i < staticLocations.length; i++) { indexLocations[i] = staticLocations[i] + "index.html"; } registry.addResourceHandler( "/**/*.css", "/**/*.html", "/**/*.js", "/**/*.json", "/**/*.bmp", "/**/*.jpeg", "/**/*.jpg", "/**/*.png", "/**/*.ttf", "/**/*.eot", "/**/*.svg", "/**/*.woff", "/**/*.woff2" ) .addResourceLocations(staticLocations) .setCachePeriod(cachePeriod); registry.addResourceHandler("/**") .addResourceLocations(indexLocations) .setCachePeriod(cachePeriod) .resourceChain(true) .addResolver(new PathResourceResolver() { @Override protected Resource getResource(final String resourcePath, final Resource location) throws IOException { return location.exists() && location.isReadable() ? location : null; } }); }
@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 resourceHandlerChainCustomized() throws Exception { load("spring.resources.chain.enabled:true", "spring.resources.chain.cache:false", "spring.resources.chain.strategy.content.enabled:true", "spring.resources.chain.strategy.content.paths:/**,/*.png", "spring.resources.chain.strategy.fixed.enabled:true", "spring.resources.chain.strategy.fixed.version:test", "spring.resources.chain.strategy.fixed.paths:/**/*.js", "spring.resources.chain.html-application-cache:true", "spring.resources.chain.gzipped:true"); assertThat(getResourceResolvers("/webjars/**")).hasSize(3); assertThat(getResourceTransformers("/webjars/**")).hasSize(2); assertThat(getResourceResolvers("/**")).extractingResultOf("getClass") .containsOnly(VersionResourceResolver.class, GzipResourceResolver.class, PathResourceResolver.class); assertThat(getResourceTransformers("/**")).extractingResultOf("getClass") .containsOnly(CssLinkResourceTransformer.class, AppCacheManifestTransformer.class); VersionResourceResolver resolver = (VersionResourceResolver) getResourceResolvers( "/**").get(0); assertThat(resolver.getStrategyMap().get("/*.png")) .isInstanceOf(ContentVersionStrategy.class); assertThat(resolver.getStrategyMap().get("/**/*.js")) .isInstanceOf(FixedVersionStrategy.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)); }
@Test public void resourceHandlerChainCustomized() throws Exception { load("spring.resources.chain.enabled:true", "spring.resources.chain.cache:false", "spring.resources.chain.strategy.content.enabled:true", "spring.resources.chain.strategy.content.paths:/**,/*.png", "spring.resources.chain.strategy.fixed.enabled:true", "spring.resources.chain.strategy.fixed.version:test", "spring.resources.chain.strategy.fixed.paths:/**/*.js", "spring.resources.chain.html-application-cache:true"); assertThat(getResourceResolvers("/webjars/**").size(), equalTo(2)); assertThat(getResourceTransformers("/webjars/**").size(), equalTo(2)); assertThat(getResourceResolvers("/**").size(), equalTo(2)); assertThat(getResourceTransformers("/**").size(), equalTo(2)); assertThat(getResourceResolvers("/**"), containsInstances( VersionResourceResolver.class, PathResourceResolver.class)); assertThat(getResourceTransformers("/**"), containsInstances( CssLinkResourceTransformer.class, AppCacheManifestTransformer.class)); VersionResourceResolver resolver = (VersionResourceResolver) getResourceResolvers( "/**").get(0); assertThat(resolver.getStrategyMap().get("/*.png"), instanceOf(ContentVersionStrategy.class)); assertThat(resolver.getStrategyMap().get("/**/*.js"), instanceOf(FixedVersionStrategy.class)); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry .addResourceHandler("/resources/**") .addResourceLocations("/resources/") .setCachePeriod(3600) .resourceChain(true) .addResolver(new PathResourceResolver()); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler(STATIC_RESOURCES) .addResourceLocations(resourceProperties.getStaticLocations()); registry.addResourceHandler("/**") .addResourceLocations(getIndexLocations()) .resourceChain(true) .addResolver(new PathResourceResolver() { @Override protected Resource getResource(String resourcePath, Resource location) throws IOException { return location.exists() && location.isReadable() ? location : null; } }); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/*.*", "/ico/**", "/reports/**", "swagger-ui.html", "/webjars/**") .addResourceLocations("/site/", "/site/ico/", "file:" + reportRootPath(), "classpath:/META-INF/resources/", "classpath:/META-INF/resources/webjars/") .resourceChain(true) .addResolver(new GzipResourceResolver()) .addResolver(new PathResourceResolver()); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/resources/vendor/**") .addResourceLocations("/resources/vendor/") .setCachePeriod(0) .resourceChain(true) .addResolver(new GzipResourceResolver()) .addResolver(new PathResourceResolver()); }
/** * Add a resource resolver to the chain. * @param resolver the resolver to add * @return the current instance for chained method invocation */ public ResourceChainRegistration addResolver(ResourceResolver resolver) { Assert.notNull(resolver, "The provided ResourceResolver should not be null"); this.resolvers.add(resolver); if (resolver instanceof VersionResourceResolver) { this.hasVersionResolver = true; } else if (resolver instanceof PathResourceResolver) { this.hasPathResolver = true; } return this; }
protected List<ResourceResolver> getResourceResolvers() { if (!this.hasPathResolver) { List<ResourceResolver> result = new ArrayList<ResourceResolver>(this.resolvers); if (isWebJarsAssetLocatorPresent) { result.add(new WebJarsResourceResolver()); } result.add(new PathResourceResolver()); return result; } return this.resolvers; }
@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 testResourcesWithResolversTransformersCustom() throws Exception { loadBeanDefinitions("mvc-config-resources-chain-no-auto.xml", 12); 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); assertThat(handler.getCacheControl().getHeaderValue(), Matchers.equalTo(CacheControl.maxAge(1, TimeUnit.HOURS) .sMaxAge(30, TimeUnit.MINUTES).cachePublic().getHeaderValue())); List<ResourceResolver> 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<ResourceTransformer> transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(2)); assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); assertThat(transformers.get(1), Matchers.instanceOf(AppCacheManifestTransformer.class)); }
@Test public void resourceChainWithoutCaching() throws Exception { this.registration.resourceChain(false); ResourceHttpRequestHandler handler = getHandler("/resources/**"); List<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers, Matchers.hasSize(2)); assertThat(resolvers.get(0), Matchers.instanceOf(WebJarsResourceResolver.class)); assertThat(resolvers.get(1), Matchers.instanceOf(PathResourceResolver.class)); List<ResourceTransformer> transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(0)); }
@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); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { if (config.getTemplatesMinified()) { registry .addResourceHandler("/assets/" + config.getAssetsTimestamp() + "/**") .addResourceLocations("/assets/") .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS).cachePublic()) .resourceChain(true) .addResolver(new GzipResourceResolver()) .addResolver(new PathResourceResolver()); } else { registry .addResourceHandler("/assets/" + config.getAssetsTimestamp() + "/**") .addResourceLocations("/assets/") .setCacheControl(CacheControl.noCache()) .resourceChain(true) .addResolver(new GzipResourceResolver()) .addResolver(new PathResourceResolver()); } // Always serve uploaded resources as a backup in-case we're running without an Apache in front... /* registry .addResourceHandler("/uploaded-resources/**") .addResourceLocations("file:///" + config.getResourceUploadPath()) .resourceChain(true) .addResolver(new GzipResourceResolver()) .addResolver(new PathResourceResolver()); */ }
@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))); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { Integer cachePeriod = resourceProperties.getCachePeriod(); /** * Angular artefacts must not be mapped to index.html */ registry.addResourceHandler("*.js", "*.css", "*.map", "flags.*", "icons.*", "favicon.ico") .addResourceLocations("classpath:/static/") .setCachePeriod(cachePeriod); registry.addResourceHandler("assets/**") .addResourceLocations("classpath:/static/assets/") .setCachePeriod(cachePeriod); registry.addResourceHandler("/static/**") .addResourceLocations("classpath:/static/") .setCachePeriod(cachePeriod); /** * For Angular all requests have to go to index.html */ registry.addResourceHandler("/**") .addResourceLocations("classpath:/static/index.html") .setCachePeriod(cachePeriod).resourceChain(true) .addResolver(new PathResourceResolver() { @Override protected Resource getResource(String resourcePath, Resource location) throws IOException { return location.exists() && location.isReadable() ? location : null; } }); }
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/docs/**") .addResourceLocations("classpath:/public/") .resourceChain(true) .addResolver(new PathResourceResolver()); }