Formato JSON Body per Retrofit da un valore a stringa singola senza il modello

Question

C'è un modo per trasformare un singolo valore di stringa (testo normale, non json) in un corpo JSON con un'annotazione? Non voglio creare un modello così semplice.

Esempio

@POST("foo/{fooId}/bars") 
Observable<Void> postBar(@Path("fooId") String styleId, @Body BarModel bar); 

class BarModel { 
    public String bar; 
} 

mi darà quello che mi aspetto:

{ 
    "bar" : "hello world" 
} 

C'è un modo semplice per farlo con un'annotazione? Qualcosa di simile a questo:

@POST("foo/{fooId}/bars") 
Observable<Void> postBar(@Path("fooId") String styleId, @Body("bar") String bar); 

Answer 1

Retrofit ha una classe astratta Converter.Factory che è possibile utilizzare per fare una rappresentazione HTTP personalizzata. È possibile creare un convertitore per costruire un okhttp.RequestBody se il metodo ha un'annotazione specifica.

Il risultato finale sarà simile:

@POST("/") 
Call<Void> postBar(@Body @Root("bar") String foo) 

e trasformare: postBar("Hello World") in { "bar" : "Hello World" }.

Iniziamo.

Fase 1 - creare un'annotazione per la chiave principale (Root.java)

/** 
* Denotes the root key of a JSON request. 
* <p> 
* Simple Example: 
* <pre><code> 
* &#64;POST("/") 
* Call&lt;ResponseBody&gt; example(
*  &#64;Root("name") String yourName); 
* </code></pre> 
* Calling with {@code foo.example("Bob")} yields a request body of 
* <code>{name=>"Bob"}</code>. 
* @see JSONConverterFactory 
*/ 
@Documented 
@Target(PARAMETER) 
@Retention(RUNTIME) 
public @interface Root { 
    /** 
    * The value of the JSON root. 
    * Results in {"value" : object} 
    */ 
    String value(); 
} 

Fase 2 - definire il Converter.Factory che rileva l'annotazione (JSONConverterFactory.java). Sto usando Gson per l'analisi JSON ma puoi usare qualsiasi framework tu voglia.

/** 
* Converts @Root("key") Value to {"key":json value} using the provided Gson converter. 
*/ 
class JSONConverterFactory extends Converter.Factory { 
    private final Gson gson; 
    private static final MediaType CONTENT_TYPE = 
      MediaType.parse("application/json"); 

    JSONConverterFactory(Gson gson) { 
     this.gson = gson; 
    } 

    @Override 
    public Converter<?, RequestBody> requestBodyConverter(
      Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) { 
     for (Annotation annotation : parameterAnnotations) { 
      if (annotation instanceof Root) { 
       Root rootAnnotation = (Root) annotation; 
       return new JSONRootConverter<>(gson, rootAnnotation.value()); 
      } 
     } 
     return null; 
    } 

    private final class JSONRootConverter<T> implements Converter<T, RequestBody> { 
     private Gson gson; 
     private String rootKey; 

     private JSONRootConverter(Gson gson, String rootKey) { 
      this.gson = gson; 
      this.rootKey = rootKey; 
     } 

     @Override 
     public RequestBody convert(T value) throws IOException { 
      JsonElement element = gson.toJsonTree(value); 
      JsonObject object = new JsonObject(); 
      object.add(this.rootKey, element); 
      return RequestBody.create(CONTENT_TYPE, this.gson.toJson(object)); 
     } 
    } 
} 

Fase 3 - installare il JSONConverterFactory nella tua istanza retrofit

Gson gson = new GsonBuilder().create(); // Or your customized version 
Retrofit.Builder builder = ...; 
builder.addConverterFactory(new JSONConverterFactory(gson)) 

Fase 4 - Utile

@POST("/") 
Call<Void> postBar(@Body @Root("bar") String foo) 

O per il vostro caso:

@POST("foo/{fooId}/bars") 
Observable<Void> postBar(@Body @Root("bar") String barValue, @Path("fooId") String styleId); 

Answer 2

Non necessariamente creare un corpo JSON, ma il vostro api potrebbe essere in grado di lavorare con URL codificato cose

@FormUrlEncoded 
@POST("foo/{fooId}/bars") 
Observable<Void> postBar(@Path("fooId") String styleId, @Field("bar") String bar); 

Answer 3

Quindi meglio usare Hashmap<String, String>. Puoi passare Hashmap direttamente nel corpo, analizzando usando Gson. E se hai bisogno di utilizzare più postazioni, puoi utilizzare la tua mappa estendendo HashMap, in modo da poter aggiungere i tuoi valori in un'unica riga. Vi metto il mio, potrebbe aiuti voi -

public class PostParams extends HashMap<String, String> { 
    public static PostParams init() { 
     return new PostParams(); 
    } 

    public PostParams add(String param, String value) { 
     put(param, value); 
     return this; 
    } 

    public PostParams add(String param, String[] values) { 
     put(param, new Gson().toJson(values)); 
     return this; 
    } 

    public PostParams add(String param, int[] values) { 
     put(param, new Gson().toJson(values)); 
     return this; 
    } 

    public PostParams add(String param, int value) { 
     put(param, value + ""); 
     return this; 
    } 

    public PostParams addPlatform() { 
     put("Platform", Constants.ANDROID); 
     return this; 
    } 

    public PostParams add(String param, double value) { 
     put(param, new Gson().toJson(value)); 
     return this; 
    } 

    @Override 
    public String toString() { 
     return new Gson().toJson(this); 
    } 
} 

Uso sarà come -

String postData = new PostParams().add("bar", "Hello World").toString() 

auguriamo che contribuiscano :)

Answer 4

io uso come questo:

@POST("url") 
Observable<Response<Object>> login(@Body Map<String, Object> body); 

Cambierà mappa in JsonObject