URLEncoder no puede traducir caracteres espaciales

Estoy esperando

System.out.println(java.net.URLEncoder.encode("Hello World", "UTF-8"));

a la salida:

Hello%20World

(20 es el código ASCII Hex para el espacio)

Sin embargo, lo que obtengo es:

Hello+World

¿Estoy usando el método incorrecto? ¿Cuál es el método correcto que debería usar?

Esto se comporta como se esperaba. losURLEncoder implementos de las especificaciones de HTML para cómo codificar las direcciones URL en formularios HTML.

De los javadocs :

Esta clase contiene métodos estáticos para convertir una cadena al formato MIME application / x-www-form-urlencoded.

y de la especificación HTML :

application / x-www-form-urlencoded

Los formularios enviados con este tipo de contenido deben codificarse de la siguiente manera:

1. Los nombres y valores de control se escapan. Los caracteres de espacio se reemplazan por '+'

Tendrá que reemplazarlo, por ejemplo:

System.out.println(java.net.URLEncoder.encode("Hello World", "UTF-8").replace("+", "%20"));

Se codifica un espacio %20en URL y+ en datos enviados de formularios (tipo de contenido application / x-www-form-urlencoded). Necesitas lo primero.

Usando guayaba :

dependencies {
     compile 'com.google.guava:guava:23.0'
     // or, for Android:
     compile 'com.google.guava:guava:23.0-android'
}

Puedes usar UrlEscapers :

String encodedString = UrlEscapers.urlFragmentEscaper().escape(inputString);

No use String.replace, esto solo codificaría el espacio. Use una biblioteca en su lugar.

Esta clase realiza application/x-www-form-urlencodedcodificación de tipo en lugar de codificación porcentual, por lo tanto, reemplaza con+ es un comportamiento correcto.

De javadoc:

Al codificar una cadena, se aplican las siguientes reglas:

• Los caracteres alfanuméricos "a" a "z", "A" a "Z" y "0" a "9" siguen siendo los mismos.
• Los caracteres especiales ".", "-", "*" y "_" siguen siendo los mismos.
• El carácter de espacio "" se convierte en un signo más "+".
• Todos los demás caracteres no son seguros y se convierten primero en uno o más bytes usando algún esquema de codificación. Luego, cada byte está representado por la cadena de 3 caracteres "% xy", donde xy es la representación hexadecimal de dos dígitos del byte. El esquema de codificación recomendado para usar es UTF-8. Sin embargo, por razones de compatibilidad, si no se especifica una codificación, se utiliza la codificación predeterminada de la plataforma.

Codificar parámetros de consulta

org.apache.commons.httpclient.util.URIUtil
    URIUtil.encodeQuery(input);

O si quieres escapar de los caracteres dentro de URI

public static String escapeURIPathParam(String input) {
  StringBuilder resultStr = new StringBuilder();
  for (char ch : input.toCharArray()) {
   if (isUnsafe(ch)) {
    resultStr.append('%');
    resultStr.append(toHex(ch / 16));
    resultStr.append(toHex(ch % 16));
   } else{
    resultStr.append(ch);
   }
  }
  return resultStr.toString();
 }

 private static char toHex(int ch) {
  return (char) (ch < 10 ? '0' + ch : 'A' + ch - 10);
 }

 private static boolean isUnsafe(char ch) {
  if (ch > 128 || ch < 0)
   return true;
  return " %$&+,/:;=?@<>#%".indexOf(ch) >= 0;
 }

Hello+Worldes cómo un navegador codificará los datos del formulario ( application/x-www-form-urlencoded) para una GETsolicitud y este es el formulario generalmente aceptado para la parte de consulta de un URI.

http://host/path/?message=Hello+World

Si envió esta solicitud a un servlet Java, el servlet decodificará correctamente el valor del parámetro. Por lo general, la única vez que hay problemas aquí es si la codificación no coincide.

Estrictamente hablando, no hay ningún requisito en las especificaciones HTTP o URI de que la parte de la consulta se codifique utilizando application/x-www-form-urlencodedpares clave-valor; la parte de la consulta solo debe estar en la forma que acepta el servidor web. En la práctica, es poco probable que esto sea un problema.

En general, sería incorrecto utilizar esta codificación para otras partes del URI (la ruta, por ejemplo). En ese caso, debe usar el esquema de codificación como se describe en RFC 3986 .

http://host/Hello%20World

Más aquí .

Las otras respuestas presentan un reemplazo de cadena manual, URLEncoder , que en realidad codifica para el formato HTML, el URIUtil abandonado de Apache , o el uso de UrlEscapers de Guava . El último está bien, excepto que no proporciona un decodificador.

Apache Commons Lang proporciona el URLCodec , que codifica y decodifica de acuerdo con el formato URL rfc3986 .

