Encodage URL Java des paramètres de chaîne de requête

Dis que j'ai une URL

http://example.com/query?q=

et j'ai une requête saisie par l'utilisateur telle que:

mot aléatoire £ 500 banque $

Je veux que le résultat soit une URL correctement encodée:

http://example.com/query?q=random%20word%20%A3500%20bank%20%24

Quelle est la meilleure façon d'y parvenir? J'ai essayé de URLEncodercréer des objets URI / URL mais aucun d'entre eux ne semble tout à fait correct.

URLEncoderest la voie à suivre. Il vous suffit de garder à l'esprit pour encoder uniquement le nom et / ou la valeur du paramètre de chaîne de requête individuelle, pas l'URL entière, bien sûr pas le caractère séparateur de paramètre de chaîne de requête &ni le caractère séparateur nom-valeur de paramètre =.

String q = "random word £500 bank $";
String url = "https://example.com?q=" + URLEncoder.encode(q, StandardCharsets.UTF_8);

Notez que les espaces dans les paramètres de requête sont représentés par +, non %20, ce qui est valablement valide. Le %20est généralement utilisé pour représenter les espaces dans l'URI lui-même (la partie avant le caractère séparateur de chaîne de requête URI ?), pas dans la chaîne de requête (la partie après ?).

Notez également qu'il existe trois encode()méthodes. Un sans Charsetcomme deuxième argument et un autre avec Stringcomme deuxième argument qui lève une exception vérifiée. Celui sans Charsetargument est obsolète. Ne l'utilisez jamais et spécifiez toujours l' Charsetargument. Le javadoc recommande même explicitement d'utiliser le codage UTF-8, tel que prescrit par RFC3986 et W3C .

Tous les autres caractères ne sont pas sûrs et sont d'abord convertis en un ou plusieurs octets à l'aide d'un schéma de codage. Ensuite, chaque octet est représenté par la chaîne de 3 caractères "% xy", où xy est la représentation hexadécimale à deux chiffres de l'octet. Le schéma de codage recommandé à utiliser est UTF-8 . Cependant, pour des raisons de compatibilité, si un encodage n'est pas spécifié, alors l'encodage par défaut de la plateforme est utilisé.

Voir également:

• Ce que tout développeur Web doit savoir sur le codage d'URL

Je n'utiliserais pas URLEncoder. En plus d'être mal nommé ( URLEncodern'a rien à voir avec les URL), inefficace (il utilise un StringBufferau lieu de Builder et fait quelques autres choses qui sont lentes). C'est aussi beaucoup trop facile à visser.

Au lieu de cela , j'utiliser URIBuilderou de printemps org.springframework.web.util.UriUtils.encodeQueryou Apache CommonsHttpClient . La raison étant que vous devez échapper le nom des paramètres de la requête (c'est-à-dire la réponse de BalusC q) différemment de la valeur du paramètre.

Le seul inconvénient de ce qui précède (que j'ai découvert douloureusement) est que les URL ne sont pas un véritable sous-ensemble d'URI .

Exemple de code:

import org.apache.http.client.utils.URIBuilder;

URIBuilder ub = new URIBuilder("http://example.com/query");
ub.addParameter("q", "random word £500 bank \$");
String url = ub.toString();

// Result: http://example.com/query?q=random+word+%C2%A3500+bank+%24

Comme je ne fais que créer un lien vers d'autres réponses, j'ai marqué cela comme un wiki communautaire. N'hésitez pas à modifier.

Vous devez d'abord créer un URI comme:

String urlStr = "http://www.example.com/CEREC® Materials & Accessories/IPS Empress® CAD.pdf"
URL url= new URL(urlStr);
URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(), url.getPath(), url.getQuery(), url.getRef());

Ensuite, convertissez cette Uri en chaîne ASCII:

urlStr=uri.toASCIIString();

Maintenant, votre chaîne d'URL est complètement codée.Nous avons d'abord effectué un simple codage d'URL, puis nous l'avons convertie en chaîne ASCII pour nous assurer qu'aucun caractère en dehors de US-ASCII ne reste dans la chaîne. C'est exactement ce que font les navigateurs.

Guava 15 a maintenant ajouté un ensemble d'échappeurs d'URL simples .

La bibliothèque de composants Apache Http fournit une option intéressante pour la création et le codage des paramètres de requête -

Avec HttpComponents 4.x, utilisez - URLEncodedUtils

Pour HttpClient 3.x - EncodingUtil

Voici une méthode que vous pouvez utiliser dans votre code pour convertir une chaîne d'URL et une carte de paramètres en une chaîne d'URL codée valide contenant les paramètres de requête.

