unicode jframe - Java entspricht der EncDEURIComponent von JavaScript, die identische Ausgabe produziert?




showmessagedialog joptionpane (10)

Ich habe eine andere Implementierung gefunden, die unter http://blog.sangupta.com/2010/05/encodeuricomponent-and.html dokumentiert ist. Die Implementierung kann auch Unicode-Bytes verarbeiten.

Ich habe mit verschiedenen Teilen von Java-Code experimentiert und versucht, etwas zu finden, das eine Zeichenfolge mit Anführungszeichen, Leerzeichen und "exotischen" Unicode-Zeichen codiert und eine Ausgabe erzeugt, die identisch mit der encodeURIComponent Funktion von JavaScript ist.

Meine Folter-Testreihe ist: "A" B ± "

Wenn ich die folgende JavaScript-Anweisung in Firebug eingeben:

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

-Dann bekomme ich:

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

Hier ist mein kleines Java-Testprogramm:

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

-Dieses Programm gibt aus:

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

Schließen, aber keine Zigarre! Was ist der beste Weg, um eine UTF-8-Zeichenkette mit Java zu kodieren, so dass sie dieselbe Ausgabe wie die encodeURIComponent JavaScript encodeURIComponent ?

BEARBEITEN: Ich benutze Java 1.4, das in Kürze zu Java 5 umzieht.


Dies ist ein einfaches Beispiel Ravi Wallaus Lösung:

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

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

Es beantwortet auch die hängenden Fragen in den Kommentaren von Loren Shqipognja, wie eine String-Variable an encodeURIComponent() . Die Methode scriptEngine.eval() gibt ein Object , so dass es unter anderem auch über String.valueOf() in String konvertiert werden kann.


Betrachtet man die Implementierungsunterschiede, sehe ich Folgendes:

encodeURIComponent :

  • [-a-zA-Z0-9._*~'()!] Zeichen (Regex-Darstellung): [-a-zA-Z0-9._*~'()!]

Java 1.5.0 Dokumentation zu URLEncoder :

  • [-a-zA-Z0-9._*] Zeichen (Regex-Darstellung): [-a-zA-Z0-9._*]
  • Das Leerzeichen " " wird in ein Pluszeichen "+" .

Um das gewünschte Ergebnis zu erhalten, benutzen Sie URLEncoder.encode(s, "UTF-8") und machen Sie dann eine Nachbearbeitung:

  • Ersetze alle Vorkommen von "+" durch "%20"
  • Ersetze alle Vorkommen von "%xx" die irgendeines von [~'()!] repräsentieren, zurück in ihre wörtlichen Gegenstücke

Ich habe erfolgreich die Klasse java.net.URI wie folgt verwendet:

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

für mich hat das geklappt:

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

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

oder mit einem anderen UriBuilder

import javax.ws.rs.core.UriBuilder;

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

Meiner Meinung nach ist die Verwendung einer Standardbibliothek eine bessere Idee als die manuelle Nachbearbeitung. Auch @Chris Antwort sah gut aus, aber es funktioniert nicht für URLs, wie " http://a+b c.html"


Ich benutze java.net.URI#getRawPath() , zB

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

Der Wert von fixed ist a+b%20c.html , was Sie wollen.

Nach der Verarbeitung der Ausgabe von URLEncoder.encode() werden alle Pluspunkte gelöscht, die in der URI enthalten sein sollen. Beispielsweise

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

gibt Ihnen a%20b%20c.html , die als ab c.html interpretiert ab c.html .


Verwenden der JavaScript Engine, die mit Java 6 ausgeliefert wird:


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

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

Der Fall ist anders, aber es ist näher an dem, was Sie wollen.


Das ist die Klasse, die ich am Ende gefunden habe:

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

/**
 * Utility class for JavaScript compatible UTF-8 encoding and decoding.
 * 
 * @see http://.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();
  }
}


Im Gegensatz zu dem, was die meisten veröffentlichen, ist dies KEINE IDE-Sache. Es ist eine Sprachsache. Die # Region ist eine C # -Anweisung.





java javascript unicode utf-8