如何使用Java通用类型使用翻新：

Question

我第一次尝试使用Android Retrofit，我正在按照教程进行操作，并在第一步中陷入困境...... 1.使用Gson2.3，okhttp2.1.0，okhttp-urlconnection2.1.0，改造1.8.0 2.我的web服务在.php脚本中并返回这种数据{“idInfo”：“12”，“typeInfo”：“2”} 3.我创建了模型类gitmodel

public class gitmodel {
    public gitmodel(int idInfo, int typeInfo) {
        this.idInfo = idInfo;
        this.typeInfo = typeInfo;
    }

    private int idInfo;
    private int typeInfo;
    public gitmodel() {
    }
    public int getIdInfo() {
        return idInfo;
    }
    public void setIdInfo(int idInfo) {
        this.idInfo = idInfo;
    }
    public int getTypeInfo() {
        return typeInfo;
    }
    public void setTypeInfo(int typeInfo) {
        this.typeInfo = typeInfo;
    }
}

” 4。我创建了类似于

的接口类gitapi

public interface gitapi {

    @GET("/users/{user}")      
    public void getFeed(@Path("user") String user,Callback<gitmodel> response);      
}

我在这个类中遇到错误“无法解析Path”并且无法解析gitmodel。我知道这只是一个开始，但我不能继续下去。

Answer 1

使用1.9版本的改装，我只是复制粘贴我的基本Api类：

compile 'com.squareup.retrofit:retrofit:1.9.0'

public class Api {

    public interface Service {

        @GET("/api/url/something")
        ResponseModelThatYouCreated getSomethingFromGithub(@Body RequestModel requestModelThatYouCreated);

        //other methods can be here
    }

    private static final String API_URL = "http://api.github.com"; //or something else

    private static final RestAdapter REST_ADAPTER = new RestAdapter.Builder()
            .setEndpoint(API_URL)
            .setLogLevel(RestAdapter.LogLevel.BASIC)
            .build();

    private static final Service ServiceInstance = REST_ADAPTER.create(Service.class);

    public static Service getService() {
        return ServiceInstance;
    }

}

用法：

ResponseModelThatYouCreated fromGit = Api.getInstance().getSomethingFromGithub(/*parameter object*/)

Answer 2

您可以使用最新的改装版本更新您的应用程序gradle文件：

compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:converter-gson:2.1.0'

您可以阅读如何将其集成到您的应用中 this link

Answer 3

如何使用Java通用类型使用翻新：

您可以使用“ BaseRetrofitHelper”中的界面进行异步调用。

public abstract class BaseRetrofitHelper {

    /** START Callback Interfaces **/    
    public interface IJsonObjectCallback {
        void OnJsonObjectResponse(Integer requestCase, JsonObject answer);
        void OnJsonObjectFailure(Integer requestCase, Throwable t);
    }

    public interface IResponseBodyCallback {
        void OnResponseBodySuccess(Integer reqCase, ResponseBody response);
        void OnResponseBodyError(Integer reqCase, Throwable t);
    }

    public interface IBaseResponseCallback{
        void OnBaseResponseSuccess(Integer requestCase, BaseResponse answer);
        void OnBaseResponseFailure(Integer requestCase, Throwable t);
    }

    public interface IBaseItemResponseCallback<T>{
        void OnBaseItemResponseSuccess(Integer reqCase, BaseItemResponse<T> answer);
        void OnBaseItemResponseError(Integer reqCase, Throwable t);
    }

    public interface IGetItemBaseResponseCallback<T>{
        void OnGetItemBaseResponseSuccess(Integer reqCase, T answer);
        void OnGetItemBaseResponseError(Integer reqCase, Throwable t);
    }

    public interface IBaseItemsResponseCallback<T>{
        void OnBaseItemsResponseSuccess(Integer reqCase, BaseItemsResponse<T> answer);
        void OnBaseItemsResponseError(Integer reqCase, Throwable t);
    }

    public interface IGetItemsBaseResponseCallback<T>{
        void OnGetItemsBaseResponseSuccess(Integer reqCase, List<T> answer);
        void OnGetItemsBaseResponseError(Integer reqCase, Throwable t);
    }
    /** END Callback Interfaces **/

    // Logcats
    protected final String LOGCAT = this.getClass().getSimpleName();
    // Timeouts
    public static final String CONNECT_TIMEOUT = "CONNECT_TIMEOUT";
    public static final String READ_TIMEOUT = "READ_TIMEOUT";
    public static final String WRITE_TIMEOUT = "WRITE_TIMEOUT";

