Jak uciec przed ciągami znaków w JSON?

Podczas ręcznego tworzenia danych JSON, jak zmienić znaczenie pól tekstowych? Należy używać coś jak Apache Commons Langa StringEscapeUtilities.escapeHtml, StringEscapeUtilities.escapeXmlczy powinienem użyć java.net.URLEncoder?

Problem polega na tym, że kiedy używam SEU.escapeHtml, nie unikam cudzysłowów, a kiedy zawijam cały ciąg parą 's, zostanie wygenerowany zniekształcony JSON.

Najlepiej byłoby znaleźć bibliotekę JSON w swoim języku , do której można wprowadzić odpowiednią strukturę danych, i pozwolić jej martwić się, jak uciec . Dzięki temu będziesz zdrowszy. Jeśli z jakiegoś powodu nie masz biblioteki w swoim języku, nie chcesz jej używać (nie sugerowałbym tego¹) lub piszesz bibliotekę JSON, czytaj dalej.

Ucieknij zgodnie z RFC. JSON jest dość liberalny: Tylko znaki muszą uciec się \, "oraz kody sterujące (coś mniej niż U + 0020).

Ta struktura ucieczki jest specyficzna dla formatu JSON. Będziesz potrzebować funkcji specyficznej dla JSON. Wszystkie znaki ucieczki można zapisać jako \uXXXXgdzie XXXXjest jednostka kodu UTF-16¹ dla tego znaku. Istnieje kilka skrótów, na przykład \\, które również działają. (I skutkują mniejszym i wyraźniejszym wyjściem).

Aby uzyskać szczegółowe informacje, zobacz RFC .

¹JSON's Escaping jest oparty na JS, więc używa \uXXXX, gdzie XXXXjest jednostką kodu UTF-16. W przypadku punktów kodowych poza BMP oznacza to kodowanie par zastępczych, które mogą być nieco owłosione. (Lub możesz po prostu wyprowadzić znak bezpośrednio, ponieważ kod JSON jest kodowany w formacie Unicode i zezwala na te określone znaki).

Wyciąg z Jettison :

 public static String quote(String string) {
         if (string == null || string.length() == 0) {
             return "\"\"";
         }

         char         c = 0;
         int          i;
         int          len = string.length();
         StringBuilder sb = new StringBuilder(len + 4);
         String       t;

         sb.append('"');
         for (i = 0; i < len; i += 1) {
             c = string.charAt(i);
             switch (c) {
             case '\\':
             case '"':
                 sb.append('\\');
                 sb.append(c);
                 break;
             case '/':
 //                if (b == '<') {
                     sb.append('\\');
 //                }
                 sb.append(c);
                 break;
             case '\b':
                 sb.append("\\b");
                 break;
             case '\t':
                 sb.append("\\t");
                 break;
             case '\n':
                 sb.append("\\n");
                 break;
             case '\f':
                 sb.append("\\f");
                 break;
             case '\r':
                sb.append("\\r");
                break;
             default:
                 if (c < ' ') {
                     t = "000" + Integer.toHexString(c);
                     sb.append("\\u" + t.substring(t.length() - 4));
                 } else {
                     sb.append(c);
                 }
             }
         }
         sb.append('"');
         return sb.toString();
     }

Spróbuj tego org.codehaus.jettison.json.JSONObject.quote("your string").

Pobierz go tutaj: http://mvnrepository.com/artifact/org.codehaus.jettison/jettison

org.json.simple.JSONObject.escape () chroni przed cudzysłowami, \, /, \ r, \ n, \ b, \ f, \ t i innymi znakami sterującymi. Może być używany do ucieczki przed kodami JavaScript.

import org.json.simple.JSONObject;
String test =  JSONObject.escape("your string");

Apache commons lang teraz to obsługuje. Tylko upewnij się, że masz wystarczająco aktualną wersję Apache commons lang w swojej ścieżce klas. Będziesz potrzebować wersji 3.2+

Uwagi do wydania dla wersji 3.2

LANG-797: Dodano escape / unescapeJson do StringEscapeUtils.

