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

项目：spring4-understanding 文件：ResourceHandlerRegistryTests.java

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

项目：smarti 文件：StaticWebResourceConfiguration.java

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

项目：spring4-understanding 文件：ResourceHandlerRegistryTests.java

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

项目：unity 文件：WebConfig.java

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

项目：https-github.com-g0t4-jenkins2-course-spring-boot 文件：WebMvcAutoConfigurationTests.java

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

项目：https-github.com-g0t4-jenkins2-course-spring-boot 文件：WebMvcAutoConfigurationTests.java

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

项目：https-github.com-g0t4-jenkins2-course-spring-boot 文件：WebMvcAutoConfigurationTests.java

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

项目：spring-boot-concourse 文件：WebMvcAutoConfigurationTests.java

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

项目：spring-boot-concourse 文件：WebMvcAutoConfigurationTests.java

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

项目：spring-boot-concourse 文件：WebMvcAutoConfigurationTests.java

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

项目：contestparser 文件：WebMvcAutoConfigurationTests.java

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

项目：contestparser 文件：WebMvcAutoConfigurationTests.java

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

项目：contestparser 文件：WebMvcAutoConfigurationTests.java

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

项目：EventSoft 文件：MvcConfig.java

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    registry
            .addResourceHandler("/resources/**")
            .addResourceLocations("/resources/")
            .setCachePeriod(3600)
            .resourceChain(true)
            .addResolver(new PathResourceResolver());
}

项目：inpacker 文件：WebConfig.java

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

项目：chronos 文件：TestConfig.java

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

项目：spring-security-angularjs 文件：MvcConfig.java

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    registry.addResourceHandler("/resources/vendor/**")
            .addResourceLocations("/resources/vendor/")
            .setCachePeriod(0)
            .resourceChain(true)
            .addResolver(new GzipResourceResolver())
            .addResolver(new PathResourceResolver());
}

项目：spring4-understanding 文件：ResourceChainRegistration.java

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

项目：spring4-understanding 文件：ResourceChainRegistration.java

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

项目：spring4-understanding 文件：MvcNamespaceTests.java

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

项目：spring4-understanding 文件：MvcNamespaceTests.java

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

项目：spring4-understanding 文件：ResourceHandlerRegistryTests.java

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

项目：spring4-understanding 文件：ResourceHandlerRegistryTests.java

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

项目：https-github.com-g0t4-jenkins2-course-spring-boot 文件：WebMvcAutoConfigurationTests.java

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

项目：entelect-spring-webapp-template 文件：SpringMVCConfig.java

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

项目：spring-boot-concourse 文件：WebMvcAutoConfigurationTests.java

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

项目：contestparser 文件：WebMvcAutoConfigurationTests.java

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

项目：SmartApplianceEnabler 文件：WebConfig.java

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

项目：spring-auto-restdocs 文件：StaticResourceConfiguration.java

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    registry.addResourceHandler("/docs/**")
            .addResourceLocations("classpath:/public/")
            .resourceChain(true)
            .addResolver(new PathResourceResolver());
}