    private static Retrofit mRetrofit;
    private static String mBaseUrl;

    /* INIT YOUR RETROFIT INSTANCE HERE */

    /* START Getter & Setter Methods */
    public static String getBaseUrl() {
        return mBaseUrl;
    }
    /* END Getter & Setter Methods */

    /* START Public Methods */
    public <T> T createService(Class<T> service) {
        return mRetrofit.create(service);
    }
    /* END Public Methods */

    /* START Protected Methods */
    String getJsonRequest(LinkedHashMap<String, String> paramsToJson) {
        Gson gson = new Gson();
        return gson.toJson(paramsToJson, LinkedHashMap.class);
    }

    /* START Sync Request Methods */
    protected <T> T executeSyncCall(ExecutorService exe, Call<T> call){
        return new ResponseExecutorCallable<>(exe, call).executeSyncCall();
    }

    public <T> T executeSyncCall(Call<T> call){
        return new ResponseExecutorCallable<>(newSingleThreadExecutor(), call).executeSyncCall();
    }

    public boolean getBaseResponseSuccess(Call<? extends  BaseResponse> call){
        return new BaseResponseExecutorCallable<>(newSingleThreadExecutor(), call).getBaseResponseSuccess();
    }

    String getBaseResponseMessage(Call<? extends BaseResponse> call){
        return new BaseResponseExecutorCallable<>(newSingleThreadExecutor(), call).getBaseResponseMessage();
    }

    protected <T> List<T> getBaseResponseItems(Call<BaseItemsResponse<T>> call){
        return new BaseItemsResponseExecutorCallable<T>(newSingleThreadExecutor(), call).getBaseResponseItems();
    }

    protected <T> T getBaseResponseItem(Call<BaseItemResponse<T>> call){
        return new BaseItemResponseExecutorCallable<T>(newSingleThreadExecutor(), call).getBaseResponseItem();
    }
    /* END Sync Request Methods */

    /* START Check Methods */
    protected JsonObject checkGetJsonObject(Response<JsonObject> response){
        JsonObject answer = null;
        if(response != null && response.isSuccessful()){
            answer = response.body();
        }
        return answer;
    }

    ResponseBody checkResponseBody(Response<ResponseBody> response){
        ResponseBody answer = null;
        if(response != null && response.isSuccessful()){
            answer = response.body();
        }
        return answer;
    }

    protected BaseResponse checkBaseResponse(Response<BaseResponse> response){
        BaseResponse answer = null;
        if(response != null && response.isSuccessful()){
            answer = response.body();
        }
        return answer;
    }

    protected <T> BaseItemResponse<T> checkBaseItemResponse(Response<BaseItemResponse<T>> response){
        BaseItemResponse<T> answer = null;
        if(response != null && response.isSuccessful()){
            answer = response.body();
        }
        return answer;
    }

    protected <T> T checkGetBaseResponseItem(Response<BaseItemResponse<T>> response){
        T item = null;
        if(response != null && response.isSuccessful()){
            BaseItemResponse<T> answer = response.body();
            if(answer != null && answer.getSuccess()){
                item = answer.getItem();
            }
        }
        return item;
    }

    <T> BaseItemsResponse<T> checkBaseItemsResponse(Response<BaseItemsResponse<T>> response){
        BaseItemsResponse<T> answer = null;
        if(response != null && response.isSuccessful()){
            answer = response.body();
        }
        return answer;
    }

    protected <T> List<T> checkGetBaseResponseItems(Response<BaseItemsResponse<T>> response){
        List<T> items = null;
        if(response != null && response.isSuccessful()){
            BaseItemsResponse<T> answer = response.body();
            if(answer != null && answer.getSuccess()){
                items = answer.getItems();
            }
        }
        return items;
    }
    /* END Check Methods *//* END Protected Methods */

    /** START Private Classes **/
    private class ResponseExecutorCallable<T> implements Callable<T>{
        private ExecutorService mExecutorService;
        private Call<T> mCall;

        ResponseExecutorCallable(ExecutorService exe, Call<T> call){
            this.mExecutorService = exe;
            this.mCall = call;
        }

        /* START Override Callable Methods */
        @Override
        public T call() {
            T ret = null;
            try {
                Response<T> response = mCall.execute();
                if (response != null && response.isSuccessful()) {
                    ret = response.body();
                }
            } catch(IOException ioE){
                onException(ioE);
            }
            return ret;
        }
        /* END Override Callable Methods */

        /* START Public Methods */
        T executeSyncCall(){
            T ret = null;
            try{
                ret = mExecutorService.submit(this).get();
            } catch(ExecutionException | InterruptedException eiE){
                onException(eiE);
            }
            return ret;
        }
        /* END Public Methods */
    }

    private class BaseResponseExecutorCallable<T extends BaseResponse> extends ResponseExecutorCallable<T> {

        BaseResponseExecutorCallable(ExecutorService exe, Call<T> call){
            super(exe, call);
        }

        /* START Public Methods */
        boolean getBaseResponseSuccess(){
            boolean ret = false;
            T res = super.executeSyncCall();
            if(res != null){
                ret = res.getSuccess();
            }
            return ret;
        }

        String getBaseResponseMessage(){
            String ret = null;
            T res = super.executeSyncCall();
            if(res != null && res.getSuccess()){
                ret = res.getMsg();
            }
            return ret;
        }
        /* END Public Methods */
    }

    private class BaseItemResponseExecutorCallable<T> extends BaseResponseExecutorCallable<BaseItemResponse<T>>{

        BaseItemResponseExecutorCallable(ExecutorService exe, Call<BaseItemResponse<T>> call){
            super(exe, call);
        }

        /* START Public Methods */
        <T> T getBaseResponseItem(){
            T ret = null;
            BaseItemResponse<T> res = (BaseItemResponse<T>) super.executeSyncCall();
            if(res != null && res.getSuccess()){
                ret = res.getItem();
            }
            return ret;
        }
        /* END Public Methods */
    }

    private class BaseItemsResponseExecutorCallable<T> extends BaseResponseExecutorCallable<BaseItemsResponse<T>>{

        BaseItemsResponseExecutorCallable(ExecutorService exe, Call<BaseItemsResponse<T>> call){
            super(exe, call);
        }

        /* START Public Methods */
        <T> List<T> getBaseResponseItems(){
            List ret = null;
            BaseItemsResponse<T> res = (BaseItemsResponse<T>) super.executeSyncCall();
            if(res != null && res.getSuccess()){
                ret = res.getItems();
            }
            return ret;
        }
        /* END Public Methods */
    }
    /** END Private Classes **/

}

我的回复：

public class BaseResponse {

    @SerializedName("success")
    protected Boolean mSuccess;
    @SerializedName("msg")
    protected String mMsg;
    @SerializedName("errors")
    protected String mErrors;

    /* START Getter & Setter Methods */
    public Boolean getSuccess() {
        return mSuccess;
    }

    public void setSuccess(Boolean success) {
        this.mSuccess = success;
    }

    public String getMsg() {
        return mMsg;
    }

    public void setMsg(String msg) {
        this.mMsg = msg;
    }

    public String getErrors() {
        return mErrors;
    }

    public void setErrors(String errors) {
        this.mErrors = errors;
    }
    /* END Getter & Setter Methods */

    @Override
    public String toString() {
        return "BaseResponse{" +
            "mSuccess=" + mSuccess +
            ", mMsg='" + mMsg + '\'' +
            ", mErrors='" + mErrors + '\'' +
            '}';
    }

}

public class BaseItemResponse<T> extends BaseResponse {

    @SerializedName(value = "item", alternate = {"..."})
    private T mItem;

    /* START Getter & Setter Methods */
    public T getItem() {
        return mItem;
    }

    public void setItem(T mItem) {
        this.mItem = mItem;
    }
    /* END Getter & Setter Methods */

    @Override
    public String toString() {
        return "BaseItemResponse{" +
            "mItem=" + mItem +
            ", mSuccess=" + mSuccess +
            ", mMsg='" + mMsg + '\'' +
            ", mErrors='" + mErrors + '\'' +
            '}';
    }

}



public class BaseItemsResponse<T> extends BaseResponse {

    @SerializedName(value = "items", alternate = {"...."})
    private List<T> mItems;

    /* START Getter & Setter Methods */
    public List<T> getItems() {
        return mItems;
    }

    public void setItems(List<T> items) {
        this.mItems = items;
    }
    /* END Getter & Setter Methods */

    @Override
    public String toString() {
        return "BaseItemsResponse{" +
            "mItems=" + mItems +
            ", mSuccess=" + mSuccess +
            ", mMsg='" + mMsg + '\'' +
            ", mErrors='" + mErrors + '\'' +
            '}';
    }

}

用于同步呼叫：

创建一个扩展“ BaseRetrofitHelper”的“ RetrofitHelper”类。在此类中，创建您的方法。您可以在另一个线程中执行Sync调用，该调用将等到完成网络操作后再执行此操作：

