Java equivalente ao encodeURIComponent do JavaScript que produz uma saída idêntica?

Eu tenho experimentado com vários pedaços de código Java tentando chegar a algo que irá codificar uma string contendo citações, espaços e caracteres Unicode “exóticos” e produzir uma saída idêntica à function encodeURIComponent do JavaScript.

Minha string de teste de tortura é: “A” B ± “

Se eu inserir a seguinte instrução JavaScript no Firebug:

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

– Então eu recebo:

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

Aqui está o meu pequeno programa Java de teste:

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

—Este programa produz:

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

Perto, mas sem charuto! Qual é a melhor maneira de codificar uma string UTF-8 usando Java para que ela produza a mesma saída que o encodeURIComponent do JavaScript?

EDIT: Eu estou usando o Java 1.4 movendo-se para o Java 5 em breve.

Olhando para as diferenças de implementação, vejo que:

MDC em encodeURIComponent() :

  • caracteres literais (representação em regex): [-a-zA-Z0-9._*~'()!]

Documentação do Java 1.5.0 no URLEncoder :

  • caracteres literais (representação em regex): [-a-zA-Z0-9._*]
  • o caractere de espaço " " é convertido em um sinal de adição "+" .

Então, basicamente, para obter o resultado desejado, use URLEncoder.encode(s, "UTF-8") e faça algum pós-processamento:

  • replace todas as ocorrências de "+" por "%20"
  • substitua todas as ocorrências de "%xx" representando qualquer de [~'()!] volta para suas contrapartes literais

Esta é a class que eu criei no final:

 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 decodeURIComponent function. Returns * null if the String is null. * * @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 encodeURIComponent function. Returns * null if the String is null. * * @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(); } } 

Usando o mecanismo de javascript fornecido com o 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 ± \"'))"); } }
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 ± \"'))"); } } 

Produção:% 22A% 22% 20B% 20% c2% b1% 20% 22

O caso é diferente, mas está mais próximo do que você quer.

Eu uso java.net.URI#getRawPath() , por exemplo

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

O valor de fixed será a+b%20c.html , que é o que você deseja.

Pós-processamento da saída de URLEncoder.encode() irá obliterar quaisquer vantagens que deveriam estar no URI. Por exemplo

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

lhe dará a%20b%20c.html , que será interpretado como ab c.html .

Eu criei minha própria versão do encodeURIComponent, porque a solução postada tem um problema, se houvesse um + presente no String, que deveria ser codificado, ele seria convertido em um espaço.

Então aqui está minha aula:

 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); // az for (int i = 97; i < = 122; ++i) { dontNeedEncoding.set(i); } // AZ 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 }; } } } 

Eu criei outra implementação documentada em http://blog.sangupta.com/2010/05/encodeuricomponent-and.html . A implementação também pode manipular bytes Unicode.

Eu encontrei a class PercentEscaper da biblioteca google-http-java-client, que pode ser usada para implementar o encodeURIComponent facilmente.

PercentEscaper do google-http-java-cliente javadoc google-http-java-client home

Eu usei com sucesso a class java.net.URI da seguinte forma:

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

Este é um exemplo direto da solução de 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(); } } 

Saída: https://www.website.com/document/Tom%20%26%20Jerry%20Manuscript.pdf

Ele também responde à pergunta pendente nos comentários de Loren Shqipognja sobre como passar uma variável String para encodeURIComponent() . O método scriptEngine.eval() retorna um Object , então ele pode ser convertido para String via String.valueOf() entre outros methods.

para mim isso funcionou:

 import org.apache.http.client.utils.URIBuilder; String encodedString = new URIBuilder() .setParameter("i", stringToEncode) .build() .getRawQuery() // output: i=encodedString .substring(2); 

ou com um UriBuilder diferente

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

Na minha opinião, usar uma biblioteca padrão é uma ideia melhor do que postar manualmente. Também a resposta do @Chris parecia boa, mas não funciona para URLs, como ” http: // a + b c.html”

Biblioteca de goiaba tem PercentEscaper:

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

“-_. *” são caracteres seguros

false diz PercentEscaper para escaping do espaço com ‘% 20’, não ‘+’