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

@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 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 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));
}

@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));
}

@PostConstruct
public void initIt() throws Exception {
    this.put("/**", (VersionStrategy) new ContentVersionStrategy());
}