1. FastJSON

阿里巴巴开源框架，效率最高

1.1 maven依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.4</version>
</dependency>

1.2 fastJSON的@JSONField 注解

package com.alibaba.fastjson.annotation;
public @interface JSONField {
    // 配置序列化和反序列化的顺序，1.1.42版本之后才⽀持
    int ordinal() default 0;
    // 指定字段的名称
    String name() default "";
    // 指定字段的格式，对⽇期格式有⽤
    String format() default "";
    // 是否序列化
    boolean serialize() default true;
    // 是否反序列化
    boolean deserialize() default true;
}

可以在属性上或者get/set方法上添加注解

1.2.1 serialize

表示是否序列化，我们可以让某个字段的serialize=false，表示不将该字段转换为json字符串

public class Dep {
	// 表示不将该字段转换为json字符串
	@JSONField(serialize=false)
	private Long uuid;
	private String name;
	private String tele;
}

1.2.2 ordinal

指定序列化和反序列化的顺序

public static class VO {
    @JSONField(ordinal = 3)
    private int f0;
    @JSONField(ordinal = 2)
    private int f1;
    @JSONField(ordinal = 1)
    private int f2;
}

1.2.3 name

指定字段的名称

@JSONField(name="ID")
private int id;

1.2.4 format

指定字段的格式

@JSONField(format="yyyyMMdd")
public Date date;

1.2.5 deserialize

是否反序列化

注意：若属性是私有的，必须有set*方法。否则无法反序列化

1.3 JSON的相关操作

String转对象

 Student stu =   JSON.parseObject(json,Student.class);

List<String> list=JSON.parseArray(json2, String.class);

对象转String

JSON.toJSONString(stu);
//or String json   = JSON.toJSON(stu).toString();

1.4 复杂的JSON操作

1.4.1 JSON字符串是简单对象类型，被大括号包围

当待解析的JSON字符串是简单对象类型的，即用大括号包围，此时采用JSONObject对象来处理

public void test3() {
        //简单对象类型
        String   jsonStr = "{'name':'Misaya','position':'Mid','hero':':Twisted   Fate'}";
        JSONObject   json = JSON.parseObject(jsonStr);
        String name   = json.getString("name");
        System.out.println(name);
        System.out.println(json);
}

1.4.2 JSON字符串是数组类型，被中括号包围

当待解析的JSON字符串是简单数组类型的，即用中括号包围，此时采用JSONArray对象来处理

public void   test4(){
        //数组类型
        String   jsonStr = "['元旦','五一','国庆','春节']";      
        JSONArray   json = JSON.parseArray(jsonStr);
        String first   = (String) json.get(0);
        System.out.println(first);
        System.out.println(json);
}

1.4.3 JSON字符串为混合类型，既有简单对象，又有数组，逐层解析

 public void   test5() {
    //混合类型
    String   jsonStr = "[{'name':'元旦','vacation':'3'},{'name':'五一','vacation':'7'},{'name':'国庆','vacation':'7'}]";
    JSONArray   jsonArr = JSON.parseArray(jsonStr);
    JSONObject   jsonObj1 = jsonArr.getJSONObject(0);
    System.out.println(jsonObj1);
}

1.4.4 JSON字符串有对应的类时，对象的解析

public void Json2Obj() {
    //待解析的json字符串
    String   jsonString = "{'name':'卢本伟','age':24,'Hero':{'name':'Fizz','Position':'Mid','charactor':'killer'},'nickNames':['五五开','芦苇','white'],'Honors':[{'year':2011,'name':'TGA总决赛冠军'},{'year':2013,'name':'S3全球总决赛中国区冠军'},{'year':2013,'name':'S3全球总决赛亚军'}]}";
    
    Player p =   JSON.parseObject(jsonString, Player.class);
    System.out.println(p);
}

2. GSON

谷歌产品

2.1 maven依赖

 <dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.1</version>
 </dependency>

2.2 String与Object互转

2.2.1 String转对象

