Agregar URL relativa a java.net.URL

Siempre que tenga un objeto java.net.URL, apuntando a digamos

http://example.com/myItems o http://example.com/myItems/

¿Hay algún ayudante en algún lugar para agregar alguna URL relativa a esto? Por ejemplo agregar ./myItemId o myItemId Llegar :
http://example.com/myItems/myItemId

URL tiene un constructor que toma una base URL y un String Especificaciones.

Alternativamente, java.net.URI se adhiere más estrechamente a los estándares, y tiene un resolve método para hacer lo mismo. Crear un URI de tu URL usando URL.toURI.

Este no necesita bibliotecas ni código adicionales y da el resultado deseado:

//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);

Esto imprime:

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

La respuesta aceptada solo funciona si no hay una ruta después del host (en mi humilde opinión, la respuesta aceptada es incorrecta)

Solo puedes usar el URI clase para esto:

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

Tenga en cuenta la barra inclinada final en la ruta base y el formato relativo a la base del segmento que se está agregando. También puede utilizar el URIBuilder clase del cliente Apache HTTP:

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

No puedo creer lo desagradable URI.resolve() realmente está lleno de casos extremos desagradables.

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"

La solución más ordenada que he visto que maneja estos casos extremos de manera predecible es:

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

Resultados:

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

Aquí hay una función de ayuda que he escrito para agregar a la ruta de la URL:

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

Puedes usar URIBuilder y el metodo URI#normalize para evitar la duplicación / en la 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

He buscado por todas partes una respuesta a esta pregunta. La única implementación que puedo encontrar está en el SDK de Android: Uri.Constructor. Lo he extraído para mis propios fines.

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

Este es donde encontré la fuente.

En conjunto con Apache URIBuilderasí es como lo estoy usando: builder.setPath(appendSegmentToPath(builder.getPath(), segment));