帮助解析java中的JSON

如果有人能帮我解析这个json结果，有可能吗。我已将结果检索为字符串

{"query":{"latitude":39.9889,"longitude":-82.8118},"timestamp":1310252291.861,"address":{"geometry":{"coordinates":[-82.81168367358264,39.9887910986731],"type":"Point"},"properties":{"address":"284 Macdougal Ln","distance":"0.02","postcode":"43004","city":"Columbus","county":"Franklin","province":"OH","country":"US"},"type":"Feature"}}

来自，在Java部分下：

---

选择你的毒药

我知道的两个最佳选择是：

使用它们只需调用映射器的一个方法。但是请记住，因为Java是静态类型的，所以您可能必须创建具有所需结构的对象。（你不必这么做，但感觉更自然）

。使用简单直观。对我来说是最好的。首先，它会把它在地图和列表中找到的所有东西都扔掉

像这样：

ObjectMapper mapper = new ObjectMapper();
Map<String,Object> yourData = mapper.readValue(new File("yourdata.json"), Map.class);

ObjectMapper mapper=new ObjectMapper（）；
Map yourData=mapper.readValue（新文件（“yourData.json”）、Map.class）；

这就是所需要的

可以找到一个好的、快速的介绍

还有一个完整的实际数据工作示例：

import java.io.IOException;
import java.util.Map;
import org.codehaus.jackson.map.ObjectMapper;

public class Main {

    public static void main(String[] args) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        Map<?,?> rootAsMap = mapper.readValue(
                "{\"query\":{\"latitude\":39.9889,\"longitude\":-82.8118},\"timestamp\":1310252291.861,\"address\":{\"geometry\":{\"coordinates\":[-82.81168367358264,39.9887910986731],\"type\":\"Point\"},\"properties\":{\"address\":\"284 Macdougal Ln\",\"distance\":\"0.02\",\"postcode\":\"43004\",\"city\":\"Columbus\",\"county\":\"Franklin\",\"province\":\"OH\",\"country\":\"US\"},\"type\":\"Feature\"}}".getBytes(),
                Map.class);
        System.out.println(rootAsMap);
        Map query = (Map) rootAsMap.get("query");
        Map address = (Map) rootAsMap.get("address");
        Map addressProperties = (Map) address.get("properties");
        String county = (String) addressProperties.get("county");
        System.out.println("County is " + county);
    }

}

import java.io.IOException；
导入java.util.Map；
导入org.codehaus.jackson.map.ObjectMapper；
公共班机{
公共静态void main（字符串[]args）引发IOException{
ObjectMapper mapper=新的ObjectMapper（）；
Map rootAsMap=mapper.readValue(
“，”时间戳：1310252291.861，”地址：“：，，，，，，“地址：“，，，，，，，，，，，，“地址：：“几何图形：：，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，哦，“，”国家\“：\”美国\“}，\”类型\“：\”功能\“}}”。getBytes（），
地图(类别),；
System.out.println（rootAsMap）；
映射查询=（Map）rootAsMap.get（“查询”）；
映射地址=（Map）rootAsMap.get（“地址”）；
Map addressProperties=（Map）address.get（“属性”）；
String county=（String）addressProperties.get（“county”）；
System.out.println（“县为”+县）；
}
}

---

现在，整个地图的处理也很好地说明了Bozho的观点，使用完全绑定（通过创建一个反映JSON数据内容的Java类）最终会更好。由于JSON中的坐标有两种不同的格式——有时是一个对象，有时是一个数组——解决方案稍微复杂一些，需要进行必要的自定义反序列化处理

import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;

import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.ObjectCodec;
import org.codehaus.jackson.Version;
import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
import org.codehaus.jackson.map.DeserializationContext;
import org.codehaus.jackson.map.JsonDeserializer;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.module.SimpleModule;
import org.codehaus.jackson.node.ArrayNode;

public class JacksonFoo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setVisibilityChecker(mapper.getVisibilityChecker().withFieldVisibility(Visibility.ANY));
    mapper.registerModule(
      new SimpleModule("CoordinatesDeserializer", Version.unknownVersion())
        .addDeserializer(Coordinates.class, new CoordinatesDeserializer()));

    Result result = mapper.readValue(new File("input.json"), Result.class);
    System.out.println(mapper.writeValueAsString(result));
  }
}