Gson gson =   new Gson();

Grade grade   = gson.fromJson(json1,Grade.class);

ArrayList<String>   list=gson.fromJson(json2,new TypeToken<ArrayList<String>>(){}.getType());

2.2.2 Object转String

String json=gson.toJson(grade);

3. jackSon

springMVC内置解析器就是jackson

3.1 maven依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

3.2 JSON操作

3.2.1 对象和String之间的转换

ObjectMapper mapper=new ObjectMapper();
Grade grade=mapper.readValue(json1, Grade.class);
mapper.writeValueAsString(grade);

3.2.2 对JsonNode的遍历

JsonNode jsonNode = mapper.readTree(jsonStr);
Iterator<String> keys = jsonNode.fieldNames();
while(keys.hasNext()){
    String fieldName   = keys.next();
    System.out.println(fieldName + " : " +   jsonNode.path(fieldName).toString());
}

3.2.3 json解析普通属性

public void   getCustomProp(){
    String   jsonStr =   "{\"price\":5000,\"count\":100,\"function\":[{\"name\":\"camera\",\"config\":1500},{\"name\":\"music\",\"config\":2000}]}";
    try{
         ObjectMapper   objMap = new ObjectMapper();
         JsonNode   root = objMap.readTree(jsonStr);

         //在根节点上的属性
         int   price = root.path("price").asInt();
         int   count = root.path("count").asInt();
    
        System.out.println("price"+":"+price);
        System.out.println("count"+":"+count);

        //在叶子节点上的属性
        JsonNode   node = root.path("function");
        String    fun1_name =   node.path(0).path("name").asText();
        int fun1_config =   node.path(0).path("config").asInt();

        System.out.println("function1:"+fun1_name+":"+fun1_config);

        String    fun2_name =   node.path(1).path("name").asText();
        int   fun2_config = node.path(1).path("config").asInt();
        System.out.println("function2:"+fun2_name+":"+fun2_config);           

    }catch(Exception ex){
              System.out.println(ex.getMessage());
    }

}

3.2.4 解析对象字符串

public void   json2obj(){
    String   jsonStr = "{\"name\":\"二狗\",\"age\":15,\"idCard\":\"42125\"}";
    try{
        ObjectMapper objMapper = new ObjectMapper();
        //当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能
        objMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,   false);
        Person p   = objMapper.readValue(jsonStr, Person.class);
        System.out.println(p);   
    }catch(Exception e){
        System.out.println(e.getMessage());
    }
}

3.2.5 解析对象数组构成的字符串

public  void jackSonTest(){
    String jsonStr =   "[{\"name\":\"二狗\",\"age\":15,\"idCard\":\"42125\"},    {\"name\":\"铁柱\",\"age\":12,\"idCard\":\"46521\"}]";
    try{
        ObjectMapper   mapper = new ObjectMapper(); 
        TreeNode  treeNode =   mapper.readTree(jsonStr);
        List<Person> persons = mapper.readValue(jsonStr, new   TypeReference<List<Person>>(){});
        for (Person   person : persons){
            System.out.println(person);
        }  
    }catch(Exception   e){
        System.out.println(e.getMessage());
    }
}

4. json-lib

json-lib具有通用性，但是比较麻烦，且时间有些久远，jar包只更新到2010年

4.1 maven依赖

<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>//jar包区分jdk1.3和jdk1.5版本
</dependency>

4.2 json操作

4.2.1 String与Object互转

JSONObject jsonobject= JSONObject.fromObject(str);
String str = JSONObject.toString

4.2.2 获取JSONObject数据

String str = JSONObject.getInt("keys")
String str = JSONObject.getString("keys")
JSONArray = JSONObject.getJSONArray(String);

4.2.3 遍历JSONArray

for(i<JSONArray.size()){
    JSONObject = JSONArray.getJSONObject(i);
    JSONObject.getInt()...
}

Iterator<String> iterator = JSONObject.keys();
while(iterator.hasNext()){
    String keys = iterator.next();
}

