MalformedJsonException with Retrofit API?

Question

Ho bisogno di inviare un JSON al mio webservice, JSON è:

{ 
    "Sala": { 
     "usuario": "%@", 
     "adversario": "%@", 
     "atualizacao": "%@", 
     "device": "%@", 
     "device_tipo": "ios" 
    } 
} 

. Sto provando a farlo usando Retrofit API 1.8. Quando provo a inviare il post genera un'eccezione.

Eccezione:

com.google.gson.JsonSyntaxException: com.google.gson.stream.MalformedJsonException: Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 7 path $ 

sto cercando questo

public class ChatObject { 
    private String usuario; 
    private String adversario; 
    private String atualizacao; 
    private String email; 
    private String device; 
    private String device_tipo; 

Retrofit interfaccia

@POST("/WsChat/interacao.json") 
    public void onReceiveMessage(@Body ChatObject obj, 
           Callback<JsonElement> response); 

Utensili

public void receiveMessage(){ 
    ///{\"Sala\":{\"usuario\":\"%@\",\"adversario\":\"%@\",\"atualizacao\":\"%@\",\"device\":\"%@\",\"device_tipo\":\"ios\"}} 
    ChatObject chatObject = new ChatObject(BatalhaConfigs.USUARIO_EMAIL, 
              BatalhaConfigs.ADVERSARIO_EMAIL, 
              new Date().toString(), 
              BatalhaConfigs.USUARIO_EMAIL, 
              AndroidReturnId.getAndroidId(), 
              "android"); 

    RestAdapter adapter = new RestAdapter.Builder() 
      .setLogLevel(RestAdapter.LogLevel.FULL) 
      .setRequestInterceptor(new CustomRequestInterceptor()) 
      .setEndpoint(END_POINT) 
      .build(); 
    ChatListener listener = adapter.create(ChatListener.class); 
    listener.onReceiveMessage(chatObject, new Callback<JsonElement>() { 
     @Override 
     public void success(JsonElement jsonElement, retrofit.client.Response response) { 
      Log.i("JSON ELEMENT->", jsonElement.toString()); 
     } 

     @Override 
     public void failure(RetrofitError error) { 
      Log.i("FALHOU->", error.getLocalizedMessage()); 

     } 
    }); 
} 

Answer 1

com.google.gson.JsonSyntaxException: com.google.gson.stream.MalformedJsonException: Use JsonReader.setLenient(true) è di solito gettati quando c'è qualche personaggio (s) che malforms il JSON. Il messaggio di eccezione suggerisce di rendere la deserializzazione più tollerante.

Ma ti suggerisco di sistemare il tuo JSON e tagliarlo da caratteri indesiderati.

È necessario estendere GsonConverter e ignorare fromBody() per rendere letto dalla tolleranza JsonReader. Quindi basta impostarlo sul tuo RestAdapter. Questo tenterà di usare il tollerante JsonReader per deserializzare e quindi chiuderlo, se non viene lanciata un'eccezione.

public class LenientGsonConverter extends GsonConverter { 
private Gson mGson; 

public LenientGsonConverter(Gson gson) { 
    super(gson); 
    mGson = gson; 
} 

public LenientGsonConverter(Gson gson, String charset) { 
    super(gson, charset); 
    mGson = gson; 
} 

@Override 
public Object fromBody(TypedInput body, Type type) throws ConversionException { 
    boolean willCloseStream = false; // try to close the stream, if there is no exception thrown using tolerant JsonReader 
    try { 
     JsonReader jsonReader = new JsonReader(new InputStreamReader(body.in())); 
     jsonReader.setLenient(true); 
     Object o = mGson.fromJson(jsonReader,type); 
     willCloseStream = true; 
     return o; 
    } catch (IOException e) { 
     e.printStackTrace(); 
    }finally { 
     if(willCloseStream) { 
      closeStream(body); 
     } 
    } 

    return super.fromBody(body, type); 
} 

private void closeStream(TypedInput body){ 
     try { 
      InputStream in = body.in(); 
      in.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

}

Answer 2

Si dovrebbe contribuire a questo codice:

RestAdapter restAdapter = new RestAdapter.Builder() 
       .setEndpoint("http://192.168.10.115/test.php") 
       .setConverter(new GsonConverter(new Gson())) 
       .build(); 

Put file jar:

[gson-2.2.2.jar][1] 

Answer 3

RestAdapter adapterRfqPost = new RestAdapter.Builder() 
            .setEndpoint(Constants.ENDPOINT) 
              `enter code here`.setConverter(new ConstantsMethods.StringConverter()) 
            .build(); 

---

public static class StringConverter implements Converter { 
     @Override 
     public Object fromBody(TypedInput typedInput, Type type) throws ConversionException { 
      String text = null; 
      try { 
       text = fromStream(typedInput.in()); 
      } catch (IOException ignored) {/*NOP*/ } 
      return text; 
     } 

     @Override 
     public TypedOutput toBody(Object o) { 
      return null; 
     } 

     public static String fromStream(InputStream in) throws IOException { 
      BufferedReader reader = new BufferedReader(new InputStreamReader(in)); 
      StringBuilder out = new StringBuilder(); 
      String newLine = System.getProperty("line.separator"); 
      String line; 
      while ((line = reader.readLine()) != null) { 
       out.append(line); 
       out.append(newLine); 
      } 
      return out.toString(); 
     } 
    } 

Answer 4

Sembra leggermente modificato con Retrofit 2.0

Ecco come ho fatto:

Retrofit retrofit = new Retrofit.Builder() 
     .baseUrl("http://whatever.com") 
     .addConverterFactory(LenientGsonConverterFactory.create(gson)) 
     .build(); 

Un nuovo stabilimento GSON indulgente:

public final class LenientGsonConverterFactory extends Converter.Factory { 

     /** 
     * Create an instance using a default {@link Gson} instance for conversion. Encoding to JSON and 
     * decoding from JSON (when no charset is specified by a header) will use UTF-8. 
     */ 
     public static LenientGsonConverterFactory create() { 
      return create(new Gson()); 
     } 

     /** 
     * Create an instance using {@code gson} for conversion. Encoding to JSON and 
     * decoding from JSON (when no charset is specified by a header) will use UTF-8. 
     */ 
     public static LenientGsonConverterFactory create(Gson gson) { 
      return new LenientGsonConverterFactory(gson); 
     } 

     private final Gson gson; 

     private LenientGsonConverterFactory(Gson gson) { 
      if (gson == null) throw new NullPointerException("gson == null"); 
      this.gson = gson; 
     } 

     @Override 
     public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, 
                   Retrofit retrofit) { 
      TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type)); 
      return new LenientGsonResponseBodyConverter<>(gson, adapter); 
     } 

