Retrofit Dynamische Response

Question

Ich plane, eine gemeinsame Dienstklasse mit dem Einsatz von Retrofit zu machen,

@GET 
Call<ResponseBody> makeGetRequest(@Url String url); 

@POST 
Call<ResponseBody> makePostRequest(@Url String url, @Body RequestBody parameters); 

In diesem Code i (Response) übergeben müssen als dynamische JSON POJO-Klassennamen, wie LoginRes

Sagen Sie zum Beispiel,

Call<LoginRes> // But this class will be dynamic 

ich werde Response passieren, aber das Response nicht weiß, welche Klasse ich bevorzugen wollte.

warum ich will das, weil nach Ergebnis

gson.fromJson(response, LoginRes.class); 

so, nach dem Ergebnis von Retrofit immer wieder wir gson.fromJson konvertieren müssen.

so wollte ich dynamische Antwort als Retrofit passieren, so dass es wird Antwort nach meiner pojo Klasse,

Ich weiß, das funktioniert prima, wenn ich LoginRes statt Response passieren, weil, wie ich schon Antwort gesagt, dass wir brauche diese Antwort in LoginRes.

Also, wenn ich

Call<LoginRes> // if i pass this way its working fine no need to convert my response i can access my all properties from that LoginRes class directly. 

passieren Dies ist mein Beispiel einen Web-Service zu nennen.

Call<ResponseBody> call = apiService.makePostRequest("/Buyer/LoginApp", requestBody); 

So rufe ich den Service an.

Lassen Sie mich wissen, wenn ich mit der Erklärung meines Problems unklar bin.

warten auf eine gute Antwort und Anregungen zu diesem Thema.

Dank Madhav

Answer 1

Da so viele Nutzer ein DOWN-ABSTIMMUNG gegeben, ich habe bereits diese von mir selbst Frage gelöst haben, GET

Griff , POST oder ANDERE methode So,

if (methodType.equalsIgnoreCase(CommonConfig.WsMethodType.GET)) { 
       apicall = getClient(CommonConfig.WsPrefix).create(ApiInterface.class).makeGetRequest(url + CommonConfig.getQueryString(new Gson().toJson(requestBody)), getAllHeader); 
} else if (methodType.equalsIgnoreCase(CommonConfig.WsMethodType.POST)) { 
       apicall = getClient(CommonConfig.WsPrefix).create(ApiInterface.class).makePostRequest(url, RequestBody.create(MediaType.parse("application/json"), new Gson().toJson(requestBody)), getAllHeader); 
} 

Handle Antwort wie folgt.

apicall.enqueue(new Callback<ResponseBody>() { 
           @Override 
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) { 
} 

@Override 
public void onFailure(Call<ResponseBody> call, Throwable t) { 

} 
} 

Retrofit-Code

private Retrofit getClient(String WsPrefix) { 
     //TODO 60 to 30 second at everywhere 
     OkHttpClient okHttpClient = new OkHttpClient().newBuilder() 
       .connectTimeout(60, TimeUnit.SECONDS) 
       .readTimeout(60, TimeUnit.SECONDS) 
       .writeTimeout(60, TimeUnit.SECONDS) 
       .build(); 

     retrofit = new Retrofit.Builder() 
       .baseUrl(WsPrefix) 
       .client(okHttpClient) 
       .build(); 
     return retrofit; 
    } 

Common Interface

interface ApiInterface { 

     @GET 
     Call<ResponseBody> makeGetRequest(@Url String url, @HeaderMap() Map<String, String> header); 

     @POST 
     Call<ResponseBody> makePostRequest(@Url String url, @Body RequestBody requestBody, @HeaderMap() Map<String, String> header); 
} 

ApiCallback

public interface ApiCallback { 
     void success(String responseData); 
     void failure(String responseData); 
} 

Answer 2

Dies ist ein bisschen schwierig, aber Sie werden eine benutzerdefinierte Retrofit Converter Fabrik mit einem benutzerdefinierten GsonBuilder, die verwendet eine benutzerdefinierte JsonDeserializer verwenden müssen.

Außerdem sollten Sie eine Schnittstelle definieren (CustomResonse in meinem Beispiel), für die der CustomJsonDeserializer verwendet wird. Dies wird nicht benötigt, aber ansonsten wird der Deserializer für jede Anfrage verwendet.

public class CustomConverterFactory { 

    public static GsonConverterFactory create() { 
     return GsonConverterFactory.create(createGsonCustomDeserializer()); 
    } 

    public static Gson createGsonCustomJsonDeserializer() { 
     return new GsonBuilder() 
      .registerTypeAdapter(CustomResponse.class, new CustomJsonDeserializer()) 
      .serializeNulls() 
      .create(); 
    } 
} 

Und für den Deserializer:

public class CustomJsonDeserializer implements JsonDeserializer<CustomResponse> { 

@Override 
public CustomResponse deserialize(final JsonElement json, final Type typeOfT, 
     final JsonDeserializationContext context) throws JsonParseException { 
    if (json.isJsonObject()) { 
     JsonObject jsonObject = json.getAsJsonObject(); 

     // Here you have to distinguish your class somehow 
     // Maybe read some Json field from your response 
     if (jsonObject.has("name")) { 
      JsonElement classes = jsonObject.get("name"); 
      ... 
      return context.deserialize(json, MyName.class); 
     } 
     ... 
     // Default fallback: Deserialize as a fallback object 
     return context.deserialize(json, MyFallback.class); 
    } else { 
     throw new IllegalStateException(); 
    } 
}