Question

我有一个通用的sendRequest（）方法，用于从服务器返回json结果。我现在在一个回调实例中解析结果，但我宁愿只是将一个类型传递给sendRequest（）方法，这样我就可以在回调之前解析和处理异常。我怎样才能做到这一点？我已经在下面提供了相关代码和一些评论。

public void sendRequest(int method, String url, final RequestListener listener) {
    StringRequest postRequest = new StringRequest(method, url,
            new Response.Listener<String>()
            {
                @Override
                public void onResponse(String response) {
                    listener.gotResponse(response, null);

                    // Instead of parsing this into a user object, I'd like to parse it into
                    // a type that I pass into the sendRequest() method.
                    try {
                        User user = User.parseJson(new JSONObject(response));
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
            }

Answer 1

首先请注意，开箱即用JsonObjectRequest会将响应直接转换为JSONObject，在您的情况下似乎优于StringRequest，但是你想进一步发展我会建议基于通用的unmarshaller创建一个custom request。

public interface JsonUnmarshaller<T> {
    T parse(JSONObject object) throws JSONException;
}

自定义请求可能是这样的：

public class JSONRequest extends Request<T> {
    private final Listener<T> mListener;
    private final JsonUnmarshaller<T> unmarshaller;

    public JSONRequest(int method, String url, Listener<T> listener,
        ErrorListener errorListener, JsonUnmarshaller<T> unmarshaller) {
        super(method, url, errorListener);
        mListener = listener;
        this.unmarshaller = unmarshaller;
    }

    @Override
    protected void deliverResponse(T response) {
        mListener.onResponse(response);
    }
    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        String parsed;
        try {
            parsed = new String(
                response.data, HttpHeaderParser.parseCharset(response.headers)
            );
        } catch (UnsupportedEncodingException e) {
            parsed = new String(response.data);
        }
        try {
            return Response.success(
                unmarshaller.parse(new JSONObject(parsed)), 
                HttpHeaderParser.parseCacheHeaders(response)
            );
        } catch (JSONException je) {
            return Response.error(new ParseError(je));
        }
    }
}

然后你的方法是：

public <T> void sendRequest(int method, String url, final RequestListener 
                            listener, JsonUnmarshaller<T> unmarshaller) {
    JSONRequest postRequest = new JSONRequest(...

Answer 2

在这里为你写了一些东西，我想你可以将它应用到你的例子中：

import java.util.*;
public class Cat{
    public static void main(String... args){
        Cat cat = new Cat();
        cat.send(Dog.class);
        cat.send(Mouse.class);
    }

    public <T extends Parseable> void send(Class<T> clazz){
        try{
            T t = clazz.newInstance();
            t.parse();
        } catch(Exception e){

        }
    }
}

interface Parseable{
    void parse();
}

class Dog implements Parseable{
    public void parse(){
        System.out.println("Dog parse");
    }
}

class Mouse implements Parseable{
    public void parse(){
        System.out.println("Mouse parse");
    }
}

您的方法是静态的，因此您可能只需执行T.parseJson()。不确定将通用类型转移到匿名监听器是否有任何问题，但我希望它能够正常工作。

在Java中创建泛型类和参数

2 个答案: