來自Json的Gson反編譯泛型

Question

在使用Android應用程序時，我遇到了一個問題，當我想制作一個最終的通用方法來發送HTTP請求（使用loopj）並反序列化它們（使用Gson）。

正如您在使用gson.fromJson可能知道的gson.fromJson您不能這樣做：

gson.fromJson(responseBody, new TypeToken<T>() {}.getType());

要么

gson.fromJson(responseBody, new TypeToken<ArrayList<T>>() {}.getType())

您已經作為T傳遞的實際對象（或LinkedTreeMap情況下的實際對象列表）代替了LinkedTreeMap對象（或LinkedTreeMap對象列表）。

如果你想要仍然想要反序列化泛型類型對象（-s），請參閱下面的答案。

+ Bonus：loopj + gson的終極通用解決方案

感謝這些帖子的作者和評論者：

http://blog.xebia.com/2009/02/07/acessing-generic-types-at-runtime-in-java/

如何獲得具體類型的通用接口

Java Type Generic作為GSON的參數

Answer 1

將JSON對象反序列化為泛型類型java對象

首先，我們需要獲得泛型類型T的實際類。

我們可以通過傳遞類本身（ Class<T> cl ）或從具有泛型類型的對象（ SomeObject<T> someObjectWithGenericType ）獲取類來實現。 我將在示例中使用第二種情況。

然后我們需要創建一個Element<T>類的特殊對象，它將告訴Gson用於反序列化的類。

public <T> T getObject(String json, SomeObject<T> someObjectWithGenericType) {
    Class cl = getTypeClassOfObject(someObjWithGenericType);
    T object = gson.fromJson(json, new Element<T>(cl));
    return object;
}

private Class getTypeClassOfObject(Object obj) {
    return (Class) ((ParameterizedType) obj.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}

private class Element<T> implements ParameterizedType {

    private Class<T> cl;

    public Element(Class<T> cl) {
        this.cl = cl;
    }

    public Type[] getActualTypeArguments() {
        return new Type[] {cl};
    }

    public Type getRawType() {
        return cl;
    }

    public Type getOwnerType() {
        return null;
    }
}

如果您的SomeObject<T>是一個接口（可能是回調，稍后您將在loopj示例中看到），您可以使用此方法而不是getTypeClassOfObject ：

private Class getTypeClassOfInterfaceObject(Object obj) {
    return (Class) ((ParameterizedType) obj.getClass().getGenericInterfaces()[0]).getActualTypeArguments()[0];
}

將JSON數組反序列化為泛型類型java對象的列表

同樣的想法，但我們有一個不同的特殊類來幫助Gson進行反序列化：

public <T> List<T> getList(String json, SomeObject<T> someObjectWithGenericType) {
    Class cl = getTypeClassOfObject(someObjWithGenericType);
    List<T> list = gson.fromJson(json, new ListWithElements<T>(cl));
    return list;
}

private class ListWithElements<T> implements ParameterizedType {

    private Class<T> elementsClass;

    public ListWithElements(Class<T> elementsClass) {
        this.elementsClass = elementsClass;
    }

    public Type[] getActualTypeArguments() {
        return new Type[] {elementsClass};
    }

    public Type getRawType() {
        return List.class;
    }

    public Type getOwnerType() {
        return null;
    }
}

獎金

正如您將在這里看到的， someObjectWithGenericType將成為具有泛型類型T的回調。 即使我使用loopj，我確信任何其他異步http客戶端都可以用來實現相同的結果。

loopj + Gson with generics：object

public <T> void getObject(String url, HashMap<String, String> paramsMap, final GetObjectCallback<T> callback) {
    RequestParams params = convertParams(paramsMap);
    client.get(url, params, new TextHttpResponseHandler() {
        @Override
        public void onSuccess(int statusCode, Header[] headers, String responseBody) {
            try {
                Class cl = getTypeClassOfInterfaceObject(callback);
                T object = gson.fromJson(responseBody, new Element<T>(cl));
                if (object != null) {
                    callback.onSuccess(object);
                } else {
                    callback.onFailure();
                }
            } catch (Exception e) {
                e.printStackTrace();
                callback.onFailure();
            }
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, String responseBody, Throwable error) {
            error.printStackTrace();
            callback.onFailure();
        }
    });
}

private RequestParams convertParams(HashMap<String, String> paramsMap) {
    RequestParams params = new RequestParams();
    if (paramsMap != null) {
        for (String key : paramsMap.keySet()) {
            params.put(key, paramsMap.get(key));
        }
    }
    return params;
}

public interface GetObjectCallback<T> {
    void onSuccess(T item);
    void onFailure();
}

loopj + Gson with generics：list

public <T> void getList(String url, HashMap<String, String> paramsMap, final GetListCallback<T> callback) {
    RequestParams params = convertParams(paramsMap);
    client.get(url, params, new TextHttpResponseHandler() {
        @Override
        public void onSuccess(int statusCode, Header[] headers, String responseBody) {
            try {
                Class cl = getTypeClassOfInterfaceObject(callback);
                List<T> list  = gson.fromJson(responseBody, new ListWithElements<T>(cl));
                if (list != null) {
                    callback.onSuccess(list);
                } else {
                    callback.onFailure();
                }
            } catch (Exception e) {
                e.printStackTrace();
                callback.onFailure();
            }
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, String responseBody, Throwable error) {
            error.printStackTrace();
            callback.onFailure();
        }
    });
}

public interface GetListCallback<T> {
    void onSuccess(List<T> list);
    void onFailure();
}

用法：對象

api.getObject(URL, paramsMap, new GetObjectCallback<NewsItem>() {
    @Override
    public void onSuccess(NewsItem item) {
        // do something
    }

    @Override
    public void onFailure() {
        // do something
    }
});

用法：清單

api.getList(URL, paramsMap, new GetListCallback<Comment>() {
    @Override
    public void onSuccess(List<Comment> list) {
        // do something
    }

    @Override
    public void onFailure() {
        // do something
    }
});

任何改進都非常受歡迎！