String addQueryStringToUrlString(String url, final Map<Object, Object> parameters) throws UnsupportedEncodingException {
    if (parameters == null) {
        return url;
    }

    for (Map.Entry<Object, Object> parameter : parameters.entrySet()) {

        final String encodedKey = URLEncoder.encode(parameter.getKey().toString(), "UTF-8");
        final String encodedValue = URLEncoder.encode(parameter.getValue().toString(), "UTF-8");

        if (!url.contains("?")) {
            url += "?" + encodedKey + "=" + encodedValue;
        } else {
            url += "&" + encodedKey + "=" + encodedValue;
        }
    }

    return url;
}

URL url= new URL("http://example.com/query?q=random word £500 bank $");
URI uri = new URI(url.getProtocol(), url.getUserInfo(), IDN.toASCII(url.getHost()), url.getPort(), url.getPath(), url.getQuery(), url.getRef());
String correctEncodedURL=uri.toASCIIString(); 
System.out.println(correctEncodedURL);

Impressions

http://example.com/query?q=random%20word%20%C2%A3500%20bank%20$

Que se passe-t-il ici?

1. Fractionnez l'URL en parties structurelles. Utilisez java.net.URL pour cela.

2. Codez correctement chaque pièce structurelle!

3. Utilisez IDN.toASCII(putDomainNameHere)pour Punycode encoder le nom d'hôte!

4. Utilisez java.net.URI.toASCIIString()pour coder en pourcentage, unicode codé NFC - (mieux serait NFKC!). Pour plus d'informations, voir: Comment coder correctement cette URL

Dans certains cas, il est conseillé de vérifier si l'URL est déjà encodée . Remplacez également les espaces encodés '+' par des espaces encodés '% 20'.

Voici quelques exemples qui fonctionneront également correctement

{
      "in" : "http://نامه‌ای.com/",
     "out" : "http://xn--mgba3gch31f.com/"
},{
     "in" : "http://www.example.com/‥/foo",
     "out" : "http://www.example.com/%E2%80%A5/foo"
},{
     "in" : "http://search.barnesandnoble.com/booksearch/first book.pdf", 
     "out" : "http://search.barnesandnoble.com/booksearch/first%20book.pdf"
}, {
     "in" : "http://example.com/query?q=random word £500 bank $", 
     "out" : "http://example.com/query?q=random%20word%20%C2%A3500%20bank%20$"
}

La solution passe environ 100 des cas de test fournis par Web Plattform Tests .

Dans Android, j'utiliserais ce code:

Uri myUI = Uri.parse ("http://example.com/query").buildUpon().appendQueryParameter("q","random word A3500 bank 24").build();

Où Uriest unandroid.net.Uri

Dans mon cas, j'avais juste besoin de passer toute l'URL et de coder uniquement la valeur de chaque paramètre. Je n'ai pas trouvé de code commun pour le faire, alors (!!) j'ai donc créé cette petite méthode pour faire le travail:

public static String encodeUrl(String url) throws Exception {
    if (url == null || !url.contains("?")) {
        return url;
    }

    List<String> list = new ArrayList<>();
    String rootUrl = url.split("\\?")[0] + "?";
    String paramsUrl = url.replace(rootUrl, "");
    List<String> paramsUrlList = Arrays.asList(paramsUrl.split("&"));
    for (String param : paramsUrlList) {
        if (param.contains("=")) {
            String key = param.split("=")[0];
            String value = param.replace(key + "=", "");
            list.add(key + "=" +  URLEncoder.encode(value, "UTF-8"));
        }
        else {
            list.add(param);
        }
    }

    return rootUrl + StringUtils.join(list, "&");
}

public static String decodeUrl(String url) throws Exception {
    return URLDecoder.decode(url, "UTF-8");
}

Il utilise org.apache.commons.lang3.StringUtils

1. Utilisez ceci: URLEncoder.encode (query, StandardCharsets.UTF_8.displayName ()); ou ceci: URLEncoder.encode (requête, "UTF-8");

2. Vous pouvez utiliser le code suivant.

   String encodedUrl1 = UriUtils.encodeQuery(query, "UTF-8");//not change 
   String encodedUrl2 = URLEncoder.encode(query, "UTF-8");//changed
   String encodedUrl3 = URLEncoder.encode(query, StandardCharsets.UTF_8.displayName());//changed
   
   System.out.println("url1 " + encodedUrl1 + "\n" + "url2=" + encodedUrl2 + "\n" + "url3=" + encodedUrl3);