Java equivalente al componente encodeURIC di JavaScript che produce un output identico?

Question

Ho sperimentato vari frammenti di codice Java cercando di trovare qualcosa che codificherà una stringa contenente virgolette, spazi e "esotici"; Caratteri Unicode e produzione di output identici alla funzione encodeURIComponent di JavaScript.

La mia stringa di test di tortura è: " A " B ± "

Se entro in Firebug inserisco la seguente dichiarazione JavaScript:

encodeURIComponent('"A" B ± "');

—Quindi ottengo:

"%22A%22%20B%20%C2%B1%20%22"

Ecco il mio piccolo programma Java di prova:

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class EncodingTest
{
  public static void main(String[] args) throws UnsupportedEncodingException
  {
    String s = "\"A\" B ± \"";
    System.out.println("URLEncoder.encode returns "
      + URLEncoder.encode(s, "UTF-8"));

    System.out.println("getBytes returns "
      + new String(s.getBytes("UTF-8"), "ISO-8859-1"));
  }
}

: output di questo programma:

URLEncoder.encode returns %22A%22+B+%C2%B1+%22
getBytes returns "A" B ± "

Chiudi, ma niente sigaro! Qual è il modo migliore per codificare una stringa UTF-8 usando Java in modo che produca lo stesso output del encodeURIComponent di JavaScript?

EDIT: sto usando Java 1.4 per passare a Java 5 a breve.

Answer 1

Osservando le differenze di implementazione, vedo che:

MDC su encodeURIComponent () :