4.2.4 JSONObject转对象

Grade grade = (Grade)JSONObject.toBean(jsonObject,Grade.class);

5. org.json

与json-lib相类似，主要有三点区别

5.1 maven依赖

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20170516</version>
</dependency>

5.2 创建JSON

JSONObject = new JSONObject(str);

注意：

1. net.sf.json.JSONObject：没有严格要求获取字段的类型跟getXXX()的类型一样

2. org.json.JSONObject：获取的字段类型必须跟getXXX()的类型一样

5.3 JSON操作

5.3.1 简单对象类型

待解析的字符串是简单对象类型，被大括号 { }包围时

public void   test6() {
    //待解析的json字符串
    String   jsonString = "{'name':'卢本伟','age':24,'Position':'Mid'}";
    //因为json字符串是大括号包围，所以用JSONObject解析
    JSONObject   json = new JSONObject(jsonString);   

    String name   = json.getString("name");
    int age =   json.getInt("age");
    String   position = json.getString("Position");
    System.out.println("姓名："+name);
    System.out.println("年龄："+age);
    System.out.println("位置"+position);               
}

5.3.2 数组类型

待解析的字符串是数组类型，被中括号 [ ] 包围时

public void   test7() {
    //待解析的json字符串
    String jsonString   = "['卢本伟','white','卢伟','五五开']";
    //因为json字符串是大括号包围，所以用JSONArray解析
    JSONArray   jsonArray = new JSONArray(jsonString);
    //遍历即可，foreach或for循环
    for (Object   name : jsonArray) {
        System.out.println(name);
    }
}

5.3.3 逐层解析

待解析的字符串既有中括号 [ ]、又有大括号[ ] 包围时，逐层解析

public void   test5() {
    //待解析的json字符串
    String   jsonString = "{'name':'卢本伟','age':24,'Hero':{'name':'Fizz','Position':'Mid','charactor':'killer'},'nickNames':['五五开','芦苇','white'],'Honors':[{'year':2011,'name':'TGA总决赛冠军'},{'year':2013,'name':'S3全球总决赛中国区冠军'},{'year':2013,'name':'S3全球总决赛亚军'}]}";
    try {
        //因为json字符串是大括号包围，所以用JSONObject解析
        JSONObject   json = new JSONObject(jsonString);
        /*
         * 普通元素，根据类型直接获取
         */
        String name   = json.getString("name");
        int age =   json.getInt("age");
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("————————————————————————————————");

        /*
         * 属性大括号包括，先获取JSONObject对象
         */
        JSONObject   hero = json.getJSONObject("Hero");
        String   hero_name = hero.getString("name");
        String   hero_position = hero.getString("Position");
        String   hero_charactor = hero.getString("charactor");

        System.out.println("擅长英雄：");
        System.out.println("英雄名："+hero_name);
        System.out.println("位置："+hero_position);
        System.out.println("英雄定位："+hero_charactor);
        System.out.println("————————————————————————————————");

        /*
         * 属性被中括号包括，获取JSONArray对象,遍历即可
         */
        System.out.println("外号：");
        JSONArray   nickNames = json.getJSONArray("nickNames");
        for (Object   nickName : nickNames) {
            System.out.println(nickName);
        }
        System.out.println("————————————————————————————————");

        /*
         * 属性中既有中括号包括，又嵌套了大括号，一层层获取即可
         */
        JSONArray   Honors = json.getJSONArray("Honors");
        System.out.println("所获荣誉：");
        for(int   i=0;i<Honors.length();i++){
            JSONObject honor = Honors.getJSONObject(i);
            int   honor_year = honor.getInt("year");
            String   honor_name = honor.getString("name");
            System.out.println(honor_year+"   : "+ honor_name);
        }

    }catch(Exception e){
       System.out.println(e.getMessage());

  }       

}

武汉小喽啰

发布了143 篇原创文章 · 获赞 7 · 访问量 4444

私信关注

Java中常用的JSON解析