Codificação de URL Java dos parâmetros da string de consulta

Digamos que eu tenho um URL

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

e eu tenho uma consulta inserida pelo usuário, como:

palavra aleatória £ 500 bank $

Quero que o resultado seja um URL codificado corretamente:

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

Qual é a melhor maneira de conseguir isso? Eu tentei URLEncodercriar objetos URI / URL, mas nenhum deles saiu bem.

URLEncoderé o caminho a percorrer. Você só precisa codificar apenas o nome e / ou o valor do parâmetro da sequência de consulta individual, e não o URL inteiro, com certeza não o caractere separador do parâmetro da sequência de consultas &nem o caractere separador nome-valor do parâmetro =.

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

Observe que os espaços nos parâmetros de consulta são representados por +, não %20, o que é legitimamente válido. O %20geralmente é para ser usado para representar espaços em si mesmo (a parte antes do caractere separador seqüência URI-consulta URI ?), e não na string de consulta (a parte depois ?).

Observe também que existem três encode()métodos. Um sem Charsetcomo segundo argumento e outro com Stringcomo segundo argumento que lança uma exceção verificada. O sem Charsetargumento está obsoleto. Nunca use e sempre especifique o Charsetargumento. O javadoc ainda recomenda explicitamente o uso da codificação UTF-8, conforme exigido pelo RFC3986 e W3C .

Todos os outros caracteres são inseguros e são primeiro convertidos em um ou mais bytes usando algum esquema de codificação. Cada byte é representado pela sequência de três caracteres "% xy", em que xy é a representação hexadecimal de dois dígitos do byte. O esquema de codificação recomendado para usar é UTF-8 . No entanto, por motivos de compatibilidade, se uma codificação não for especificada, a codificação padrão da plataforma será usada.

Veja também:

• O que todo desenvolvedor web deve saber sobre codificação de URL

Eu não usaria URLEncoder. Além de ter um nome incorreto ( URLEncodernão tem nada a ver com URLs), é ineficiente (usa um em StringBuffervez do Builder e faz algumas outras coisas que são lentas) Também é muito fácil estragar tudo.

Em vez disso eu usaria URIBuilderou Primavera do org.springframework.web.util.UriUtils.encodeQueryou Commons ApacheHttpClient . A razão é que você precisa escapar do nome dos parâmetros da consulta (ou seja, a resposta do BalusC q) de maneira diferente do valor do parâmetro.

A única desvantagem do que foi mencionado acima (que eu descobri dolorosamente) é que os URLs não são um verdadeiro subconjunto dos URIs .

Código de amostra:

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

Como estou apenas ligando para outras respostas, marquei isso como um wiki da comunidade. Sinta-se livre para editar.

Você precisa primeiro criar um URI como:

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

Em seguida, converta esse Uri em string ASCII:

urlStr=uri.toASCIIString();

Agora, sua string de URL é completamente codificada. Primeiro fizemos uma codificação de URL simples e depois a convertemos em ASCII String para garantir que nenhum caractere fora do US-ASCII permaneça na string. É exatamente assim que os navegadores fazem.

O Guava 15 agora adicionou um conjunto de escapers simples de URL .

A biblioteca Apache Http Components fornece uma opção interessante para criar e codificar parâmetros de consulta -

Com o uso do HttpComponents 4.x - URLEncodedUtils

Para uso do HttpClient 3.x - EncodingUtil

Aqui está um método que você pode usar no seu código para converter uma string de URL e um mapa de parâmetros em uma string de URL codificada válida que contenha os parâmetros de consulta.

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

Impressões

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

O que esta acontecendo aqui?

1. Divida o URL em partes estruturais. Usarjava.net.URL para isso.

2) Codifique cada parte estrutural corretamente!

3. Use IDN.toASCII(putDomainNameHere)para Punycode codificar o nome do host!

4. Use java.net.URI.toASCIIString()para codificação percentual, unicode codificado por NFC - (melhor seria NFKC!). Para mais informações, consulte: Como codificar corretamente este URL

Em alguns casos, é aconselhável verificar se o URL já está codificado . Substitua também os espaços codificados '+' pelos espaços codificados '% 20'.

Aqui estão alguns exemplos que também funcionarão corretamente

{
      "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$"
}

A solução passa em torno de 100 dos casos de teste fornecidos pelos testes da Web Plattform .

No android, eu usaria este código:

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

Onde Uriestá umandroid.net.Uri

No meu caso, eu só precisava passar o URL inteiro e codificar apenas o valor de cada parâmetro. Não encontrei um código comum para fazer isso (!!), então criei este pequeno método para fazer o trabalho:

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

Ele usa org.apache.commons.lang3.StringUtils

1. Use isto: URLEncoder.encode (query, StandardCharsets.UTF_8.displayName ()); ou este: URLEncoder.encode (consulta, "UTF-8");

2. Você pode usar o código a seguir.

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