public List<YOURCLASS> requestSyncListYOURCLASS(String url, String token, HashMap<String, Object> data){
        YourAPI api = createService(YourAPI.class);
        String params = JsonUtils.buildB64EncodedParams(token, data);
        Call<BaseItemsResponse<YOURCLASS>> call = api.getListYOURCLASS(url, params);
        return super.getBaseResponseItems(call);
    }

使用此方法，您将在活动中获得“ YOURCLASS”元素的列表。联网操作是在另一个线程中完成的，因此您不会收到“ NetworkingOnMainThreadException”，也不需要将“ Policy”设置为“ PermitAll”来解决“ NetworkingOnMainThreadException”。（更改策略以允许在主线程中联网确实是一件坏事！）

用于异步呼叫：

我个人更喜欢在可能的情况下始终使用“异步呼叫”进行联网操作。这就是为什么在接口中有一个“ Integer requestCase”参数的原因：当您必须执行多个网络操作且它们使用相同的Callback时，您只需要传递一个整数值作为“ requestCase”（reqCase）即可识别完成的操作。在“成功”和“错误”回调方法中，您只需要放置“ switch（requestCase）”语句即可知道哪个操作已完成并返回其结果。

---->在活动中实现回调接口时，如果在联网操作返回时始终可以返回相同的对象类，则可以将期望的结果类指定为其类型参数。否则，如果您使用相同的回调方法返回了多种对象类，则在实现接口时，不应为接口提供类型参数。

public void requestAsyncListYOURCLASS(String url, String token, HashMap<String, Object> data, final Integer reqCase,
                                       final IGetItemsBaseResponseCallback<YOURCLASS> callback) {
String params = JsonUtils.buildB64EncodedParams(token, data);
        YourAPI api = createService(YourAPI.class);
        Call<BaseItemsResponse<YOURCLASS>> call = api.getListYOURCLASS(url, params);
        call.enqueue(new Callback<BaseItemsResponse<YOURCLASS>>() {
            @Override
            public void onResponse(Call<BaseItemsResponse<YOURCLASS>> call, Response<BaseItemsResponse<YOURCLASS>> response) {
                callback.OnGetItemsBaseResponseSuccess(reqCase, checkGetBaseResponseItems(response));
            }

            @Override
            public void onFailure(Call<BaseItemsResponse<YOURCLASS>> call, Throwable t) {
                callback.OnGetItemsBaseResponseError(reqCase, t);
            }
        });
    }

希望这对您有帮助！谢谢大家再见：D

Answer 4

请尝试以下步骤：

添加gradle这个和同步你的项目

实现'com.squareup.retrofit2：retrofit：2.0.2'

执行 'com.squareup.retrofit2：转换器-GSON：2.0.2'

创建您的pojo类并添加模型类

 public class LoginModel {
 @SerializedName("code")
 @Expose
 private String code;
 @SerializedName("message")
 @Expose
 private String message;
 @SerializedName("data")
 @Expose
  private Data data;

   public String getCode() {
   return code;
   }

  public void setCode(String code) {
  this.code = code;
 }

 public String getMessage() {
 return message;
 }

 public void setMessage(String message) {
 this.message = message;
 }

 public Data getData() {
  return data;
 }

public void setData(Data data) {
this.data = data;
}

public class Data {

@SerializedName("id")
@Expose
private String id;
@SerializedName("facebookId")
@Expose
private String facebookId;
@SerializedName("password")
@Expose
private String password;
@SerializedName("securityHash")
@Expose
private String securityHash;
@SerializedName("userName")
@Expose
private String userName;
@SerializedName("firstName")
@Expose
private String firstName;
@SerializedName("lastName")
@Expose
private String lastName;
@SerializedName("email")
@Expose
private String email;
@SerializedName("contact")
@Expose
private String contact;
@SerializedName("userLastLoggedIn")
@Expose
private String userLastLoggedIn;
@SerializedName("status")
@Expose
private String status;
@SerializedName("createdAt")
@Expose
private String createdAt;
@SerializedName("updatedAt")
@Expose
private String updatedAt;
@SerializedName("profileStatus")
@Expose
private String profileStatus;
@SerializedName("gender")
@Expose
private String gender;

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public String getFacebookId() {
    return facebookId;
}

public void setFacebookId(String facebookId) {
    this.facebookId = facebookId;
}

public String getPassword() {
    return password;
}

public void setPassword(String password) {
    this.password = password;
}

public String getSecurityHash() {
    return securityHash;
}

public void setSecurityHash(String securityHash) {
    this.securityHash = securityHash;
}

public String getUserName() {
    return userName;
}

public void setUserName(String userName) {
    this.userName = userName;
}

public String getFirstName() {
    return firstName;
}

public void setFirstName(String firstName) {
    this.firstName = firstName;
}

public String getLastName() {
    return lastName;
}

public void setLastName(String lastName) {
    this.lastName = lastName;
}

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email = email;
}

public String getContact() {
    return contact;
}

public void setContact(String contact) {
    this.contact = contact;
}

public String getUserLastLoggedIn() {
    return userLastLoggedIn;
}

public void setUserLastLoggedIn(String userLastLoggedIn) {
    this.userLastLoggedIn = userLastLoggedIn;
}

public String getStatus() {
    return status;
}

public void setStatus(String status) {
    this.status = status;
}

public String getCreatedAt() {
    return createdAt;
}

public void setCreatedAt(String createdAt) {
    this.createdAt = createdAt;
}

public String getUpdatedAt() {
    return updatedAt;
}

public void setUpdatedAt(String updatedAt) {
    this.updatedAt = updatedAt;
}

public String getProfileStatus() {
    return profileStatus;
}

public void setProfileStatus(String profileStatus) {
    this.profileStatus = profileStatus;
}

public String getGender() {
    return gender;
}

public void setGender(String gender) {
    this.gender = gender;
}

}
}

