如何在android中使用Jackson解析json响应？（android的json解析）

25-01-30 24

如果您想了解如何在android中使用Jackson解析json响应？和android的json解析的知识，那么本篇文章将是您的不二之选。我们将深入剖析如何在android中使用Jackson解析js

如果您想了解如何在android中使用Jackson解析json响应？和android的json解析的知识，那么本篇文章将是您的不二之选。我们将深入剖析如何在android中使用Jackson解析json响应？的各个方面，并为您解答android的json解析的疑在这篇文章中，我们将为您介绍如何在android中使用Jackson解析json响应？的相关知识，同时也会详细的解释android的json解析的运用方法，并给出实际的案例分析，希望能帮助到您！

本文目录一览：

如何在android中使用Jackson解析json响应？（android的json解析）
Android – Retrofit Gson-如何在JSON响应中将JSON字符串解析为JSON键的对象？
Android 中Json解析的几种框架(Gson、Jackson、FastJson、LoganSquare)使用与对比
android-如何使用Gson解析JSON对象内的多个JSON数组？
Android中使用Gson解析JSON数据的两种方法

如何在android中使用Jackson解析json响应？（android的json解析）

我通过点击网址获得了一些json响应.我想用jackson来解析json的响应.我尝试使用对象Mapper,但我得到了异常.

JSON：

{
    "contacts": [
        {
                "id": "c200",
                "name": "ravi raja",
                "email": "raja@gmail.com",
                "address": "xx-xx-xxxx,x - street, x - country",
                "gender" : "male",
                "phone": {
                    "mobile": "+91 0000000000",
                    "home": "00 000000",
                    "office": "00 000000"
                }
        },
        {
                "id": "c201",
                "name": "Johnny Depp",
                "email": "johnny_depp@gmail.com",
                "address": "xx-xx-xxxx,x - street, x - country",
                "gender" : "male",
                "phone": {
                    "mobile": "+91 0000000000",
                    "home": "00 000000",
                    "office": "00 000000"
                }
        },

    ]
}

POJO：

public class ContactPojo {

    String name,email,gender,mobileno;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getMobileno() {
        return mobileno;
    }

    public void setMobileno(String mobileno) {
        this.mobileno = mobileno;
    }

}

码：

ObjectMapper mapper=new ObjectMapper();
             userData=mapper.readValue(jsonResponse,ContactPojo.class);

解决方法:

正如我所看到的,json不是数组,而是包含一个包含数组的对象的对象,因此您需要创建一个临时数据持有者类,以便Jackson对其进行解析.

private static class ContactJsonDataHolder {
    @JsonProperty("contacts")
    public List<ContactPojo> mContactList;
}

public List<ContactPojo> getContactsFromJson(String json) throws JSONException, IOException {

    ContactJsonDataHolder dataHolder = new ObjectMapper()
        .readValue(json, ContactJsonDataHolder.class);

    // ContactPojo contact = dataHolder.mContactList.get(0);
    // String name = contact.getName();
    // String phoneNro = contact.getPhone().getMobileNro();
    return dataHolder.mContactList;
}

对你的班级进行一些调整：

@JsonIgnoreProperties(ignoreUnkNown=true)
public class ContactPojo {

    String name, email, gender;
    Phone phone;

    @JsonIgnoreProperties(ignoreUnkNown=true)
    public static class Phone {

         String mobile;

         public String getMobileNro() {
              return mobile;
         }
    }

    // ...

    public Phone getPhone() {
        return phone;
    }

@JsonIgnoreProperties(ignoreUnkNown = true)注释确保当你的类不包含json中的属性时,你没有得到异常,例如你的json中的地址可以给出异常,或者在Phone对象中为home.

Android – Retrofit Gson-如何在JSON响应中将JSON字符串解析为JSON键的对象？

这是我的 JSON响应：

{
      "id": 2,"name": "Test","content": "{\"type\": \"status\",\"text\": \"Lorem ipsum dummy text.\",\"id\": 1}"
}

这些是模型结构：

class TestModel {
    public int id;
    public String name;
    public Content content;
}

class Content {
    public int id;
    public String status;
    public String text;
}

我想使用Retrofit和GsonConvertor将内容的值直接解析到我的Content模型对象中.但是目前,我将其解析为String值,而不是使用Gson.fromJson()转换为我的Content模型对象.是否有任何解决方案可以获得我的预期结果？

当我以前使用GsonConverterFactory解析它时,Retrofit在onFailure方法中给出了回调,但有以下异常：

java.lang.IllegalStateException: Expected BEGIN_OBJECT but was STRING at line 4 column 19 path $.data[0].content

解决方法

问题在于JSON响应,它不在 correct JSON format中.“content”字段应该是一个对象,而不是一个字符串：

{
    "id": 2,"content": {
        "type": "status","text": "Lorem ipsum dummy text.","id": 1
    }
}

这将允许gson.fromJson(response,TestModel.class)或带有GsonConverterFactory的RetroFit将您的响应正确解析为相应的对象.

当然,这仅适用于您能够更改正在接收的JSON响应的情况.如果没有,首先要确保控制响应的人知道他们做错了.如果没有任何变化,那么您应该能够通过将TestModel中的内容更改为String来解决此问题：

class TestModel {
    public int id;
    public String name;
    public String content;
}

class Content {
    public int id;
    public String type;
    public String text;
}

然后分别解析每个对象：

TestModel testModel = gson.fromJson(response,TestModel.class);
Content content = gson.fromJson(testModel.content,Content.class);

如果无法更改响应,则另一个选项是为Content对象创建TypeAdapter：

public class ContentAdapter extends TypeAdapter<Content> {