class CoordinatesDeserializer extends JsonDeserializer<Coordinates>
{
  @Override
  public Coordinates deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException
  {
    ObjectCodec codec = jp.getCodec();
    JsonNode node = codec.readTree(jp);
    if (node.isObject())
    {
      ObjectMapper mapper = new ObjectMapper();
      mapper.setVisibilityChecker(mapper.getVisibilityChecker().withFieldVisibility(Visibility.ANY));
      return mapper.readValue(node, Coordinates.class);
    }
    // else it's an array
    ArrayNode array = (ArrayNode) node;
    Coordinates coordinates = new Coordinates();
    coordinates.latitude = codec.treeToValue(array.get(0), BigDecimal.class);
    coordinates.latitude = codec.treeToValue(array.get(1), BigDecimal.class);
    return coordinates;
  }
}

class Result
{
  Coordinates query;
  BigDecimal timestamp;
  Address address;
}

class Coordinates
{
  BigDecimal latitude;
  BigDecimal longitude;
}

class Address
{
  String type;
  Geometry geometry;
  AddressDetails properties;
}

class Geometry
{
  String type;
  Coordinates coordinates;
}

class AddressDetails
{
  String address;
  BigDecimal distance;
  String postcode;
  String city;
  String county;
  String province;
  String country;
}

导入java.io.File；
导入java.io.IOException；
导入java.math.BigDecimal；
导入org.codehaus.jackson.JsonNode；
导入org.codehaus.jackson.JsonParser；
导入org.codehaus.jackson.JsonProcessingException；
导入org.codehaus.jackson.ObjectCodec；
导入org.codehaus.jackson.Version；
导入org.codehaus.jackson.annotate.JsonAutoDetect.Visibility；
导入org.codehaus.jackson.map.DeserializationContext；
导入org.codehaus.jackson.map.jsonderializer；
导入org.codehaus.jackson.map.ObjectMapper；
导入org.codehaus.jackson.map.module.SimpleModule；
导入org.codehaus.jackson.node.ArrayNode；
公务舱杰克逊福
{
公共静态void main（字符串[]args）引发异常
{
ObjectMapper mapper=新的ObjectMapper（）；
setVisibilityChecker（mapper.getVisibilityChecker（）.withFieldVisibility（Visibility.ANY））；
mapper.registerModule(
新的SimpleModule（“CoordinatesDeserializer”，Version.unknownVersion（））
.addDeserializer（Coordinates.class，new Coordinates Deserializer（））；
Result=mapper.readValue（新文件（“input.json”）、Result.class）；
System.out.println（mapper.writeValueAsString（result））；
}
}
类协调反序列化程序扩展JsonDeserializer
{
@凌驾
公共坐标反序列化（JsonParser jp，反序列化上下文ctxt）引发IOException，JsonProcessingException
{
ObjectCodec codec=jp.getCodec（）；
JsonNode=codec.readTree（jp）；
if（node.isObject（））
{
ObjectMapper mapper=新的ObjectMapper（）；
setVisibilityChecker（mapper.getVisibilityChecker（）.withFieldVisibility（Visibility.ANY））；
返回mapper.readValue（节点，坐标，类）；
}
//否则它就是一个数组
ArrayNode数组=（ArrayNode）节点；
坐标=新坐标（）；
coordinates.latitude=codec.treeToValue（array.get（0），BigDecimal.class）；
coordinates.latitude=codec.treeToValue（array.get（1），BigDecimal.class）；
返回坐标；
}
}
班级成绩
{
坐标查询；
大十进制时间戳；
地址；
}
类坐标
{
大十进制纬度；
大十进制经度；
}
班级地址
{
字符串类型；
几何；
地址详细信息和属性；
}
类几何
{
字符串类型；
坐标；
}
类地址详细信息
{
字符串地址；
大十进制距离；
字符串邮政编码；
字符串城市；
弦县；
弦省；
弦国；
}

不，您不需要，请参阅我回复中指向Jackson simple databinding的链接。@fvu您不需要，是的，但在大多数情况下更好，我想我对最佳路线有点困惑。似乎每个结果都不一样。我想我需要澄清对象和数组是什么，每个结果包含什么。@bozho简单数据绑定的简单性让人们很容易开始，“升级”到完整数据绑定是很自然的事情。@flu你能举出一些好的例子或教程吗？我只需要一个快速启动。：）这是一个最差的JSON到/从Java库的示例，对吗？Jackson是我见过的唯一一个JSON到/从Java库的示例，它将任意复杂的JSON对象反序列化为一个映射，只需一行代码。请注意，如果在调用readValue时使用映射参数化类型引用，则对Map和String的强制转换将是不必要的。TypeReference mapType=新的TypeReference（）{}；Map result=new ObjectMapper（）.readValue（新文件（“input.json”），mapType@fvu