Come devo evitare le stringhe in JSON?

Quando si creano manualmente i dati JSON, come devo evitare i campi stringa? Dovrei usare qualcosa di simile di Apache Commons Lang StringEscapeUtilities.escapeHtml, StringEscapeUtilities.escapeXmlo dovrei usare java.net.URLEncoder?

Il problema è che quando uso SEU.escapeHtml, non sfugge alle virgolette e quando avvolgo l'intera stringa in una coppia di 's, verrà generato un JSON non valido.

Idealmente, trova una libreria JSON nella tua lingua in cui puoi alimentare una struttura dati appropriata e lascia che si preoccupi di come sfuggire alle cose . Ti manterrà molto più sano. Se per qualsiasi motivo non hai una libreria nella tua lingua, non vuoi usarne una (non la suggerirei¹), o stai scrivendo una libreria JSON, continua a leggere.

Fuggire secondo la RFC. JSON è abbastanza liberale: Gli unici caratteri si deve fuggire sono \, "e codici di controllo (niente di meno che U + 0020).

Questa struttura di escape è specifica di JSON. Avrai bisogno di una funzione specifica JSON. Tutte le escape possono essere scritte come \uXXXXdove si XXXXtrova l'unità di codice UTF-16¹ per quel personaggio. Ci sono alcune scorciatoie, come \\, che funzionano anche. (E si traducono in un output più piccolo e più chiaro.)

Per i dettagli completi, consultare RFC .

¹ L'escaping di JSON è basato su JS, quindi utilizza \uXXXX, dove si XXXXtrova un'unità di codice UTF-16. Per i punti di codice al di fuori del BMP, ciò significa codificare coppie surrogate, che possono diventare un po 'pelose. (Oppure, puoi semplicemente generare direttamente il carattere, poiché JSON è codificato per essere testo Unicode e consente questi caratteri particolari.)

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

Prova questo org.codehaus.jettison.json.JSONObject.quote("your string").

Scaricalo qui: http://mvnrepository.com/artifact/org.codehaus.jettison/jettison

org.json.simple.JSONObject.escape () sfugge alle virgolette, \, /, \ r, \ n, \ b, \ f, \ te altri caratteri di controllo. Può essere usato per sfuggire ai codici JavaScript.

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

Apache Commons Lang ora supporta questo. Assicurati solo di avere una versione abbastanza recente delle lingue comuni di Apache sul tuo percorso di classe. Avrai bisogno della versione 3.2+

Note di rilascio per la versione 3.2

LANG-797: Aggiunto escape / unescapeJson a StringEscapeUtils.

org.json.JSONObject quote(String data) il metodo fa il lavoro

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

Estratto dalla documentazione:

Codifica i dati come una stringa JSON. Questo applica le virgolette e l'eventuale fuga di caratteri necessaria . [...] Null verrà interpretato come una stringa vuota

StringEscapeUtils.escapeJavaScript/ StringEscapeUtils.escapeEcmaScriptdovrei fare anche il trucco.

Se si utilizza fastexml jackson, è possibile utilizzare quanto segue: com.fasterxml.jackson.core.io.JsonStringEncoder.getInstance().quoteAsString(input)

Se si utilizza codehaus jackson, è possibile utilizzare quanto segue: org.codehaus.jackson.io.JsonStringEncoder.getInstance().quoteAsString(input)

Non sei sicuro di cosa intendi per "creazione manuale di json", ma puoi usare qualcosa come gson ( http://code.google.com/p/google-gson/ ) e che trasformerebbe il tuo HashMap, Array, String, ecc. , a un valore JSON. Consiglio di andare con un framework per questo.

Non ho speso il tempo per accertarmi al 100%, ma ha funzionato abbastanza per i miei input da essere accettato dai validatori JSON online:

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

anche se non sembra migliore di org.codehaus.jettison.json.JSONObject.quote("your string")

Uso semplicemente gli strumenti di velocità nel mio progetto: il mio edificio "manuale JSON" era all'interno di un modello di velocità

Per coloro che sono venuti qui alla ricerca di una soluzione da riga di comando, come me, il codice -data-urlencode di cURL funziona bene:

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

invia

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

, per esempio. I dati JSON più grandi possono essere inseriti in un file e useresti la sintassi @ per specificare un file da cui assimilare i dati da cui fuggire. Ad esempio, se

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

tu useresti

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

E ora, questo è anche un tutorial su come interrogare Freebase dalla riga di comando :-)

Utilizzare la classe EscapeUtils nell'API lang di commons.

EscapeUtils.escapeJavaScript("Your JSON string");

Considera la classe JsonWriter di Moshi . Ha un'API meravigliosa e riduce al minimo la copia, tutto può essere trasmesso in streaming su un archiviato, OutputStream, ecc.

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

Se vuoi la stringa in mano:

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

Apache commons-text ora ha StringEscapeUtils.escapeJson (String) .

Se devi uscire da JSON all'interno della stringa JSON, usa org.json.JSONObject.quote ("la tua stringa json che deve essere salvata") sembra funzionare bene

l'utilizzo della sintassi \ uXXXX può risolvere questo problema, google UTF-16 con il nome del segno, puoi scoprire XXXX, ad esempio: utf-16 double quote

I metodi qui che mostrano l'implementazione effettiva sono tutti difettosi.
Non ho un codice Java, ma solo per la cronaca, potresti facilmente convertire questo codice C #:

Per gentile concessione del 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();
}

Questo può essere compattato

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

Penso che la migliore risposta nel 2017 sia utilizzare le API javax.json. Usa javax.json.JsonBuilderFactory per creare i tuoi oggetti json, quindi scrivi gli oggetti usando javax.json.JsonWriterFactory. Molto bella combinazione costruttore / scrittore.