org.json.JSONObject quote(String data) metoda spełnia swoje zadanie

import org.json.JSONObject;
String jsonEncodedString = JSONObject.quote(data);

Wyciąg z dokumentacji:

Koduje dane jako ciąg JSON. Dotyczy to cudzysłowów i wszelkich niezbędnych znaków ucieczki . [...] Null zostanie zinterpretowane jako pusty ciąg

StringEscapeUtils.escapeJavaScript/ też StringEscapeUtils.escapeEcmaScriptpowinien załatwić sprawę.

Jeśli używasz fastexml jackson, możesz użyć następujących: com.fasterxml.jackson.core.io.JsonStringEncoder.getInstance().quoteAsString(input)

Jeśli używasz codehaus jackson, możesz użyć: org.codehaus.jackson.io.JsonStringEncoder.getInstance().quoteAsString(input)

Nie jestem pewien, co masz na myśli, mówiąc „ręczne tworzenie pliku json”, ale możesz użyć czegoś takiego jak gson ( http://code.google.com/p/google-gson/ ), a to przekształci Twoją HashMap, Array, String itp. na wartość JSON. Zalecam wybranie do tego ram.

Nie poświęciłem czasu na upewnienie się w 100%, ale zadziałało na tyle, że moje dane wejściowe zostały zaakceptowane przez internetowe walidatory JSON:

org.apache.velocity.tools.generic.EscapeTool.EscapeTool().java("input")

chociaż nie wygląda lepiej niż org.codehaus.jettison.json.JSONObject.quote("your string")

Po prostu używam już narzędzi dynamicznych w moim projekcie - moje „ręczne budowanie JSON” odbywało się w szablonie szybkości

Dla tych, którzy przybyli tutaj, szukając rozwiązania wiersza poleceń, jak ja, cURL --data-urlencode działa dobrze:

curl -G -v -s --data-urlencode 'query={"type" : "/music/artist"}' 'https://www.googleapis.com/freebase/v1/mqlread'

wysyła

GET /freebase/v1/mqlread?query=%7B%22type%22%20%3A%20%22%2Fmusic%2Fartist%22%7D HTTP/1.1

, na przykład. Większe dane JSON można umieścić w pliku i można użyć składni @, aby określić plik do slurp w danych, z których mają zostać usunięte zmiany znaczenia. Na przykład, jeśli

$ cat 1.json 
{
  "type": "/music/artist",
  "name": "The Police",
  "album": []
}

użyłbyś

curl -G -v -s --data-urlencode query@1.json 'https://www.googleapis.com/freebase/v1/mqlread'

A teraz jest to również samouczek dotyczący wysyłania zapytań do Freebase z wiersza poleceń :-)

Użyj klasy EscapeUtils we wspólnym interfejsie API.

EscapeUtils.escapeJavaScript("Your JSON string");

Rozważmy Moshi „s JsonWriter klasę. Ma cudowne API i ogranicza kopiowanie do minimum, wszystko można ładnie przesyłać strumieniowo do pliku, OutputStream itp.

OutputStream os = ...;
JsonWriter json = new JsonWriter(Okio.buffer(Okio.sink(os)));
json.beginObject();
json.name("id").value(getId());
json.name("scores");
json.beginArray();
for (Double score : getScores()) {
  json.value(score);
}
json.endArray();
json.endObject();

Jeśli chcesz mieć sznurek w dłoni:

Buffer b = new Buffer(); // okio.Buffer
JsonWriter writer = new JsonWriter(b);
//...
String jsonString = b.readUtf8();

Apache commons-text ma teraz StringEscapeUtils.escapeJson (String) .

Jeśli chcesz pominąć JSON w ciągu JSON, użyj org.json.JSONObject.quote („Twój ciąg json, który wymaga zmiany znaczenia”) wydaje się działać dobrze

używając składni \ uXXXX możesz rozwiązać ten problem, google UTF-16 z nazwą znaku, możesz znaleźć XXXX, na przykład: podwójny cudzysłów utf-16

