public ResourceChainRegistration(boolean cacheResources, @Nullable 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)); } }
@Override protected Mono<Resource> resolveResourceInternal(@Nullable ServerWebExchange exchange, String requestPath, List<? extends Resource> locations, ResourceResolverChain chain) { String key = computeKey(exchange, requestPath); Resource cachedResource = this.cache.get(key, Resource.class); if (cachedResource != null) { String logPrefix = exchange != null ? exchange.getLogPrefix() : ""; logger.trace(logPrefix + "Resource resolved from cache"); return Mono.just(cachedResource); } return chain.resolveResource(exchange, requestPath, locations) .doOnNext(resource -> this.cache.put(key, resource)); }
protected String computeKey(@Nullable ServerWebExchange exchange, String requestPath) { StringBuilder key = new StringBuilder(RESOLVED_RESOURCE_CACHE_KEY_PREFIX); key.append(requestPath); if (exchange != null) { String codingKey = getContentCodingKey(exchange); if (StringUtils.hasText(codingKey)) { key.append("+encoding=").append(codingKey); } } return key.toString(); }
@Test public void resourceChain() throws Exception { ResourceUrlProvider resourceUrlProvider = Mockito.mock(ResourceUrlProvider.class); this.registry.setResourceUrlProvider(resourceUrlProvider); ResourceResolver mockResolver = Mockito.mock(ResourceResolver.class); ResourceTransformerSupport mockTransformer = Mockito.mock(ResourceTransformerSupport.class); this.registration.resourceChain(true).addResolver(mockResolver).addTransformer(mockTransformer); ResourceWebHandler 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)); Mockito.verify(mockTransformer).setResourceUrlProvider(resourceUrlProvider); }
@Before public void setup() { this.cache = new ConcurrentMapCache("resourceCache"); List<ResourceResolver> resolvers = new ArrayList<>(); resolvers.add(new CachingResourceResolver(this.cache)); resolvers.add(new PathResourceResolver()); this.chain = new DefaultResourceResolverChain(resolvers); this.locations = new ArrayList<>(); this.locations.add(new ClassPathResource("test/", getClass())); }
@Override protected Mono<Resource> resolveResourceInternal(ServerWebExchange exchange, String requestPath, List<? extends Resource> locations, ResourceResolverChain chain) { String key = computeKey(exchange, requestPath); Resource cachedResource = this.cache.get(key, Resource.class); if (cachedResource != null) { if (logger.isTraceEnabled()) { logger.trace("Found match: " + cachedResource); } return Mono.just(cachedResource); } return chain.resolveResource(exchange, requestPath, locations) .doOnNext(resource -> { if (logger.isTraceEnabled()) { logger.trace("Putting resolved resource in cache: " + resource); } this.cache.put(key, resource); }); }
@Before public void setup() { Cache cache = new ConcurrentMapCache("resourceCache"); VersionResourceResolver versionResolver = new VersionResourceResolver(); versionResolver.setStrategyMap(Collections.singletonMap("/**", new ContentVersionStrategy())); List<ResourceResolver> resolvers = new ArrayList<>(); resolvers.add(new CachingResourceResolver(cache)); resolvers.add(new EncodedResourceResolver()); resolvers.add(versionResolver); resolvers.add(new PathResourceResolver()); this.resolver = new DefaultResourceResolverChain(resolvers); this.locations = new ArrayList<>(); this.locations.add(new ClassPathResource("test/", getClass())); this.locations.add(new ClassPathResource("testalternatepath/", getClass())); }
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)); } }