Como devo escapar de strings no JSON?

Ao criar dados JSON manualmente, como devo escapar dos campos de sequência? Devo usar algo como Apache Commons Lang StringEscapeUtilities.escapeHtml, StringEscapeUtilities.escapeXmlou eu deveria usarjava.net.URLEncoder ?

O problema é que, quando eu uso SEU.escapeHtml, ele não escapa aspas e quando envolvo toda a string em um par de 's, um JSON malformado será gerado.

Idealmente, encontre uma biblioteca JSON no seu idioma na qual você possa alimentar alguma estrutura de dados apropriada e deixe-a se preocupar com como escapar de coisas . Vai mantê-lo muito mais saudável. Se, por qualquer motivo, você não tiver uma biblioteca no seu idioma, não quiser usá-la (eu não sugeriria isso¹) ou estiver escrevendo uma biblioteca JSON, continue lendo.

Escape de acordo com a RFC. JSON é muito liberal: Os únicos caracteres que você deve escapar são \, "e códigos de controle (nada menos do que U + 0020).

Essa estrutura de escape é específica para JSON. Você precisará de uma função específica JSON. Todas as fugas podem ser escritas como \uXXXXonde XXXXestá a unidade de código UTF-16¹ para esse caractere. Existem alguns atalhos, como \\, que também funcionam. (E eles resultam em uma saída menor e mais clara.)

Para detalhes completos, consulte o RFC .

O escape de JSON é construído em JS, então ele usa \uXXXX, onde XXXXestá uma unidade de código UTF-16. Para pontos de código fora do BMP, isso significa codificar pares substitutos, o que pode ser um pouco complicado. (Ou, você pode simplesmente gerar o caractere diretamente, pois o JSON codificado para é texto Unicode e permite esses caracteres específicos.)

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

Tente isso org.codehaus.jettison.json.JSONObject.quote("your string").

Faça o download aqui: http://mvnrepository.com/artifact/org.codehaus.jettison/jettison

org.json.simple.JSONObject.escape () escapa aspas, \, /, \ r, \ n, \ b, \ f, \ te outros caracteres de controle. Pode ser usado para escapar dos códigos JavaScript.

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

O Apache commons lang agora suporta isso. Apenas verifique se você tem uma versão recente o suficiente do Apache commons em seu caminho de classe. Você precisará da versão 3.2 ou superior

Notas de versão da versão 3.2

LANG-797: Adicionado escape / unescapeJson no StringEscapeUtils.

org.json.JSONObject quote(String data) método faz o trabalho

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

Extrair da documentação:

Codifica dados como uma sequência JSON. Isso aplica aspas e qualquer caractere necessário escapando . [...] nulo será interpretado como uma string vazia

StringEscapeUtils.escapeJavaScriptEu também StringEscapeUtils.escapeEcmaScriptdeveria fazer o truque.

Se você estiver usando fastexml jackson, poderá usar o seguinte: com.fasterxml.jackson.core.io.JsonStringEncoder.getInstance().quoteAsString(input)

Se você estiver usando o codehaus jackson, poderá usar o seguinte: org.codehaus.jackson.io.JsonStringEncoder.getInstance().quoteAsString(input)

Não sei ao certo o que você quer dizer com "criando json manualmente", mas você pode usar algo como gson ( http://code.google.com/p/google-gson/ ), que transformaria seu HashMap, Array, String etc. , para um valor JSON. Eu recomendo ir com uma estrutura para isso.

Não gastei tempo para garantir 100% de certeza, mas funcionou para minhas entradas o suficiente para ser aceito pelos validadores JSON online:

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

embora não pareça melhor do que org.codehaus.jettison.json.JSONObject.quote("your string")

Eu simplesmente já uso ferramentas de velocidade no meu projeto - meu edifício "manual JSON" estava dentro de um modelo de velocidade

Para aqueles que vieram aqui procurando uma solução de linha de comando, como eu, o --data-urlencode do cURL funciona bem:

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

envia

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

, por exemplo. Dados JSON maiores podem ser colocados em um arquivo e você usaria a sintaxe @ para especificar um arquivo a ser coletado nos dados a serem escapados. Por exemplo, se

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

você usaria

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

E agora, este também é um tutorial sobre como consultar o Freebase na linha de comando :-)

Use a classe EscapeUtils na API comum.

EscapeUtils.escapeJavaScript("Your JSON string");

Considere a classe JsonWriter de Moshi . Possui uma API maravilhosa e reduz ao mínimo a cópia, tudo pode ser transmitido de maneira agradável para um arquivo, OutputStream etc.

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 você quer a corda na mão:

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

O texto comum do Apache agora possui um StringEscapeUtils.escapeJson (String) .

Se você precisar escapar do JSON dentro da string JSON, use org.json.JSONObject.quote ("sua string json que precisa ser escapada") parece funcionar bem

usando a sintaxe \ uXXXX pode resolver esse problema, google UTF-16 com o nome do sinal, você pode descobrir XXXX, por exemplo: utf-16 aspas duplas

Os métodos aqui que mostram a implementação real estão todos com defeito.
Eu não tenho código Java, mas apenas para o registro, você pode facilmente converter esse código C #:

Cortesia do mono-projeto @ 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();
}

Isso pode ser compactado em

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

Acho que a melhor resposta em 2017 é usar as APIs javax.json. Use javax.json.JsonBuilderFactory para criar seus objetos json e, em seguida, grave os objetos usando javax.json.JsonWriterFactory. Muito boa combinação de construtor / escritor.