Android:动态传递模型类以改进回调

Question

通过改造将json响应映射到pojo通常我们这样做

@POST
Call<User> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

ApiCalls api = retrofit.create(ApiCalls.class);
    Call<User> call = api.getDataFromServer(StringConstants.URL,hashMap);
    call.enqueue(new Callback<User>() {
         //Response and failure callbacks
    }

用户是我的Pojo课程.但是对于每个其他请求,我需要制作不同的pojo并为改进调用编写相同的代码.我想制作一个单独的方法来调用api并传递相应的pojo类来改进调用.像这样

ApiCalls api = retrofit.create(ApiCalls.class);
Call<*ClassPassed*> call = api.getDataFromServer(StringConstants.URL,hashMap);
call.enqueue(new Callback<*ClassPassed*>() {
     //Response and failure callbacks
}

所以现在我可以将任何pojo类转换为单个方法并获得响应.这只是为了避免一次又一次地重写相同的代码.这是可能的

更新 要详细说明:

假设我需要提出两个请求.第一个是获取userDetails,另一个是patientDetails.所以我必须创建两个模型类User和Patient.所以在改造api我会有类似的东西

@POST
Call<User> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

@POST
Call<Patient> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

在我的FragmentUser和FragmentPatient类中,我将这样做

  ApiCalls api = retrofit.create(ApiCalls.class);
Call<User> call = api.getDataFromServer(StringConstants.URL,hashMap);
call.enqueue(new Callback<User>() {
     //Response and failure callbacks
}

ApiCalls api = retrofit.create(ApiCalls.class);
Call<Patient> call = api.getDataFromServer(StringConstants.URL,hashMap);
call.enqueue(new Callback<Patient>() {
     //Response and failure callbacks
}

但是这里的代码只是因为不同的pojo类而被修复.我需要在每个其他片段中为不同的请求重复相同的代码.所以我需要制作一个通用的方法,它可以接受任何pojo类,然后从片段我将只是传递pojo进行映射.

Answer 1

Android:动态传递模型类以改进回调

有两种方法可以做到这一点.........

1.泛型

2.将所有POJO合二为一......

泛型

在泛型中,您必须使用类传递方法.请试看......

ApiCalls api = retrofit.create(ApiCalls.class);

Call<User> call = api.getDataFromServer(StringConstants.URL,hashMap);

callRetrofit(call,1);

 public static <T> void callRetrofit(Call<T> call,final int i) {

        call.enqueue(new Callback<T>() {
            @Override
            public void onResponse(Call<T> call, Response<T> response) {
            if(i==1){
                  User user = (User) response.body(); // use the user object for the other fields
             }else if (i==2){
                 Patient user = (Patient) response.body(); 
              }


            }

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

            }
        });

    }

注意: - 上面改装调用TypeCast你的响应YOUR OBJECT,所以你可以访问其字段和方法

将所有POJO合并为一个

这是非常容易使用 .您必须将所有POJO类合并为一个并在Retrofit中使用它们.请看下面的例子....

我有两个API登录和用户......

在Login API中,我得到了像这样的JSON响应......

{"成功":是的,"消息":"身份验证成功"}

在JSON之上,POJO看起来像这样

public class LoginResult{

    private String message;
    private boolean success;

    //constructor , getter and setter 
}

和Retrofit电话看起来像这样......

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


                }

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

                }
            });

在User API中,我得到了像这样的JSON响应.

{"name":"sushildlh","place":"hyderabad"}

在JSON之上,POJO看起来像这样

 public class UserResult{

        private String name;
        private String place;

        //constructor , getter and setter 
    }

和Retrofit电话看起来像这样......

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


                }

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

                }
            }); 

只需将上述两个JSON响应合并为一个......

public class Result{

            private String name;
            private String place;
            private String message;
            private boolean success;

            //constructor , getter and setter 
        }

并在API调用中使用Result ......

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


            }

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

            }
        }); 

注意: - 您直接组合2 POJO类并访问它.(如果响应非常大,这非常复杂,如果某些KEY与不同的变量类型相同,则提供重复)

Answer 2

你可以像这样构建主要的pojo

public class BaseResponse<T>
{
    @SerializedName("Ack")
    @Expose
    private String ack;

    @SerializedName("Message")
    @Expose
    private String message;

    @SerializedName("Data")
    @Expose
    private T data;

    /**
     *
     * @return
     * The ack
     */
    public String getAck() {
        return ack;
    }

    /**
     *
     * @param ack
     * The Ack
     */
    public void setAck(String ack) {
        this.ack = ack;
    }

    /**
     *
     * @return
     * The message
     */
    public String getMessage() {
        return message;
    }

    /**
     *
     * @param message
     * The Message
     */
    public void setMessage(String message) {
        this.message = message;
    }


    /**
     *
     * @return
     * The data
     */
    public T getData() {
        return data;
    }

    /**
     *
     * @param data
     * The Data
     */
    public void setData(T data) {
        this.data = data;
    }
}

并且这样打电话

 Call<BaseResponse<SetupDetails>> getSetup(@Query("site_id") int id,@Query("ino") String ii);

Answer 3

首先创建接口：

public interface
ItemAPI {

    @GET("setup.php")
    Call<SetupDetails> getSetup(@Query("site_id") int id,@Query("ino") String ii);

    @GET("setup.php")
    void setMy(@Query("site_id") int id, Callback<List<SetupDetails>> sd);
    }

现在创建类：

public class Apiclient {

    private static final String BASE_URL ="http://www.YOURURL.COM/";
    private static Retrofit retrofit = null;

    public static Retrofit getClient() {

        OkHttpClient.Builder httpClient2 = new OkHttpClient.Builder();
        httpClient2.addNetworkInterceptor(new Interceptor() {

            @Override
            public Response intercept(Chain chain) throws IOException {
                Request.Builder builder = chain.request().newBuilder();
                builder.addHeader("site_id","1");
                return chain.proceed(builder.build());
            }
        });
        OkHttpClient client = httpClient2.build();

        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .client(client)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }

现在在任何活动中只需使用：

ItemAPI itemAPI = Apiclient.getClient().create(ItemAPI.class);
     Call<AllProducts> call=itemAPI.getSetup(1,count);
     call.enqueue(new Callback<AllProducts>() {
            @Override
            public void onResponse(Call<AllProducts> call, Response<AllProducts> response) {
                try {
                    if (response.body().getItem().size()>0){

                    }

                }catch (Exception e){
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailedAfterRetry(Throwable t) {

            }
        });