@Override public String value() { return this.fullPath.value(); }
private static PathContainer initContextPath(PathContainer path, @Nullable String contextPath) { if (!StringUtils.hasText(contextPath) || "/".equals(contextPath)) { return PathContainer.parsePath(""); } validateContextPath(path.value(), contextPath); int length = contextPath.length(); int counter = 0; for (int i=0; i < path.elements().size(); i++) { PathContainer.Element element = path.elements().get(i); counter += element.value().length(); if (length == counter) { return path.subPath(0, i + 1); } } // Should not happen.. throw new IllegalStateException("Failed to initialize contextPath '" + contextPath + "'" + " for requestPath '" + path.value() + "'"); }
@Test public void subPath() throws Exception { // basic PathContainer path = PathContainer.parsePath("/a/b/c"); assertSame(path, path.subPath(0)); assertEquals("/b/c", path.subPath(2).value()); assertEquals("/c", path.subPath(4).value()); // root path path = PathContainer.parsePath("/"); assertEquals("/", path.subPath(0).value()); // trailing slash path = PathContainer.parsePath("/a/b/"); assertEquals("/b/", path.subPath(2).value()); }
private void testPath(String input, String value, List<String> expectedElements) { PathContainer path = PathContainer.parsePath(input); assertEquals("value: '" + input + "'", value, path.value()); assertEquals("elements: " + input, expectedElements, path.elements().stream() .map(PathContainer.Element::value).collect(Collectors.toList())); }
private Mono<String> resolveResourceUrl(ServerWebExchange exchange, PathContainer lookupPath) { return this.handlerMap.entrySet().stream() .filter(entry -> entry.getKey().matches(lookupPath)) .min((entry1, entry2) -> PathPattern.SPECIFICITY_COMPARATOR.compare(entry1.getKey(), entry2.getKey())) .map(entry -> { PathContainer path = entry.getKey().extractPathWithinPattern(lookupPath); int endIndex = lookupPath.elements().size() - path.elements().size(); PathContainer mapping = lookupPath.subPath(0, endIndex); ResourceWebHandler handler = entry.getValue(); List<ResourceResolver> resolvers = handler.getResourceResolvers(); ResourceResolverChain chain = new DefaultResourceResolverChain(resolvers); return chain.resolveUrlPath(path.value(), handler.getLocations()) .map(resolvedPath -> mapping.value() + resolvedPath); }) .orElseGet(() ->{ if (logger.isTraceEnabled()) { logger.trace(exchange.getLogPrefix() + "No match for \"" + lookupPath + "\""); } return Mono.empty(); }); }
/** * Get the public resource URL for the given URI string. * <p>The URI string is expected to be a path and if it contains a query or * fragment those will be preserved in the resulting public resource URL. * @param uriString the URI string to transform * @param exchange the current exchange * @return the resolved public resource URL path, or empty if unresolved */ public final Mono<String> getForUriString(String uriString, ServerWebExchange exchange) { ServerHttpRequest request = exchange.getRequest(); int queryIndex = getQueryIndex(uriString); String lookupPath = uriString.substring(0, queryIndex); String query = uriString.substring(queryIndex); PathContainer parsedLookupPath = PathContainer.parsePath(lookupPath); return resolveResourceUrl(exchange, parsedLookupPath).map(resolvedPath -> request.getPath().contextPath().value() + resolvedPath + query); }
/** * Get the request path as a {@code PathContainer}. */ default PathContainer pathContainer() { return PathContainer.parsePath(path()); }
@Override public List<Element> elements() { return this.fullPath.elements(); }
private void testPathSegment(String rawValue, String valueToMatch, MultiValueMap<String, String> params) { PathContainer container = PathContainer.parsePath(rawValue); if ("".equals(rawValue)) { assertEquals(0, container.elements().size()); return; } assertEquals(1, container.elements().size()); PathSegment segment = (PathSegment) container.elements().get(0); assertEquals("value: '" + rawValue + "'", rawValue, segment.value()); assertEquals("valueToMatch: '" + rawValue + "'", valueToMatch, segment.valueToMatch()); assertEquals("params: '" + rawValue + "'", params, segment.parameters()); }
public static PathContainer toPathContainer(String path) { if (path == null) { return null; } return PathContainer.parsePath(path); }
public MatchingContext(PathContainer pathContainer, boolean extractVariables) { this.candidate = pathContainer; this.pathElements = pathContainer.elements(); this.pathLength = this.pathElements.size(); this.extractingVariables = extractVariables; }
@Override public String path() { return this.pathContainer.value(); }
private static PathContainer initContextPath(PathContainer path, @Nullable String contextPath) { if (!StringUtils.hasText(contextPath) || "/".equals(contextPath)) { return PathContainer.parsePath(""); } validateContextPath(path.value(), contextPath); int length = contextPath.length(); int counter = 0; for (int i=0; i < path.elements().size(); i++) { PathContainer.Element element = path.elements().get(i); counter += element.value().length(); if (length == counter) { return path.subPath(0, i + 1); } } // Should not happen.. throw new IllegalStateException("Failed to initialize contextPath '" + contextPath + "'" + " for requestPath '" + path.value() + "'"); }