    @Override
    public void write(JsonWriter out,Content value) throws IOException {
        // Todo: Writer implementation
    }

    @Override
    public Content read(JsonReader in) throws IOException {
        if(in.peek() != JsonToken.NULL) {
            return fromJson(in.nextString());
        } else {
            in.nextNull();
            return null;
        }
    }

}

然后将TypeAdapter添加到您的GSON实现：

Gson gson = new GsonBuilder()
        .registerTypeAdapter(Content.class,new ContentAdapter()).create();

Android 中Json解析的几种框架(Gson、Jackson、FastJson、LoganSquare)使用与对比

介绍

移动互联网产品与服务器端通信的数据格式，如果没有特殊的需求的话，一般选择使用JSON格式，Android系统也原生的提供了JSON解析的API，但是它的速度很慢，而且没有提供简介方便的接口来提高开发者的效率和降低出错的可能。因此，通常情况下，我们都会选择其他优秀的JSON解析实现，用以替代系统的API，目前JSON解析的开源实现主要包括一下几种：

Gson
JackJson
FastJson
LoganSquare

例如有如下JSON数据（序列化：对象转换成字符串；反序列化：字符串转换成对象）：

{
    "data": {
        "cities": [
            {
                "area": 123, "city": "anhuisheng", "people": 789 }, { "area": 456, "city": "jiangsusheng", "people": 678 } ], "location": "china" }, "retcode": 200 }

结构图如下：

Gson

Gson是Google出品的Json解析函数库，可以将JSON字符串反序列化为对应的Java对象，或者反过来将Java对象序列化为对应的字符串，免去了开发者手动通过JSONObject和JSONArray将Json字段逐个进行解析的烦恼，也减少了出错的可能性，增强了代码的质量。使用gson解析时候，对应的Java实体类无需要使用注解进行标记，支持任意复杂Java对象包括没有源代码的对象。

定义json对应的类的步骤

先定义成员变量名称
再定义成员变量的类型
再定义泛型的类
从外向类逐渐推荐

步骤一定义JSON对应的类

public class GsonData {
   private Data data;
   private int retcode; @Override public String toString() { return "GsonData{" + "data=" + data + ", retcode=" + retcode + ''}''; } public Data getData() { return data; } public void setData(Data data) { this.data = data; } public int getRetcode() { return retcode; } public void setRetcode(int retcode) { this.retcode = retcode; } }

public class Data {
    private List<City> cities;
    private String location;

    @Override
    public String toString() { return "Data{" + "cities=" + cities + ", location=''" + location + ''\'''' + ''}''; } public List<City> getCities() { return cities; } public void setCities(List<City> cities) { this.cities = cities; } public String getLocation() { return location; } public void setLocation(String location) { this.location = location; } }

public class City {
    private int area;
    private String city; private int people; @Override public String toString() { return "City{" + "area=" + area + ", city=''" + city + ''\'''' + ", people=" + people + ''}''; } public int getArea() { return area; } public void setArea(int area) { this.area = area; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public int getPeople() { return people; } public void setPeople(int people) { this.people = people; } }

 private GsonData getDataToGson() {
        GsonData obj = new GsonData();
        obj.setRetcode(200); Data data=new Data(); City city1=new City(); city1.setArea(123); city1.setCity("anhuisheng"); city1.setPeople(789); City city2=new City(); city2.setArea(456); city2.setCity("jiangsusheng"); city2.setPeople(678); ArrayList<City> cities=new ArrayList<>(); cities.add(city1); cities.add(city2); data.setCities(cities); data.setLocation("china"); obj.setData(data); return obj; }

步骤二序列化与反序列化

序列化：

Gson gson = new Gson();
String json = gson.toJson(getDataToGson());

反序列化：

Gson gson=new Gson();
GsonData gsonData = gson.fromJson(JSON_STRING,GsonData.class);

Jackson

jackson是java语言的一个流行的JSON函数库，在android开发使用过程中，主要包含三部分。Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象