• caratteri letterali (rappresentazione regex): [-a-zA-Z0-9._*~'()![

Documentazione Java 1.5.0 su URLEncoder :

• caratteri letterali (rappresentazione regex): [-a-zA-Z0-9._*[
• il carattere spazio " " viene convertito in un segno più " + " .

Quindi, in pratica, per ottenere il risultato desiderato, usa URLEncoder.encode (s, " UTF-8 ") e poi fai un po 'di post-elaborazione:

• sostituisce tutte le occorrenze di " + " con "%20"
• sostituisce tutte le occorrenze di "% xx " che rappresenta una delle [~ '()!] torna alle loro controparti letterali

Answer 2

Questa è la classe che mi è venuta in mente alla fine:

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

/**
 * Utility class for JavaScript compatible UTF-8 encoding and decoding.
 * 
 * @see http://stackoverflow.com/questions/607176/java-equivalent-to-javascripts-encodeuricomponent-that-produces-identical-output
 * @author John Topley 
 */
public class EncodingUtil
{
  /**
   * Decodes the passed UTF-8 String using an algorithm that's compatible with
   * JavaScript's <code>decodeURIComponent</code> function. Returns
   * <code>null</code> if the String is <code>null</code>.
   *
   * @param s The UTF-8 encoded String to be decoded
   * @return the decoded String
   */
  public static String decodeURIComponent(String s)
  {
    if (s == null)
    {
      return null;
    }

    String result = null;

    try
    {
      result = URLDecoder.decode(s, "UTF-8");
    }

    // This exception should never occur.
    catch (UnsupportedEncodingException e)
    {
      result = s;  
    }

    return result;
  }

  /**
   * Encodes the passed String as UTF-8 using an algorithm that's compatible
   * with JavaScript's <code>encodeURIComponent</code> function. Returns
   * <code>null</code> if the String is <code>null</code>.
   * 
   * @param s The String to be encoded
   * @return the encoded String
   */
  public static String encodeURIComponent(String s)
  {
    String result = null;

    try
    {
      result = URLEncoder.encode(s, "UTF-8")
                         .replaceAll("\\+", "%20")
                         .replaceAll("\\%21", "!")
                         .replaceAll("\\%27", "'")
                         .replaceAll("\\%28", "(")
                         .replaceAll("\\%29", ")")
                         .replaceAll("\\%7E", "~");
    }

    // This exception should never occur.
    catch (UnsupportedEncodingException e)
    {
      result = s;
    }

    return result;
  }  

  /**
   * Private constructor to prevent this class from being instantiated.
   */
  private EncodingUtil()
  {
    super();
  }
}

Answer 3

Utilizzo del motore javascript fornito con Java 6:

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class Wow
{
    public static void main(String[] args) throws Exception
    {
        ScriptEngineManager factory = new ScriptEngineManager();
        ScriptEngine engine = factory.getEngineByName("JavaScript");
        engine.eval("print(encodeURIComponent('\"A\" B ± \"'))");
    }
}

Output:% 22A% 22% 20B% 20% c2% b1% 20% 22

Il caso è diverso ma è più vicino a quello che vuoi.

Answer 4

Uso java.net.URI # getRawPath () , ad esempio

String s = "a+b c.html";
String fixed = new URI(null, null, s, null).getRawPath();

Il valore di fixed sarà a + b% 20c.html , che è quello che vuoi.

Post-elaborazione dell'output di URLEncoder.encode () cancellerà tutti i plus che si suppone siano nell'URI. Ad esempio

URLEncoder.encode("a+b c.html").replaceAll("\\+", "%20");

ti darà a% 20b% 20c.html , che sarà interpretato come a b c.html .

Answer 5

Mi è venuta in mente la mia versione del componente encodeURIC, perché la soluzione pubblicata ha un problema, se nella stringa c'era un +, che dovrebbe essere codificato, verrà convertito in uno spazio.

Quindi ecco la mia classe:

import java.io.UnsupportedEncodingException;
import java.util.BitSet;

public final class EscapeUtils
{
    /** used for the encodeURIComponent function */
    private static final BitSet dontNeedEncoding;

    static
    {
        dontNeedEncoding = new BitSet(256);

        // a-z
        for (int i = 97; i <= 122; ++i)
        {
            dontNeedEncoding.set(i);
        }
        // A-Z
        for (int i = 65; i <= 90; ++i)
        {
            dontNeedEncoding.set(i);
        }
        // 0-9
        for (int i = 48; i <= 57; ++i)
        {
            dontNeedEncoding.set(i);
        }

        // '()*
        for (int i = 39; i <= 42; ++i)
        {
            dontNeedEncoding.set(i);
        }
        dontNeedEncoding.set(33); // !
        dontNeedEncoding.set(45); // -
        dontNeedEncoding.set(46); // .
        dontNeedEncoding.set(95); // _
        dontNeedEncoding.set(126); // ~
    }

    /**
     * A Utility class should not be instantiated.
     */
    private EscapeUtils()
    {

    }

    /**
     * Escapes all characters except the following: alphabetic, decimal digits, - _ . ! ~ * ' ( )
     * 
     * @param input
     *            A component of a URI
     * @return the escaped URI component
     */
    public static String encodeURIComponent(String input)
    {
        if (input == null)
        {
            return input;
        }

        StringBuilder filtered = new StringBuilder(input.length());
        char c;
        for (int i = 0; i < input.length(); ++i)
        {
            c = input.charAt(i);
            if (dontNeedEncoding.get(c))
            {
                filtered.append(c);
            }
            else
            {
                final byte[] b = charToBytesUTF(c);

                for (int j = 0; j < b.length; ++j)
                {
                    filtered.append('%');
                    filtered.append("0123456789ABCDEF".charAt(b[j] >> 4 & 0xF));
                    filtered.append("0123456789ABCDEF".charAt(b[j] & 0xF));
                }
            }
        }
        return filtered.toString();
    }

    private static byte[] charToBytesUTF(char c)
    {
        try
        {
            return new String(new char[] { c }).getBytes("UTF-8");
        }
        catch (UnsupportedEncodingException e)
        {
            return new byte[] { (byte) c };
        }
    }
}

Answer 6

Ho trovato un'altra implementazione documentata su http: //blog.sangupta .com / 2010/05 / encodeURIComponent-and.html . L'implementazione può anche gestire byte Unicode.

Answer 7

Questo è un semplice esempio della soluzione di Ravi Wallau:

public String buildSafeURL(String partialURL, String documentName)
        throws ScriptException {
    ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    ScriptEngine scriptEngine = scriptEngineManager
            .getEngineByName("JavaScript");

    String urlSafeDocumentName = String.valueOf(scriptEngine
            .eval("encodeURIComponent('" + documentName + "')"));
    String safeURL = partialURL + urlSafeDocumentName;

    return safeURL;
}

public static void main(String[] args) {
    EncodeURIComponentDemo demo = new EncodeURIComponentDemo();
    String partialURL = "https://www.website.com/document/";
    String documentName = "Tom & Jerry Manuscript.pdf";

    try {
        System.out.println(demo.buildSafeURL(partialURL, documentName));
    } catch (ScriptException se) {
        se.printStackTrace();
    }
}

Output: https://www.website.com/document/Tom%20%26%20Jerry%20Manuscript.pdf

Risponde anche alla domanda sospesa nei commenti di Loren Shqipognja su come passare una variabile String a encodeURIComponent () . Il metodo scriptEngine.eval () restituisce un Object , quindi può essere convertito in String tramite String.valueOf () tra gli altri metodi.

Answer 8

Questo è quello che sto usando:

private static final String HEX = "0123456789ABCDEF";

public static String encodeURIComponent(String str) {
    if (str == null) return null;

    byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
    StringBuilder builder = new StringBuilder(bytes.length);

    for (byte c : bytes) {
        if (c >= 'a' ? c <= 'z' || c == '~' :
            c >= 'A' ? c <= 'Z' || c == '_' :
            c >= '0' ? c <= '9' :  c == '-' || c == '.')
            builder.append((char)c);
        else
            builder.append('%')
                   .append(HEX.charAt(c >> 4 & 0xf))
                   .append(HEX.charAt(c & 0xf));
    }

    return builder.toString();
}

Va ??oltre Javascript codificando in percentuale ogni carattere che non è un personaggio senza prenotazione secondo RFC 3986 .

---

Questa è la conversione opposta:

public static String decodeURIComponent(String str) {
    if (str == null) return null;

    int length = str.length();
    byte[] bytes = new byte[length / 3];
    StringBuilder builder = new StringBuilder(length);

    for (int i = 0; i < length; ) {
        char c = str.charAt(i);
        if (c != '%') {
            builder.append(c);
            i += 1;
        } else {
            int j = 0;
            do {
                char h = str.charAt(i + 1);
                char l = str.charAt(i + 2);
                i += 3;

                h -= '0';
                if (h >= 10) {
                    h |= ' ';
                    h -= 'a' - '0';
                    if (h >= 6) throw new IllegalArgumentException();
                    h += 10;
                }

                l -= '0';
                if (l >= 10) {
                    l |= ' ';
                    l -= 'a' - '0';
                    if (l >= 6) throw new IllegalArgumentException();
                    l += 10;
                }

                bytes[j++] = (byte)(h << 4 | l);
                if (i >= length) break;
                c = str.charAt(i);
            } while (c == '%');
            builder.append(new String(bytes, 0, j, UTF_8));
        }
    }

    return builder.toString();
}

Answer 9

Ho trovato la classe PercentEscaper dalla libreria google-http-java-client, che può essere utilizzata abbastanza facilmente per implementare encodeURIComponent.

PercentEscaper da google-http-java-client javadoc home page di google-http-java-client

Answer 10

Ho usato con successo la classe java.net.URI in questo modo:

public static String uriEncode(String string) {
    String result = string;
    if (null != string) {
        try {
            String scheme = null;
            String ssp = string;
            int es = string.indexOf(':');
            if (es > 0) {
                scheme = string.substring(0, es);
                ssp = string.substring(es + 1);
            }
            result = (new URI(scheme, ssp, null)).toString();
        } catch (URISyntaxException usex) {
            // ignore and use string that has syntax error
        }
    }
    return result;
}

Answer 11

per me ha funzionato:

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

String encodedString = new URIBuilder()
  .setParameter("i", stringToEncode)
  .build()
  .getRawQuery() // output: i=encodedString
  .substring(2);

o con un UriBuilder diverso

import javax.ws.rs.core.UriBuilder;

String encodedString = UriBuilder.fromPath("")
  .queryParam("i", stringToEncode)
  .toString()   // output: ?i=encodedString
  .substring(3);

Secondo me l'uso di una libreria standard è un'idea migliore piuttosto che post-elaborazione manuale. Anche la risposta di @Chris sembrava buona, ma non funziona per gli URL, come " http: // a + b c.html "

Answer 12

La libreria Guava ha PercentEscaper:

Escaper percentEscaper = new PercentEscaper (" -_. * " ;, false);

". -_ * " sono personaggi sicuri

false dice PercentEscaper per sfuggire allo spazio con '% 20', non '+'