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

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

@Override
public String resolveUrlPath(String resourcePath, List<? extends Resource> locations) {
    ResourceResolver resolver = getNext();
    if (resolver == null) {          
        return null;
    }
    try {
        String returnPath = resolver.resolveUrlPath(resourcePath, locations, this);
        if (LOG.isTraceEnabled()) {
            LOG.trace("The return path for " + resourcePath + " from resolver " + resolver + " is " + returnPath);
        }            
        return returnPath;
    } finally {
        this.index--;
    }
}

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

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

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

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

protected List<ResourceResolver> getResourceResolvers(String mapping) {
    SimpleUrlHandlerMapping handler = (SimpleUrlHandlerMapping) this.context
            .getBean("resourceHandlerMapping");
    ResourceHttpRequestHandler resourceHandler = (ResourceHttpRequestHandler) handler
            .getHandlerMap().get(mapping);
    return resourceHandler.getResourceResolvers();
}

protected List<ResourceResolver> getResourceResolvers(String mapping) {
    SimpleUrlHandlerMapping handler = (SimpleUrlHandlerMapping) this.context
            .getBean("resourceHandlerMapping");
    ResourceHttpRequestHandler resourceHandler = (ResourceHttpRequestHandler) handler
            .getHandlerMap().get(mapping);
    return resourceHandler.getResourceResolvers();
}

protected List<ResourceResolver> getResourceResolvers(String mapping) {
    SimpleUrlHandlerMapping handler = (SimpleUrlHandlerMapping) this.context
            .getBean("resourceHandlerMapping");
    ResourceHttpRequestHandler resourceHandler = (ResourceHttpRequestHandler) handler
            .getHandlerMap().get(mapping);
    return resourceHandler.getResourceResolvers();
}

@Override
public Resource resolveResource(HttpServletRequest request, String requestPath, List<? extends Resource> locations) {
    ResourceResolver resolver = getNext();
    if (resolver == null) {
        return null;
    }
    try {
        return resolver.resolveResource(request, requestPath, locations, this);
    } finally {
        this.index--;
    }
}

private ResourceResolver getNext() {

        Assert.state(this.index <= this.resolvers.size(),
                "Current index exceeds the number of configured ResourceResolver's");

        if (this.index == (this.resolvers.size() - 1)) {
            return null;
        }

        this.index++;
        return this.resolvers.get(this.index);
    }

public BroadleafDefaultResourceResolverChain(List<? extends ResourceResolver> resolvers) {
    if (resolvers != null) {
        this.resolvers.addAll(resolvers);
    }
}