在Java对象中反序列化通用对象

Question

I have a class called WebApiReturn that is the representation of a class that is sent to me as Json:

 public class WebApiReturn<T> {
    @SerializedName("objectReturn")
    public T ObjectReturn;
    @SerializedName("hasError")
    public boolean HasError;
    @SerializedName("errorMessage")
    public String ErrorMessage;
    @SerializedName("errorCode")
    public String ErrorCode;
}

Besides that I have the representation class of the one I'm trying to get from my WebService:

public class MyObject {
    public int ID_Obj;
    public String ObjectName;
    public Date LastLoginDate;
}

And a function called getObject that get a String formatted as Json sent by my WebService and convert it into this Java Class:

public Object getObject(Class wantedResponseClass) throws JSONException{
        Gson gson = new Gson();
        object = gson.fromJson(this.result, wantedResponseClass);

        return object;
    }

And my Json String is, for example:

{"objectReturn":{"iD_Obj":123,"objectName":"TestName","lastLoginDate":"0001-01-01T00:00:00"},"hasError":false,"errorMessage":null,"errorCode":null}

In and in my code I try to get my object like:

WebApiReturn<MyObject> responseFromServer = new WebApiReturn<>();
try {
     responseFromServer =(WebApiReturn<MyObject>) getObject(responseFromServer.getClass());
     } catch (Exception e) {
          e.printStackTrace();
     }

But then the generic T ObjectReturn, that should be turned to a MyObject when I declared WebApiReturn<MyObject> responseFromServer = new WebApiReturn<>(); is not being filled with the representation of it from the Json. Someone know what am I doing wrong right now? Should I use another type of deserialization or something like that?

Answer 1

You can't use a generic type, at runtime instances of T get replaced with Object so therefore you are trying to deserialised into an Object instead of into MyObject .

If you replaced T with MyObject it would work, for your example at least. However, I imagine you are using generic type because ObjectReturn can have multiple type... you might get an answer here Gson deserialize JSON array with multiple object types

Answer 2

To have a class with a generic class in it deserializer, I created a class with an instance of T that extends AsyncTask (to get the Json from the server asynchronous of the UI Thread) and used JSONObject AND Gson Library to split my class in 2 parts: the class itself and the generic inside. Then I return then as 2 Elements.

Here is my class:

public class RestClient<t>  extends AsyncTask<String, String, String> {

private Class<t> tClass;

private t returnGenericObject;
private WebApiReturn webApiReturn;

private AsyncCallback callback;

public RestClient(Class<t> tClass)
{
    //The instance of the class you want
    this.tClass = tClass;
    webApiReturn= new WebApiReturn();
}

//You get the WebApiReturn with this method
public WebApiReturn getWebApiReturn(){
    return webApiReturn;
}

//You get the inside generic object with this method
public Object getObjectResponse(){
    return returnGenericObject;
}


@Override
protected String doInBackground(String... OnlyTheURL) {
    String urlString = OnlyTheURL[0];
    try {
        URL url = new URL(urlString);

        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");

        connection.connect();

        String result = convertStreamToString(connection.getInputStream()); //A function to convert Stream to String...

        connection.disconnect();

        //Created a JSONObject from the result of the connection
        JSONObject jsonObject = new JSONObject(result);

        //Don't set the Generic Object because it will crash when you try to get back
        webApiReturn.setHasError(jsonObject.getBoolean("hasError"));
        webApiReturn.setErrorMessage (jsonObject.getString("errorMessage"));
        webApiReturn.setErrorCode(jsonObject.getString("errorCode"));

        //Get the String of the generic object within the WebApiReturn
        String obj = jsonObject.get("objetoRetorno").toString();
        //With Gson convert it to the class you expect (that you instanciated in the constructor)
        Gson gson = new Gson();
        ObjetoDeRetorno = gson.fromJson(obj, tClass);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

and where you want to call it you just do like this:

RestClient<YourObject> restClient = new RestClient<>(YourObject.class);
restClient.execute();
Thread.sleep(5000); //You can do this other better ways, but just as example I'm doing this...

//After the execution you get your objects:
WebApiReturn return = getWebApiReturn();
YourObject object = (YourObject) restClient.getObjectResponse();