Java tương đương với mã hóa của JavaScript

Tôi đã thử nghiệm với nhiều đoạn mã Java khác nhau để cố gắng tìm ra thứ gì đó sẽ mã hóa một chuỗi chứa dấu ngoặc kép, dấu cách và các ký tự Unicode "kỳ lạ" và tạo ra đầu ra giống với hàm encodeURIComponent của JavaScript .

Chuỗi kiểm tra tra tấn của tôi là: "A" B ± "

Nếu tôi nhập câu lệnh JavaScript sau vào Firebug:

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

—Sau đó tôi nhận được:

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

Đây là chương trình Java thử nghiệm nhỏ của tôi:

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

—Chương trình này xuất ra:

URLEncoder.encode trả về% 22A% 22 + B +% C2% B1 +% 22
getBytes trả về "A" B ± "

Đóng, nhưng không có xì gà! Cách tốt nhất để mã hóa chuỗi UTF-8 bằng Java để nó tạo ra đầu ra giống như JavaScript là encodeURIComponentgì?

CHỈNH SỬA: Tôi đang sử dụng Java 1.4 sẽ sớm chuyển sang Java 5.

Nhìn vào sự khác biệt về triển khai, tôi thấy rằng:

MDC trênencodeURIComponent() :

• ký tự chữ (biểu diễn regex): [-a-zA-Z0-9._*~'()!]

Tài liệu Java 1.5.0 vềURLEncoder :

• ký tự chữ (biểu diễn regex): [-a-zA-Z0-9._*]
• ký tự khoảng trắng " "được chuyển đổi thành một dấu cộng "+".

Vì vậy, về cơ bản, để có được kết quả mong muốn, hãy sử dụng URLEncoder.encode(s, "UTF-8")và sau đó thực hiện một số xử lý hậu kỳ:

• thay thế tất cả các lần xuất hiện "+"bằng"%20"
• thay thế tất cả các lần xuất hiện "%xx"đại diện cho bất kỳ phần nào [~'()!]trở lại các bộ phận theo nghĩa đen của chúng

Cuối cùng thì đây là lớp tôi đã nghĩ ra:

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

Sử dụng công cụ javascript được vận chuyển với 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 ± \"'))");
    }
}

Sản lượng:% 22A% 22% 20B% 20% c2% b1% 20% 22

Trường hợp khác nhau nhưng nó gần với những gì bạn muốn.

Tôi sử dụng java.net.URI#getRawPath(), ví dụ

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

Giá trị của fixedý chí a+b%20c.htmllà những gì bạn muốn.

Hậu xử lý đầu ra của URLEncoder.encode()sẽ xóa bất kỳ điểm cộng nào được cho là có trong URI. Ví dụ

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

sẽ cung cấp cho bạn a%20b%20c.html, sẽ được hiểu là a b c.html.

Tôi đã nghĩ ra phiên bản encodeURIComponent của riêng mình, vì giải pháp đã đăng có một vấn đề, nếu có dấu + trong Chuỗi, cần được mã hóa, nó sẽ được chuyển đổi thành khoảng trắng.

Đây là lớp học của tôi:

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

Tôi đã nghĩ ra một triển khai khác được ghi lại tại, http://blog.sangupta.com/2010/05/encodeuricomponent-and.html . Việc triển khai cũng có thể xử lý các byte Unicode.

Tôi đã sử dụng thành công lớp java.net.URI như vậy:

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

Đây là một ví dụ đơn giản về giải pháp của 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();
    }
}

Đầu ra: https://www.website.com/document/Tom%20%26%20Jerry%20Manuscript.pdf

Nó cũng trả lời câu hỏi treo trong phần bình luận của Loren Shqipognja về cách chuyển một biến Chuỗi sang encodeURIComponent(). Phương thức scriptEngine.eval()trả về một Object, vì vậy nó có thể được chuyển đổi thành Chuỗi thông qua String.valueOf()giữa các phương thức khác.

đối với tôi điều này đã hoạt động:

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

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

hoặc với một UriBuilder khác

import javax.ws.rs.core.UriBuilder;

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

Theo tôi, sử dụng một thư viện tiêu chuẩn là một ý tưởng tốt hơn là xử lý bài viết theo cách thủ công. Ngoài ra, câu trả lời của @Chris có vẻ tốt, nhưng nó không hoạt động đối với các url, như " http: // a + b c.html"

Đây là những gì tôi đang sử dụng:

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

Nó vượt xa Javascript bằng cách mã hóa phần trăm mọi ký tự không phải là ký tự chưa được lưu trữ theo RFC 3986 .

Đây là chuyển đổi hỗn hợp:

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

Tôi đã tìm thấy lớp PercentEscaper từ thư viện google-http-java-client, có thể được sử dụng để triển khai encodeURIComponent khá dễ dàng.

Phần trămEcaper từ google-http-java-client javadoc google-http-java-client home

Thư viện ổi có PercentEscaper:

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

"-_. *" là các ký tự an toàn

false nói PercentEscaper để thoát không gian bằng '% 20', không phải '+'

Tôi đã sử dụng String encodedUrl = new URI(null, url, null).toASCIIString(); để mã hóa url. Để thêm các tham số sau những tham số hiện có trong urltôi sử dụngUriComponentsBuilder