在开发 Android 应用程序时，我遇到了一个问题，当时我想制作一个最终的通用方法来发送 HTTP 请求(使用 loopj)并反序列化它们(使用 Gson)。

正如您在使用 gson.fromJson 时可能知道的，您不能这样做:

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

或

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

您将获得 LinkedTreeMap 对象(或 LinkedTreeMap 对象)。

如果您仍然想要反序列化通用类型对象(-s)，请参阅下面的答案。

+Bonus:loopj+gson 的最终通用解决方案

感谢这些帖子的作者和评论者:

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

How to get concrete type of a generic interface

Java Type Generic as Argument for GSON

最佳答案

将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>是一个接口(interface)(可能是一个回调，你将在后面的 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
    }
});

欢迎任何改进!

关于java - Gson fromJson反序列化泛型，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26203634/