मॉडल के बिना एकल स्ट्रिंग मान से रेट्रोफिट के लिए जेएसओएन बॉडी प्रारूप

Question

क्या एक सिंगल स्ट्रिंग मान (सादा पाठ, जेसन नहीं) एक एनोटेशन के साथ एक JSON बॉडी में बदलने का कोई तरीका है? मैं इतना सरल मॉडल नहीं बनाना चाहता हूं।

उदाहरण

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

class BarModel { 
    public String bar; 
} 

मुझे दे देगा मैं क्या उम्मीद:

{ 
    "bar" : "hello world" 
} 

वहाँ एक टिप्पणी के साथ यह करने के लिए एक आसान तरीका है? कुछ इस तरह:

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

Answer 1

रेट्रोफिट एक Converter.Factory सार वर्ग है कि आप करने के लिए उपयोग कर सकते हैं में मदद मिलेगी कस्टम HTTP प्रतिनिधित्व करते हैं। यदि विधि में एक विशिष्ट एनोटेशन है तो आप okhttp.RequestBody बनाने के लिए कनवर्टर बना सकते हैं।

अंतिम परिणाम तरह दिखेगा:

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

और परिणत: postBar("Hello World") { "bar" : "Hello World" } में।

चलो शुरू करें।

चरण 1 - जड़ कुंजी (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(); 
} 

चरण 2 के लिए एक एनोटेशन बना सकते हैं - अपने Converter.Factory कि एनोटेशन (JSONConverterFactory.java) का पता लगाता है परिभाषित करते हैं। मैं JSON पार्सिंग के लिए Gson का उपयोग कर रहा हूं लेकिन आप जो भी ढांचा चाहते हैं उसका उपयोग कर सकते हैं।

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

चरण 3 - अपने रेट्रोफिट उदाहरण

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

चरण में JSONConverterFactory स्थापित 4 - लाभ

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

या अपने मामले के लिए:

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

Answer 2

यह जरूरी एक json शरीर का निर्माण नहीं करता है, लेकिन अपने API URL इनकोडिंग बातें

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

Answer 3

फिर Hashmap<String, String> उपयोग करने के लिए बेहतर के साथ काम करने में सक्षम हो सकता है। आप जीसन का उपयोग करके पार्सिंग करके सीधे शरीर में हैशमैप पास कर सकते हैं। और यदि आपको एकाधिक जगह का उपयोग करने की आवश्यकता है तो आप अपने मानचित्र का उपयोग हैश मैप को विस्तारित कर सकते हैं, ताकि आप अपने मान एक पंक्ति में जोड़ सकें। मैं मेरा पोस्टिंग कर रहा हूँ, यह आपकी मदद कर सकता है -

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

प्रयोग किया जाएगा -

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

आशा है कि यह :)

Answer 4

मैं की तरह उपयोग करें यह:

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

यह JSONObject