jackson-core:json流处理核心库。
jackson-databind:数据绑定函数库，实现Java对象和JSON字符串之间的相互转换。
jackson-anntations:databind使用的注解函数库

JsonFactory：这个类是Jackson项目主要的工厂方法，主要用于配置和构建解析器(比如 JsonParser)和生成器(比如 JsonGenerator)，这个工厂实例是线程安全的，如果有配置的话，可以重复使用。

JsonGenerator：这个类主要是用来生成Json格式的内容的，我们可以使用JsonFactory的方法生成一个实例。

JsonParser：这个主要是用来读取Json格式的内容，并且完成解析操作的，我们可以使用JsonFactory的方法生成一个实例。

ObjectMapper：这个类提供了Java对象和Json之间的转化，主要通过JsonParser和JsonGenerator实例来完成实际的对Json数据的读写操作。这个类是ObjectCodec的子类，主要的实现细节都在ObjectCodec里面。而且这个类可以重复使用，所以一般会创建这个类的一个单例模式，比如下面的代码

public class JacksonMapper {
    private static final ObjectMapper mapper = new ObjectMapper(); private JacksonMapper() { } public static ObjectMapper getInstance() { return mapper; } }

简单对象的Json数据生成

这里所说的简单对象指的是单一对象或者是对象的集合类

public String getJsonString(Object object) throws Exception {
        return JacksonMapper.getInstance().writeValueAsString(object); }

在这种方法中，我们直接使用ObjectMapper类的writeValueAsString()，就可以把对象的json格式作为返回值直接返回。
除此之外，我们还可以使用第二种方法，代码如下

//序列化
public String getJsonString1(Object object) throws Exception {  
            ObjectMapper mapper = JacksonMapper.getInstance();  
            StringWriter sw = new StringWriter(); JsonGenerator gen = new JsonFactory().createJsonGenerator(sw); mapper.writeValue(gen, object); gen.flush(); gen.close(); return sw.toString(); }

反序列化：

GsonData gsonData = JacksonMapper.getInstance().readValue(JSON_STRING, new GsonData().getClass());

由于jackson是针对Java语言通用的JSON函数库，并没有为Android优化定制过，因此函数包中包含了很多非必需的API，相比其他JSON函数库，用于Android平台会更显著的增大最终生成的APK体积。

参考：http://blog.csdn.net/yan8024/article/details/46048807

Fastjson

fastjson是阿里巴巴公司出品的一个java语言编写的高性能且功能完善的JSON函数库，他采用一种“假定有序快速匹配”的算法，把JSON parse的性能提升到极致，号称是目前java语言中最快的JSON库。Fastjson接口简单易用，已经被广泛使用在缓存序列化，协议交互。Web输出、Android客户端等多种应用场景。

序列化：

JSON.toJSONString(getDataToGson())

反序列化：

JSON.parseObject(JSON_STRING).toString()

由于是java语言是互通的，因此，在以前的Android上使用时，Fastjson不可避免的引入了很多对于Android而言冗余的功能，从而增加了包的大小，很多人使用的就是标准版本的fastjson,但事实上，fastjson还存在一个专门为android定制的版本-fastjson-android。和标准版相比，Android版本中去掉了一些Android虚拟机dalvik不支持的功能，使得jar更小。

LoganSquare

LoganSquare是近两年崛起来的快速解析和序列化JSON的Android函数库。其底层基于jackson的streaming API,使用APT（Android Annotation Tool）实现编译时注解，从而提高JSON解析和序列化的性能。
android studio gradle配置：
对于低版本配置：

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath ''com.neenbedankt.gradle.plugins:android-apt:1.8''
    }
}
apply plugin: ''com.neenbedankt.android-apt''

dependencies { apt ''com.bluelinelabs:logansquare-compiler:1.3.6'' compile ''com.bluelinelabs:logansquare:1.3.6'' }

但是对于相对于较高的android studio 版本，Gradle不支持android-apt生成编译时注解的方式，所以改用下面方式：

annotationProcessor ''com.bluelinelabs:logansquare-compiler:1.3.6''
compile ''com.bluelinelabs:logansquare:1.3.6''

第一步定义bean

@JsonObject
public class GsonData { @JsonField private Data data; @JsonField private int retcode; @Override public String toString() { return "GsonData{" + "data=" + data + ", retcode=" + retcode + ''}''; } public Data getData() { return data; } public void setData(Data data) { this.data = data; } public int getRetcode() { return retcode; } public void setRetcode(int retcode) { this.retcode = retcode; } }

