parser - read json file java

¿Cómo debo escapar cadenas en JSON?

Question

Al crear datos JSON manualmente, ¿cómo debería escapar de los campos de cadena? ¿Debería usar algo como StringEscapeUtilities.escapeHtml de Apache Commons Lang, StringEscapeUtilities.escapeXml , o debería usar java.net.URLEncoder ?

El problema es que cuando uso SEU.escapeHtml , no escapa a las comillas y cuando SEU.escapeHtml toda la cadena en un par de '' s, se generará un JSON malformado.

Answer 1

Apache commons lang ahora es compatible con esto. Solo asegúrate de tener una versión reciente de Apache commons lang en tu classpath. Necesitarás la versión 3.2+

Notas de la versión para la versión 3.2

LANG-797: Se agregó escape / unescapeJson a StringEscapeUtils.

Answer 2

Considere la clase JsonWriter Moshi . Tiene una maravillosa API y reduce al mínimo la copia, todo se puede transmitir fácilmente a un archivo, 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();

Si quieres la cadena en la mano:

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

Answer 3

Creo que la mejor respuesta en 2017 es usar las API de javax.json. Use javax.json.JsonBuilderFactory para crear sus objetos JSON, luego escriba los objetos usando javax.json.JsonWriterFactory. Muy buena combinación constructor / escritor.

Answer 4

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

Answer 5

Idealmente, encuentre una biblioteca JSON en su idioma a la que pueda alimentar con una estructura de datos adecuada, y deje que se preocupe por cómo escapar de las cosas . Te mantendrá mucho más sano. Si por alguna razón no tienes una biblioteca en tu idioma, no quieres usar una (no sugeriría esto¹), o estás escribiendo una biblioteca JSON, sigue leyendo.

Escape de acuerdo con el RFC. JSON es bastante liberal: los únicos caracteres que debe escaparse son / , " y los códigos de control (cualquier cosa menor que U + 0020).

Esta estructura de escape es específica de JSON. Necesitarás una función específica de JSON. Todos los escapes se pueden escribir como /uXXXX donde XXXX es la unidad de código UTF-16¹ para ese personaje. Hay algunos atajos, como // , que también funcionan. (Y dan como resultado una salida más pequeña y más clara.)

Para detalles completos, vea ietf.org/rfc/rfc4627.txt .

EscaEl escape de JSON se basa en JS, por lo que usa /uXXXX , donde XXXX es una unidad de código UTF-16. Para los puntos de código fuera del BMP, esto significa codificar parejas sustitutas, que pueden ponerse un poco peludas. (O bien, puede simplemente generar el carácter directamente, ya que JSON está codificado para texto Unicode y permite estos caracteres en particular).

Answer 6

Los métodos aquí que muestran la implementación real son todos defectuosos.
No tengo el código de Java, pero para el registro, puedes convertir fácilmente este código de C #:

Cortesía del monoproyecto @ 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();
}

Esto puede ser compactado en

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

Answer 7

No estoy seguro de lo que quiere decir con "crear json manualmente", pero puede usar algo como gson ( http://code.google.com/p/google-gson/ ), y eso transformaría su HashMap, Array, String, etc. , a un valor JSON. Recomiendo ir con un marco para esto.

Answer 8

No me he tomado el tiempo para estar 100% seguro, pero funcionó para mis entradas lo suficiente como para ser aceptado por validadores JSON en línea:

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

aunque no se ve mejor que org.codehaus.jettison.json.JSONObject.quote("your string")

Simplemente uso herramientas de velocidad en mi proyecto ya - mi construcción "JSON manual" estaba dentro de una plantilla de velocidad

Answer 9

Para aquellos que vinieron aquí en busca de una solución de línea de comandos, como yo, cURL''s --data-urlencode funciona bien:

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

envía

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

, por ejemplo. Los datos de JSON más grandes se pueden poner en un archivo y se usaría la sintaxis @ para especificar un archivo para sorber en los datos de los que se debe escapar. Por ejemplo, si

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

usarías

curl -G -v -s --data-urlencode [email protected] ''https://www.googleapis.com/freebase/v1/mqlread''

Y ahora, este es también un tutorial sobre cómo consultar Freebase desde la línea de comando :-)

Answer 10

Pruebe este org.codehaus.jettison.json.JSONObject.quote("your string") .

Descárguelo aquí: http://mvnrepository.com/artifact/org.codehaus.jettison/jettison

Answer 11

Si está utilizando fastexml jackson, puede usar lo siguiente: com.fasterxml.jackson.core.io.JsonStringEncoder.getInstance().quoteAsString(input)

Si está utilizando codehaus jackson, puede usar lo siguiente: org.codehaus.jackson.io.JsonStringEncoder.getInstance().quoteAsString(input)

Answer 12

Si necesita escapar de JSON dentro de la cadena JSON, use org.json.JSONObject.quote ("su cadena json que necesita ser escapada") parece funcionar bien

Answer 13

Use la clase EscapeUtils en commons lang API.

EscapeUtils.escapeJavaScript("Your JSON string");

Answer 14

el uso de la sintaxis / uXXXX puede resolver este problema, google UTF-16 con el nombre del signo, puede encontrar XXXX, por ejemplo: utf-16 comillas dobles

Answer 15

org.json.simple.JSONObject.escape () escapa de las comillas, /, /, / r, / n, / b, / f, / t y otros caracteres de control. Se puede usar para escapar de códigos JavaScript.

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

Answer 16

StringEscapeUtils.escapeJavaScript / StringEscapeUtils.escapeEcmaScript debería funcionar.

Answer 17

org.json.JSONObject quote(String data) hace el trabajo

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

Extracto de la documentación:

Codifica los datos como una cadena JSON. Esto aplica comillas y cualquier personaje necesario que escape . [...] Nulo se interpretará como una cadena vacía