     @Override 
     public Converter<?, RequestBody> requestBodyConverter(Type type, 
                   Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) { 
      TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type)); 
      return new LenientGsonRequestBodyConverter<>(gson, adapter); 
     } 

    } 

Lenient analisi di risposte:

private class LenientGsonResponseBodyConverter<T> implements Converter<ResponseBody, T> { 
     private final Gson gson; 
     private final TypeAdapter<T> adapter; 

     LenientGsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) { 
      this.gson = gson; 
      this.adapter = adapter; 
     } 

     @Override 
     public T convert(ResponseBody value) throws IOException { 
      JsonReader jsonReader = gson.newJsonReader(value.charStream()); 
      jsonReader.setLenient(true); 
      try { 
       return adapter.read(jsonReader); 
      } finally { 
       value.close(); 
      } 
     } 
    } 

creazione Lenient di richieste:

private class LenientGsonRequestBodyConverter<T> implements Converter<T, RequestBody> { 
     private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8"); 
     private static final Charset UTF_8 = Charset.forName("UTF-8"); 

     private final Gson gson; 
     private final TypeAdapter<T> adapter; 

     LenientGsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) { 
      this.gson = gson; 
      this.adapter = adapter; 
     } 

     @Override 
     public RequestBody convert(T value) throws IOException { 
      Buffer buffer = new Buffer(); 
      Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8); 
      JsonWriter jsonWriter = gson.newJsonWriter(writer); 
      jsonWriter.setLenient(true); 
      adapter.write(jsonWriter, value); 
      jsonWriter.close(); 
      return RequestBody.create(MEDIA_TYPE, buffer.readByteString()); 
     } 
    } 

Io ho semplicemente copiato il codice sorgente Retrofit e ha aggiunto una linea per la richiesta e convertitori di risposta jsonWriter.setLenient(true);

---

O ancora più semplice:

Gson gson = new GsonBuilder() 
     .setLenient() 
     .create(); 

    Retrofit retrofit = new Retrofit.Builder() 
     .baseUrl("http://whatever.com") 
     .addConverterFactory(GsonConverterFactory.create(gson)) 
     .build();