在您的程序包中添加三个类

RetrofitApiInterfaces

RetrofitClient

RetrofitConstent

1.1像这样添加RetrofitApiInterface Calss：

 public interface RetrofitApiInterface {

/*Login API Post Method*/
@POST("login")
@FormUrlEncoded
Call<LoginModel> loginMethod(@Field("email") String email, @Field("password") String password);
 }

<强> 1.2添加RetrofitClient CALSS

public class RetrofitClient {
private static Retrofit retrofit = null;
public static Retrofit getClient(String url){
    if(retrofit == null){
        retrofit = new Retrofit.Builder()
                .baseUrl(url)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
    }
    return retrofit;
}
}

<强> 1.3添加RetrofitConstent类

public class RetrofitConstent {
public static String BASE_URL="";

public static RetrofitApiInterface retrofitApiInterface(){
    return RetrofitClient.getClient(BASE_URL).create(RetrofitApiInterface.class);
}
 }

4。添加像THI 取值

改造API方法

/*simple login API method*/ public void loginAPIMethod(String email, String password) { dialog = new Dialog(this, android.R.style.Theme_Translucent); dialog.requestWindowFeature(Window.FEATURE_NO_TITLE); dialog.setContentView(R.layout.custom_progress_dialog); dialog.setCancelable(false); dialog.show(); Call<LoginModel> call = null; try { call = YabbyConstant.retrofitApiInterface().loginMethod(email, password); call.enqueue(new Callback<LoginModel>() { @Override public void onResponse(Call<LoginModel> call, Response<LoginModel> response) { /*getting success response */ Log.e(TAG + "Response", "" + response.body().getCode()); try { if (response.body().getCode().equalsIgnoreCase("1")) { dialog.dismiss(); LoginModel.Data data = response.body().getData(); /*save data into shared preference*/ Preference.storeUserPreferences(SignInActivity.this, ApiUtils.USER, new Gson().toJson(response.body().getData())); Log.e(TAG, "sharedLogin" + new Gson().toJson(response.body().getData())); Log.e(TAG, "id" + String.valueOf(data.getId())); Log.e(TAG, "email" + String.valueOf(data.getEmail())); finish(); startActivity(new Intent(SignInActivity.this, HomeScreenActivity.class)); overridePendingTransition(R.anim.right_to_left, R.anim.left_to_right); String message = response.body().getMessage(); Toast.makeText(getApplicationContext(), "" + message, Toast.LENGTH_SHORT).show(); } else { String data = response.body().getMessage(); alertDialogueFail(data); Log.e(TAG, "data--" + data); dialog.dismiss(); } } catch (NullPointerException e) { e.printStackTrace(); } } /* getting failure response*/ @Override public void onFailure(Call<LoginModel> call, Throwable t) { dialog.dismiss(); Log.e("Error", "" + String.valueOf(t.getMessage())); } }); } catch (Exception e) { e.printStackTrace(); } }

请检查我的代码是如何使用改装

我希望它能对您有所帮助

Android Retrofit简单用法

4 个答案:

如何使用Java通用类型使用翻新：

我的回复：

用于同步呼叫：

用于异步呼叫：