@JsonObject
public class Data { @JsonField private List<City> cities; @JsonField private String location; @Override public String toString() { return "Data{" + "cities=" + cities + ", location=''" + location + ''\'''' + ''}''; } public List<City> getCities() { return cities; } public void setCities(List<City> cities) { this.cities = cities; } public String getLocation() { return location; } public void setLocation(String location) { this.location = location; } }

@JsonObject
public class City { @JsonField private int area; @JsonField private String city; @JsonField private int people; @Override public String toString() { return "City{" + "area=" + area + ", city=''" + city + ''\'''' + ", people=" + people + ''}''; } public int getArea() { return area; } public void setArea(int area) { this.area = area; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public int getPeople() { return people; } public void setPeople(int people) { this.people = people; } }

序列化：

LoganSquare.parse(JSON_STRING, GsonData.class).toString()

反序列化：

LoganSquare.serialize(getDataToGson()).toString()

下图是官网的一张Benchmark图，从中可以看出LonganSquare和gson、jackson databind的性能对比。

单纯从性能方面来看，LoganSquare应该是完胜gson和jackson的。如果和fastjson相比较两者应该不相伯仲的。

总结起来。四个函数库的大小分别如下：

gson:232KB
jackson:259+47+1229=1.5M
Fastjson:417KB
Fastjson.android:256KB
LoganSquare:307KB

从性能和包的大小综合考虑我们会选择fastjson.android作为基础技术堆栈中的JSON解析和序列化库。

代码

(PS:Android studio 通过下载插件GsonFormat 可以快速实现实体类)

android-如何使用Gson解析JSON对象内的多个JSON数组？

这个问题已经在这里有了答案： > Parse JSON file using GSON 3个
如何使用Gson解析JSON对象内的多个JSON数组？

{
    "id": 1,
    "Data": {
        "Details": [{
            "Code": "1",
            "Name": "John"
        }, {
            "Code": "2",
            "Name": "Peter"
        }],
        "Other": [{
            "age": "56",
            "gender": "M"
        }, {
            "age": "66",
            "gender": "M"
        }]
    },
    "message": "SUCCESS"
}

任何帮助,将不胜感激.

解决方法:

简单！

JSONObject jsonObj = new JSONObject(yourStringHere).optJSONObject("Data");
JSONArray jsonDetail = jsonObj.optJSONArray("Details");
JSONArray jsonOther = jsonObj.optJSONArray("Other");

Android中使用Gson解析JSON数据的两种方法

Json是一种类似于XML的通用数据交换格式,具有比XML更高的传输效率.
从结构上看，所有的数据（data）最终都可以分解成三种类型：
第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"北京"这个单独的词。
第二种类型是序列（sequence），也就是若干个相关的数据按照一定顺序并列在一起，又叫做数组（array）或列表（List），比如"北京，上海"。
第三种类型是映射（mapping），也就是一个名/值对（Name/value），即数据有一个名称，还有一个与之相对应的值，这又称作散列（hash）或字典（dictionary），比如"首都：北京"。
Json的规格非常简单，只用一个页面几百个字就能说清楚，而且Douglas Crockford声称这个规格永远不必升级，因为该规定的都规定了。
1）并列的数据之间用逗号（"，"）分隔。
2）映射用冒号（"："）表示。
3）并列数据的集合（数组）用方括号("[]")表示。
4）映射的集合（对象）用大括号（"{}"）表示。

在Android中可以使用Gson解析JSON数据
首先，从 code.google.com/p/google-gson/downloads/list下载GsonAPI：
google-gson-1.7.1-release.zip
把gson-1.7.jar copy到libs(项目根目录新建一个libs文件夹)中。
可以使用以下两种方法解析JSON数据：
通过获取JsonReader对象解析JSON数据：

复制代码代码如下:

String jsonData = "[{\"username\":\"arthinking\",\"userId\":001},{\"username\":\"Jason\",\"userId\":002}]";
try{
JsonReader reader = new JsonReader(new StringReader(jsonData));
reader.beginArray();
while(reader.hasNext()){
reader.beginobject();
while(reader.hasNext()){
String tagName = reader.nextName();
if(tagName.equals("username")){
System.out.println(reader.nextString());
}
else if(tagName.equals("userId")){
System.out.println(reader.nextString());
}
}
reader.endobject();
}
reader.endarray();
}
catch(Exception e){
e.printstacktrace();
}

通过把JSON数据映射成一个对象，使用Gson对象的fromJson()方法获取一个对象数组进行操作：
创建JSON数据对应的一个POJO对象User.java：

复制代码代码如下:

public class User {
private String username ;
private int userId ;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
}

使用Gson对象获取User对象数据进行相应的操作：

复制代码代码如下:

Type listType = new Typetoken<LinkedList<User>>(){}.getType();
Gson gson = new Gson();
LinkedList<User> users = gson.fromJson(jsonData,listType);
for (Iterator iterator = users.iterator(); iterator.hasNext();) {
User user = (User) iterator.next();
System.out.println(user.getUsername());
System.out.println(user.getUserId());
}