Question

例如，我有一个带有以下JSON的回复：

{
    response: {
        id: 20,
        name: Stas
    }
}

我想将其解析为以下对象：

class User {
    private int id;
    private String name;
}

如何跳过响应节点？

我使用Google Http Java客户端，如果有人会回答如何在那里做，那将会很好。这条线将如何改变？

request.setParser(new JacksonFactory().createJsonObjectParser());
return request.execute().parseAs(getResultType());

Answer 1

您现在可以一步实现：

new JsonObjectParser.Builder(jsonFactory)
    .setWrapperKeys(Arrays.asList("response"))
    .build()

http://javadoc.google-http-java-client.googlecode.com/hg/1.15.0-rc/index.html

Answer 2

我不知道Google Http Java客户端，但如果您可以访问Jackson ObjectMapper，您可以执行以下操作：

1。）Enable root unwrapping：

objectMapper.enable(DeserializationFeature.UNWRAP_ROOT_VALUE);

2。）将annotation添加到User.class：

@JsonRootName("response")
class User {
    …
}

我希望你能使用这种方法。

编辑：我挖掘了google-http-java-client API并得出结论，你无法直接访问ObjectMapper。为了使用Jackson的全部功能，您必须编写自己的JsonObjectParser实现来包装“真正的”Jackson解析器。很抱歉，也许其他人可以提出更好的解决方案。

Answer 3

我没有找到解决我的任务的本地方式（对于这个库）。结果，我通过扩展JsonObjectParser的功能解决了这个问题。它需要扩展JacksonFactory，但它是最后一类，所以我使用聚合。

我写了以下课程：

JacksonFilteringFactory

import com.google.api.client.json.JsonObjectParser;
import com.google.api.client.json.jackson2.JacksonFactory;

public class JacksonFilteringFactory {
    private final JacksonFactory factory = new JacksonFactory();

    public JsonObjectParser createJsonObjectParser(String filteringNode) {
        return new FilteringJsonObjectParser(factory, filteringNode);
    }
}

FilteringJsonObjectParser

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.nio.charset.Charset;

import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;

import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.JsonObjectParser;
import com.vkredmessenger.AppController;
import com.vkredmessenger.util.StringUtils;

public class FilteringJsonObjectParser extends JsonObjectParser {

    private String mFilteringNode;

    public FilteringJsonObjectParser(JsonFactory jsonFactory, 
            String filteringNode) {

        super(jsonFactory);

        mFilteringNode = filteringNode;
    }

    @Override
    public Object parseAndClose(InputStream in, 
            Charset charset, Type dataType)
                throws IOException {

        String originalResponse = 
                StringUtils.convertStreamToString(in, charset);

        String response = null;

        try {
            JSONTokener tokener = new JSONTokener(originalResponse);
            JSONObject originalResponseObject = 
                    (JSONObject) tokener.nextValue();

            JSONObject responseObject = 
                    originalResponseObject.getJSONObject(mFilteringNode);
            response = responseObject.toString();

        } catch (JSONException e) {
            e.printStackTrace();
        }

        InputStream filteredIn = 
                new ByteArrayInputStream(response.getBytes(charset));

        return super.parseAndClose(filteredIn, charset, dataType);
    }
}

因此，例如，根据我的问题，结果解析代码如下：

request.setParser(new JacksonFilteringFactory().createJsonObjectParser("response"));
return request.execute().parseAs(getResultType());

使用Google Http Java Client将嵌套的JSON节点解析为POJO

3 个答案: