Ajouter une URL relative à java.net.URL

À condition d'avoir un java.net.URL de l'objet, pointant vers disons

http://example.com/myItems ou http://example.com/myItems/

Est-il un helper quelque part pour ajouter des URL relatives pour cela?
Par exemple ajouter ./myItemId ou myItemId pour obtenir :
http://example.com/myItems/myItemId

double possible de la Construction d'une URL absolue à partir d'une URL relative en Java servlet
Il semble qu'il n'y est pas de solution simple. Soit l'URL ou URI classe ne prend pas en charge cette fonction. Apache HttpClient aussi n'a pas de support pour cela.

InformationsquelleAutor fulmicoton | 2011-09-21

java url

26

~~URL a un constructeur qui prend une base URL et un String spec.~~

Sinon, java.net.URI adhère plus étroitement aux normes, et a un résoudre méthode pour faire la même chose. Créer un URI de votre URL à l'aide de URL.le t.
- "URL a un constructeur qui prend une URL de base et une Chaîne spec." - Pas utile. URL url1 = new URL("petstore.swagger.wordnik.com/api/api-docs"); URL url2 = new URL(url1, "animaux"); System.out.println(url2.toString()) vous donne: petstore.swagger.wordnik.com/pet, pas petstore.swagger.wordnik.com/api/api-docs/pet
- Pour bénéficier des autres: La première URL constructeur méthode ne fonctionne pas tout à fait la façon que j'attendais (rtfm, hein?). Seule la non-partie du chemin d'accès de l'baseURL est utilisé.
- Le deuxième paramètre ne doit pas commencer par un slash. La barre oblique indique un "absolu" lien, donc le chemin de la url1 est rejetée.
- URI résoudre effectivement ne fonctionne que par erreur ici. voir @Christoph Henkelmann la réponse ci-dessous
- Comme @user2585038 mentionné cette réponse ne tient pas compte de la section 5.2 (6a) à partir de RFC2396 qui stipule: "Toutes les, mais la dernière partie de l'URI de base de l'élément de chemin, est copié dans le tampon. En d'autres termes, tous les caractères après le dernier (le plus à droite) caractère de barre oblique, le cas échéant, sont exclus." Cette OMI rend URI résoudre inutilisable dans la majorité des cas, y compris celui de l'OP.
InformationsquelleAutor Andrew Duffy
25

Celui-ci n'a pas besoin d'un syndicat ou d'un code et donne le résultat souhaité:
```
URL url1 = new URL("http://petstore.swagger.wordnik.com/api/api-docs");
URL url2 = new URL(url1.getProtocol(), url1.getHost(), url1.getPort(), url1.getFile() + "/pet", null);
System.out.println(url1);
System.out.println(url2);
```
Cette affiche:
```
http://petstore.swagger.wordnik.com/api/api-docs
http://petstore.swagger.wordnik.com/api/api-docs/pet
```
La accepté de répondre ne fonctionne que si il n'y a pas de chemin après que l'hôte (à mon humble avis l'on a accepté la réponse est fausse)
- MalformedUrlException pourquoi ne pas simplement jeter décoché exception :'(
- Ouais, ça craint... et c'est incohérent: analyse d'un nombre de lancers décoché des exceptions ^^
- Cette solution ne gère pas les barres obliques. La question fournit deux exemples.
- url1.getFile().endsWith("/") ? url1.getFile() + "pet" : url1.getFile() + "/pet"?
InformationsquelleAutor Christoph Henkelmann

Ici est une fonction d'aide je l'ai écrit pour ajouter le chemin d'accès d'url:

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

Si baseUrl se termine avec un / ou extraPath commence avec un / vous aurez répété / dans l'URL finale. Vous devez ajouter un .normalize() avant la dernière toURL().
Cela ne fonctionne pas pour un fichier local URL, ce qui devrait démarrer avec le fichier://

InformationsquelleAutor Andrew Shepherd

4

J'ai cherché un peu partout une réponse à cette question. La seule application que je peux trouver est dans le SDK Android: Uri.Constructeur. J'ai extrait mes propres fins.
```
private String appendSegmentToPath(String path, String segment) {
  if (path == null || path.isEmpty()) {
    return "/" + segment;
  }

  if (path.charAt(path.length() - 1) == '/') {
    return path + segment;
  }

  return path + "/" + segment;
}
```
Cette est là que j'ai trouvé la source.

En conjonction avec Apache URIBuilder, c'est comment je l'utilise: builder.setPath(appendSegmentToPath(builder.getPath(), segment));
- Cela peut être utilisés de la même manière à l'Aide de UriBuilder de jersey client/ docs.oracle.com/javaee/7/api/javax/ws/rs/core/UriBuilder.html
- bonne trouvaille
InformationsquelleAutor twhitbeck
3

Vous pouvez utiliser URIBuilder et la méthode URI#normalize pour éviter de dupliquer des / dans l'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
```
- URIBuilder semble pas faire partie du JDK. Peut-être que vous devriez mentionner le paquet/bibliothèque qui fournit la URIBuilder classe.
- Il est lié: org.apache.http.client.utils.URIBuilder
- Oui, en attendant, il est lié 😉 Thx herau pour l'édition.
InformationsquelleAutor herau
2

Mis à JOUR

Je crois que c'est le plus court de solution:
```
URL url1 = new URL("http://domain.com/contextpath");
String relativePath = "/additional/relative/path";
URL concatenatedUrl = new URL(url1.toExternalForm() + relativePath);
```
- new URL("/additional/relative/path"); jette MalformedURLException
- oui, vous avez raison; la réponse est mis à jour...
InformationsquelleAutor Galya

Quelques exemples d'utilisation de l'Apache URIBuilder http://hc.apache.org/httpcomponents-client-4.3.x/httpclient/apidocs/org/apache/http/client/utils/URIBuilder.html:

Ex1:

String url = "http://example.com/test";
URIBuilder builder = new URIBuilder(url);
builder.setPath((builder.getPath() + "/example").replaceAll("//+", "/"));
System.out.println("Result 1 -> " + builder.toString());

Résultat 1 -> http://example.com/test/example

Ex2:

String url = "http://example.com/test";
URIBuilder builder = new URIBuilder(url);
builder.setPath((builder.getPath() + "///example").replaceAll("//+", "/"));
System.out.println("Result 2 -> " + builder.toString());

Résultat 2 -> http://example.com/test/example

InformationsquelleAutor Marcelo C.

Vous pouvez simplement utiliser le URI classe pour ce:

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

Note le slash sur le chemin de la base et de la base par rapport au format du segment qui est annexé. Vous pouvez également utiliser le URIBuilder classe de client HTTP Apache:

<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() + "/").resolve("./" + path).getPath());
    return builder.build();
}

InformationsquelleAutor Scott Babcock

1

Concaténer un chemin relatif vers un URI:
```
java.net.URI uri = URI.create("https://stackoverflow.com/questions")
java.net.URI res = uri.resolve(uri.getPath + "/some/path")
```
res contiendra https://stackoverflow.com/questions/some/path
- Si vous exécutez ce code, je pense que vous verrez que le résultat est:
- Code corrigé pour utiliser uri.getPath au lieu de cela, merci!
InformationsquelleAutor Martin Tapp
1

J'ai eu quelques difficultés avec l'encodage des URI. Ajoutant a pas de travail pour moi car il a un contenu://le type et il a été de ne pas aimer le "/". Cette solution n'assume aucune requête, ni fragment(nous travaillons avec des chemins, après tout):

Kotlin code:
```
  val newUri = Uri.parse(myUri.toString() + Uri.encode("/$relPath"))
```
InformationsquelleAutor johnml1135

Ma solution basée sur twhitbeck réponse:

import java.net.URI;
import java.net.URISyntaxException;

public class URIBuilder extends org.apache.http.client.utils.URIBuilder {
    public URIBuilder() {
    }

    public URIBuilder(String string) throws URISyntaxException {
        super(string);
    }

    public URIBuilder(URI uri) {
        super(uri);
    }

    public org.apache.http.client.utils.URIBuilder addPath(String subPath) {
        if (subPath == null || subPath.isEmpty() || "/".equals(subPath)) {
            return this;
        }
        return setPath(appendSegmentToPath(getPath(), subPath));
    }

    private String appendSegmentToPath(String path, String segment) {
        if (path == null || path.isEmpty()) {
            path = "/";
        }

        if (path.charAt(path.length() - 1) == '/' || segment.startsWith("/")) {
            return path + segment;
        }

        return path + "/" + segment;
    }
}

Test:

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class URIBuilderTest {

    @Test
    public void testAddPath() throws Exception {
        String url = "http://example.com/test";
        String expected = "http://example.com/test/example";

        URIBuilder builder = new URIBuilder(url);
        builder.addPath("/example");
        assertEquals(expected, builder.toString());

        builder = new URIBuilder(url);
        builder.addPath("example");
        assertEquals(expected, builder.toString());

        builder.addPath("");
        builder.addPath(null);
        assertEquals(expected, builder.toString());

        url = "http://example.com";
        expected = "http://example.com/example";

        builder = new URIBuilder(url);
        builder.addPath("/");
        assertEquals(url, builder.toString());
        builder.addPath("/example");
        assertEquals(expected, builder.toString());
    }
}

Gist: https://gist.github.com/enginer/230e2dc2f1d213a825d5

InformationsquelleAutor Sllouyssgort

0

Pour android assurez-vous d'utiliser .appendPath() de android.net.Uri

InformationsquelleAutor Roman Gherta
0

Sur Android, vous pouvez utiliser android.net.Uri. La suite permet de créer un Uri.Builder à partir d'une URL existante comme String puis ajouter:
```
Uri.parse(baseUrl) //Create Uri from String
    .buildUpon()   //Creates a "Builder"
    .appendEncodedPath("path/to/add")
    .build()
```
Noter que appendEncodedPath ne vous attendez pas à un leader / et contient seulement un vérifiez si le "baseUrl" se termine par un, sinon on est ajoutée avant le chemin d'accès.

InformationsquelleAutor sunadorer

Vous devez vous connecter pour publier un commentaire.