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

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

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    // Serve assets from public dir
    registry.addResourceHandler("/dist/**")
            .addResourceLocations("classpath:/public/dist/")
            .setCachePeriod(CACHE_TIME)
            .resourceChain(true)
            .addResolver(new GzipResourceResolver());

    // Serve index for all other routes
    registry.addResourceHandler("/**")
            .setCachePeriod(CACHE_TIME)
            .resourceChain(true)
            .addResolver(new IndexResourceResolver());
}

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

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

private void configureResourceChain(ResourceProperties.Chain properties,
        ResourceChainRegistration chain) {
    Strategy strategy = properties.getStrategy();
    if (strategy.getFixed().isEnabled() || strategy.getContent().isEnabled()) {
        chain.addResolver(getVersionResourceResolver(strategy));
    }
    if (properties.isGzipped()) {
        chain.addResolver(new GzipResourceResolver());
    }
    if (properties.isHtmlApplicationCache()) {
        chain.addTransformer(new AppCacheManifestTransformer());
    }
}

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

private void configureResourceChain(ResourceProperties.Chain properties,
        ResourceChainRegistration chain) {
    Strategy strategy = properties.getStrategy();
    if (strategy.getFixed().isEnabled() || strategy.getContent().isEnabled()) {
        chain.addResolver(getVersionResourceResolver(strategy));
    }
    if (properties.isGzipped()) {
        chain.addResolver(new GzipResourceResolver());
    }
    if (properties.isHtmlApplicationCache()) {
        chain.addTransformer(new AppCacheManifestTransformer());
    }
}