String encoded = new URLCodec().encode(str);
String decoded = new URLCodec().decode(str);

Si ya está utilizando Spring, también puede optar por usar su clase UriUtils .

"+" es correcto. Si realmente necesita% 20, reemplace los Plus usted mismo después.

Solo he estado luchando con esto también en Android, logré tropezar con Uri.encode (String, String) mientras que es específico para Android (android.net.Uri) podría ser útil para algunos.

codificación de cadena estática (cadena s, cadena permitida)

https://developer.android.com/reference/android/net/Uri.html#encode(java.lang.String, java.lang.String)

Esto funciono para mi

org.apache.catalina.util.URLEncoder ul = new org.apache.catalina.util.URLEncoder().encode("MY URL");

Aunque bastante viejo, sin embargo, una respuesta rápida:

Spring proporciona UriUtils: con esto puede especificar cómo codificar y qué parte está relacionada desde un URI, por ejemplo

encodePathSegment
encodePort
encodeFragment
encodeUriVariables
....

Los uso porque ya estamos usando Spring, es decir, ¡no se requiere una biblioteca adicional!

Echa un vistazo a la clase java.net.URI.

¿Estoy usando el método incorrecto? ¿Cuál es el método correcto que debería usar?

Sí, este método java.net.URLEncoder.encode no se hizo para convertir "" a "20%" de acuerdo con las especificaciones ( fuente ).

El carácter de espacio "" se convierte en un signo más "+".

Incluso si este no es el método correcto, puede modificarlo para: System.out.println(java.net.URLEncoder.encode("Hello World", "UTF-8").replaceAll("\\+", "%20"));tener un buen día =).

USE MyUrlEncode.URLencoding (String url, String enc) para manejar el problema

    public class MyUrlEncode {
    static BitSet dontNeedEncoding = null;
    static final int caseDiff = ('a' - 'A');
    static {
        dontNeedEncoding = new BitSet(256);
        int i;
        for (i = 'a'; i <= 'z'; i++) {
            dontNeedEncoding.set(i);
        }
        for (i = 'A'; i <= 'Z'; i++) {
            dontNeedEncoding.set(i);
        }
        for (i = '0'; i <= '9'; i++) {
            dontNeedEncoding.set(i);
        }
        dontNeedEncoding.set('-');
        dontNeedEncoding.set('_');
        dontNeedEncoding.set('.');
        dontNeedEncoding.set('*');
        dontNeedEncoding.set('&');
        dontNeedEncoding.set('=');
    }
    public static String char2Unicode(char c) {
        if(dontNeedEncoding.get(c)) {
            return String.valueOf(c);
        }
        StringBuffer resultBuffer = new StringBuffer();
        resultBuffer.append("%");
        char ch = Character.forDigit((c >> 4) & 0xF, 16);
            if (Character.isLetter(ch)) {
            ch -= caseDiff;
        }
        resultBuffer.append(ch);
            ch = Character.forDigit(c & 0xF, 16);
            if (Character.isLetter(ch)) {
            ch -= caseDiff;
        }
         resultBuffer.append(ch);
        return resultBuffer.toString();
    }
    private static String URLEncoding(String url,String enc) throws UnsupportedEncodingException {
        StringBuffer stringBuffer = new StringBuffer();
        if(!dontNeedEncoding.get('/')) {
            dontNeedEncoding.set('/');
        }
        if(!dontNeedEncoding.get(':')) {
            dontNeedEncoding.set(':');
        }
        byte [] buff = url.getBytes(enc);
        for (int i = 0; i < buff.length; i++) {
            stringBuffer.append(char2Unicode((char)buff[i]));
        }
        return stringBuffer.toString();
    }
    private static String URIEncoding(String uri , String enc) throws UnsupportedEncodingException { //对请求参数进行编码
        StringBuffer stringBuffer = new StringBuffer();
        if(dontNeedEncoding.get('/')) {
            dontNeedEncoding.clear('/');
        }
        if(dontNeedEncoding.get(':')) {
            dontNeedEncoding.clear(':');
        }
        byte [] buff = uri.getBytes(enc);
        for (int i = 0; i < buff.length; i++) {
            stringBuffer.append(char2Unicode((char)buff[i]));
        }
        return stringBuffer.toString();
    }

    public static String URLencoding(String url , String enc) throws UnsupportedEncodingException {
        int index = url.indexOf('?');
        StringBuffer result = new StringBuffer();
        if(index == -1) {
            result.append(URLEncoding(url, enc));
        }else {
            result.append(URLEncoding(url.substring(0 , index),enc));
            result.append("?");
            result.append(URIEncoding(url.substring(index+1),enc));
        }
        return result.toString();
    }

}

use el juego de caracteres " ISO-8859-1" para URLEncoder