Wszystkie metody pokazujące rzeczywistą implementację są wadliwe.
Nie mam kodu Java, ale dla przypomnienia, możesz łatwo przekonwertować ten kod C #:

Dzięki uprzejmości mono-project @ https://github.com/mono/mono/blob/master/mcs/class/System.Web/System.Web/HttpUtility.cs

public static string JavaScriptStringEncode(string value, bool addDoubleQuotes)
{
    if (string.IsNullOrEmpty(value))
        return addDoubleQuotes ? "\"\"" : string.Empty;

    int len = value.Length;
    bool needEncode = false;
    char c;
    for (int i = 0; i < len; i++)
    {
        c = value[i];

        if (c >= 0 && c <= 31 || c == 34 || c == 39 || c == 60 || c == 62 || c == 92)
        {
            needEncode = true;
            break;
        }
    }

    if (!needEncode)
        return addDoubleQuotes ? "\"" + value + "\"" : value;

    var sb = new System.Text.StringBuilder();
    if (addDoubleQuotes)
        sb.Append('"');

    for (int i = 0; i < len; i++)
    {
        c = value[i];
        if (c >= 0 && c <= 7 || c == 11 || c >= 14 && c <= 31 || c == 39 || c == 60 || c == 62)
            sb.AppendFormat("\\u{0:x4}", (int)c);
        else switch ((int)c)
            {
                case 8:
                    sb.Append("\\b");
                    break;

                case 9:
                    sb.Append("\\t");
                    break;

                case 10:
                    sb.Append("\\n");
                    break;

                case 12:
                    sb.Append("\\f");
                    break;

                case 13:
                    sb.Append("\\r");
                    break;

                case 34:
                    sb.Append("\\\"");
                    break;

                case 92:
                    sb.Append("\\\\");
                    break;

                default:
                    sb.Append(c);
                    break;
            }
    }

    if (addDoubleQuotes)
        sb.Append('"');

    return sb.ToString();
}

Można to zagęścić w

    // https://github.com/mono/mono/blob/master/mcs/class/System.Json/System.Json/JsonValue.cs
public class SimpleJSON
{

    private static  bool NeedEscape(string src, int i)
    {
        char c = src[i];
        return c < 32 || c == '"' || c == '\\'
            // Broken lead surrogate
            || (c >= '\uD800' && c <= '\uDBFF' &&
                (i == src.Length - 1 || src[i + 1] < '\uDC00' || src[i + 1] > '\uDFFF'))
            // Broken tail surrogate
            || (c >= '\uDC00' && c <= '\uDFFF' &&
                (i == 0 || src[i - 1] < '\uD800' || src[i - 1] > '\uDBFF'))
            // To produce valid JavaScript
            || c == '\u2028' || c == '\u2029'
            // Escape "</" for <script> tags
            || (c == '/' && i > 0 && src[i - 1] == '<');
    }



    public static string EscapeString(string src)
    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();

        int start = 0;
        for (int i = 0; i < src.Length; i++)
            if (NeedEscape(src, i))
            {
                sb.Append(src, start, i - start);
                switch (src[i])
                {
                    case '\b': sb.Append("\\b"); break;
                    case '\f': sb.Append("\\f"); break;
                    case '\n': sb.Append("\\n"); break;
                    case '\r': sb.Append("\\r"); break;
                    case '\t': sb.Append("\\t"); break;
                    case '\"': sb.Append("\\\""); break;
                    case '\\': sb.Append("\\\\"); break;
                    case '/': sb.Append("\\/"); break;
                    default:
                        sb.Append("\\u");
                        sb.Append(((int)src[i]).ToString("x04"));
                        break;
                }
                start = i + 1;
            }
        sb.Append(src, start, src.Length - start);
        return sb.ToString();
    }
}

Myślę, że najlepszą odpowiedzią w 2017 roku jest użycie interfejsów API javax.json. Użyj javax.json.JsonBuilderFactory, aby utworzyć obiekty json, a następnie wypisz obiekty przy użyciu javax.json.JsonWriterFactory. Bardzo fajne połączenie konstruktora / pisarza.