Hängen Sie die relative URL an java.net.URL an

Vorausgesetzt, ich habe ein java.net.URL-Objekt, das auf sagen wir mal zeigt

http://example.com/myItems oder http://example.com/myItems/

Gibt es irgendwo einen Helfer, um eine relative URL daran anzuhängen? Zum Beispiel anhängen ./myItemId oder myItemId zu bekommen :
http://example.com/myItems/myItemId

URL hat ein Konstrukteur Das braucht eine Basis URL und ein String spez.

Alternative, java.net.URI hält sich stärker an die Standards und verfügt über eine resolve Methode, um dasselbe zu tun. Ein … kreieren URI von deiner URL verwenden URL.toURI.

Dieser benötigt keine zusätzlichen Bibliotheken oder Code und liefert das gewünschte Ergebnis:

//import java.net.URL;
URL url1 = new URL("http://petstore.swagger.wordnik.com/api/api-docs?foo=1&bar=baz");
URL url2 = new URL(url1.getProtocol(), url1.getHost(), url1.getPort(), url1.getPath() + "/pet" + "?" + url1.getQuery(), null);
System.out.println(url1);
System.out.println(url2);

Dies druckt:

http://petstore.swagger.wordnik.com/api/api-docs?foo=1&bar=baz
http://petstore.swagger.wordnik.com/api/api-docs/pet?foo=1&bar=baz

Die akzeptierte Antwort funktioniert nur, wenn nach dem Host kein Pfad vorhanden ist (meiner Meinung nach ist die akzeptierte Antwort falsch).

Sie können einfach das verwenden URI Klasse dafür:

import java.net.URI;
import org.apache.http.client.utils.URIBuilder;

URI uri = URI.create("http://example.com/basepath/");
URI uri2 = uri.resolve("./relative");
// => http://example.com/basepath/relative

Beachten Sie den abschließenden Schrägstrich im Basispfad und das basisrelative Format des Segments, das angehängt wird. Sie können auch die verwenden URIBuilder Klasse vom Apache HTTP-Client:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.3</version>
</dependency>

…

import java.net.URI;
import org.apache.http.client.utils.URIBuilder;

URI uri = URI.create("http://example.com/basepath");
URI uri2 = appendPath(uri, "relative");
// => http://example.com/basepath/relative

public URI appendPath(URI uri, String path) {
    URIBuilder builder = new URIBuilder(uri);
    builder.setPath(URI.create(builder.getPath() + "https://stackoverflow.com/").resolve("./" + path).getPath());
    return builder.build();
}

Ich kann nicht glauben, wie böse URI.resolve() Es ist wirklich voller fieser Randfälle.

new URI("http://localhost:80").resolve("foo") => "http://localhost:80foo"
new URI("http://localhost:80").resolve("//foo") => "http://foo"
new URI("http://localhost:80").resolve(".//foo") => "http://foo"

Die sauberste Lösung, die ich je gesehen habe und die diese Randfälle auf vorhersehbare Weise behandelt, ist:

URI addPath(URI uri, String path) {
    String newPath;
    if (path.startsWith("/")) newPath = path.replaceAll("//+", "/");
    else if (uri.getPath().endsWith("/")) newPath = uri.getPath() + path.replaceAll("//+", "/");
    else newPath = uri.getPath() + "/" + path.replaceAll("//+", "/");

    return uri.resolve(newPath).normalize();
}

Ergebnisse:

jshell> addPath(new URI("http://localhost"), "sub/path")
$3 ==> http://localhost/sub/path

jshell> addPath(new URI("http://localhost/"), "sub/path")
$4 ==> http://localhost/sub/path

jshell> addPath(new URI("http://localhost/"), "/sub/path")
$5 ==> http://localhost/sub/path

jshell> addPath(new URI("http://localhost/random-path"), "/sub/path")
$6 ==> http://localhost/sub/path

jshell> addPath(new URI("http://localhost/random-path"), "./sub/path")
$7 ==> http://localhost/random-path/sub/path

jshell> addPath(new URI("http://localhost/random-path"), "../sub/path")
$8 ==> http://localhost/sub/path

jshell> addPath(new URI("http://localhost"), "../sub/path")
$9 ==> http://localhost/../sub/path

jshell> addPath(new URI("http://localhost/"), "//sub/path")
$10 ==> http://localhost/sub/path

jshell> addPath(new URI("http://localhost/"), "//sub/./path")
$11 ==> http://localhost/sub/path

Hier ist eine Hilfsfunktion, die ich geschrieben habe, um sie dem URL-Pfad hinzuzufügen:

public static URL concatenate(URL baseUrl, String extraPath) throws URISyntaxException, 
                                                                    MalformedURLException {
    URI uri = baseUrl.toURI();
    String newPath = uri.getPath() + "https://stackoverflow.com/" + extraPath;
    URI newUri = uri.resolve(newPath);
    return newUri.toURL();
}

Sie können verwenden URIBuilder und die Methode URI#normalize um Duplikate zu vermeiden / in der URI:

URIBuilder uriBuilder = new URIBuilder("http://example.com/test");
URI uri = uriBuilder.setPath(uriBuilder.getPath() + "/path/to/add")
          .build()
          .normalize();
// expected : http://example.com/test/path/to/add

Ich habe lange nach einer Antwort auf diese Frage gesucht. Die einzige Implementierung, die ich finden kann, ist im Android SDK: Uri.Builder. Ich habe es für meine eigenen Zwecke extrahiert.

private String appendSegmentToPath(String path, String segment) {
  if (path == null || path.isEmpty()) {
    return "https://stackoverflow.com/" + segment;
  }

  if (path.charAt(path.length() - 1) == "https://stackoverflow.com/") {
    return path + segment;
  }

  return path + "https://stackoverflow.com/" + segment;
}

Das Hier habe ich die Quelle gefunden.

In Verbindung mit Apache URIBuilderso verwende ich es: builder.setPath(appendSegmentToPath(builder.getPath(), segment));