Java 类org.springframework.web.servlet.resource.CachingResourceTransformer 实例源码

@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/**")).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));
    }
}

protected List<ResourceTransformer> getResourceTransformers() {
    if (this.hasVersionResolver  && !this.hasCssLinkTransformer) {
        List<ResourceTransformer> result = new ArrayList<ResourceTransformer>(this.transformers);
        boolean hasTransformers = !this.transformers.isEmpty();
        boolean hasCaching = hasTransformers && this.transformers.get(0) instanceof CachingResourceTransformer;
        result.add(hasCaching ? 1 : 0, new CssLinkResourceTransformer());
        return result;
    }
    return this.transformers;
}

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 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 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/**")).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)));
}