几种常用的JSON解析工具的使用

亦凉 2022-05-13 02:24 205阅读 0赞

**目录**

简介：

（1）org.json的使用

（2）net.sf.json的使用

（3）json-simple的使用

（4）gson的使用

（5）jackson的使用

（6）fastjson的使用

--------------------

## 简介： ##

现在越来越多的网站采用JSON来交换数据，在Json.org网站上，Java可以使用的解析Json的组件就有超过20种。

Json官网：[http://json.org/][http_json.org]

页面往下拉，可以看到java板块的json类库：

![70][]

其中gson，jackson，fastjson都是我们常用的工具类，每种工具用起来可能稍稍有点差别，但都是大同小异，基本上都包含两大块JSONObject和JSONArray

JSONObject：普通json对象

JSONArray：json数组

这里只简单测试一下JSON的基本生成与解析，复杂的类型与之同理，这里不过多介绍。

## **（1）org.json的使用** ##

（实测最好将该jar包下载下来，然后手动导入工程）

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

import org.json.JSONArray;
    import org.json.JSONObject;
    import org.junit.Test;
    
    /**
     * java原生json处理
     */
    public class OrgJsonTest {
    
        /**
         * JSON的初始化
         */
        @Test
        public void test1() {
           JSONObject jsonObject = new JSONObject();
           jsonObject.put("name", "zhangsan");
           jsonObject.put("age", 20);
           jsonObject.put("married", false);
    
           System.out.println(jsonObject);
           // {"name":"zhangsan","married":false,"age":20}
    
           JSONArray jsonArray = new JSONArray();
           jsonArray.put(0, true);
           jsonArray.put(1, "lisi");
           jsonArray.put(2, 22);
    
           System.out.println(jsonArray);
           // [true,"lisi",22]
        }
    
        /**
         * JSON的解析
         */
        @Test
        public void test2() {
           // 初始化
           JSONObject jsonObject = new JSONObject("{\"name\":\"zhangsan\",\"married\":false,\"age\":20}");
           String name = jsonObject.getString("name");
           int age = jsonObject.getInt("age");
           boolean married = jsonObject.getBoolean("married");
    
           System.out.println("name=" + name + "\nage=" + age + "\nmarried=" + married);
           // name=zhangsan
           // age=20
           // married=false
           
           JSONArray jsonArray = new JSONArray("[true,\"lisi\",22]");
           boolean arr1 = jsonArray.getBoolean(0);
           String arr2 = jsonArray.getString(1);
           int arr3 = jsonArray.getInt(2);
    
           System.out.println(arr1 + "\t" + arr2 + "\t" + arr3);
        }
    
        /**
         * JSONObject和JSONArray的相互嵌套
         */
        @Test
        public void test3() {
           // 初始化
           JSONObject jsonObject = new JSONObject("{\"name\":\"zhangsan\",\"married\":false,\"age\":20}");
           JSONObject address = new JSONObject("{\"address\":\"China\"}");
           JSONArray education = new JSONArray("[\"小学\",\"初中\",\"高中\"]");
    
           jsonObject.put("addr", address);
           jsonObject.put("edu", education);
    
           System.out.println(jsonObject);
           // {"edu":["小学","初中","高中"],"name":"zhangsan","addr":{"address":"China"},"married":false,"age":20}
    
        }
    }

## **（2）net.sf.json的使用** ##

<dependency>
        <groupId>net.sf.json-lib</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.4</version>
    </dependency>
    
    <dependency>
        <groupId>net.sf.ezmorph</groupId>
        <artifactId>ezmorph</artifactId>
        <version>1.0.6</version>
    </dependency>

import org.junit.Test;
    
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    
    public class NetsfJSON {
        
        /**
         * 创建JSON
         */
        @Test
        public void test1() {
    
          String str = "{\"name\":\"zhangsan\",\"age\":20}";
          JSONObject json1 = JSONObject.fromObject(str);
    
          System.out.println(json1.toString());
          // {"name":"zhangsan","age":20}
          
          JSONObject json2 = new JSONObject();
          json2.put("name", "zhangsan");
          json2.put("age", 20);
          json2.element("telphone", "15000000000");
    
          System.out.println(json2);
          // {"name":"zhangsan","age":20,"telphone":"15000000000"}
       }
    
        /**
         * 解析JSON
         */
        @Test
        public void test2() {
    
          String str = "{\"name\":\"zhangsan\",\"age\":20}";
          JSONObject json = JSONObject.fromObject(str);
    
          String name = json.getString("name");
          int age = json.getInt("age");
    
          System.out.println("name = " + name + ", age = " + age);
          // name = zhangsan, age = 20
       }
    
        /**
         * JSONArray
         */
        @Test
        public void test3() {
          // JSONObject内嵌JSONArray
          JSONObject json = new JSONObject();
          json.put("name", "zhangsan");
          json.put("age", 20);
    
          JSONObject json3 = new JSONObject();
          json3.put("math", 90);
          json3.put("english", 88);
    
          JSONArray array = new JSONArray();
          array.add(json3);
    
          json.put("class", array);
          System.out.println(json);
          // {"name":"zhangsan","age":20,"class":[{"math":90,"english":88}]}
    
          JSONArray jsonArray = json.getJSONArray("class");
          System.out.println(jsonArray.toString());
          // [{"math":90,"english":88}]
    	  
          // 创建JSONArray
          JSONArray jsonArray2 = new JSONArray();
          jsonArray2.add(0, "zhangsan");
          jsonArray2.add(1, "lisi");
          jsonArray2.element(2, "wangwu");
          System.out.println(jsonArray2);
          // ["zhangsan", "lisi", "wangwu"]
    
          // 解析
          Object object = jsonArray2.get(0);
          System.out.println(object);
          // zhangsan
       }
    }

## **（3）json-simple的使用** ##

<dependency>
        <groupId>com.googlecode.json-simple</groupId>
        <artifactId>json-simple</artifactId>
        <version>1.1.1</version>
    </dependency>

import org.json.simple.JSONArray;
    import org.json.simple.JSONObject;
    import org.json.simple.parser.JSONParser;
    import org.json.simple.parser.ParseException;
    import org.junit.Test;
    
    public class JSONSimple {
    
    	@Test
    	public void test1() throws ParseException {
    		// 创建
    		JSONObject obj = new JSONObject();
    		obj.put("name", "zhangsan");
    		obj.put("age", 20);
    		obj.put("tel", "15000000000");
    		System.out.println(obj);
    		
    		// 解析
    		JSONParser parser = new JSONParser();
    		JSONObject json = (JSONObject) parser.parse(obj.toString());
    		System.out.println(json);
    		
    		Object name = json.get("name");
    		Object age = json.get("age");
    		System.out.println("name = " + name + ", age = " + age);
    	}
    }

## **（4）gson的使用** ##

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

public class Person {
    
        private String name;
    
        private int age;
    }
    -----------------------------------------------------------------------------
    
    import org.junit.Test;
    import com.google.gson.Gson;
    
    public class GSONTest {
    
        @Test
        public void test() {
    
           Gson gson = new Gson();
    
           Person person = new Person();
           person.setName("zhangsan");
           person.setAge(20);
    
           String json = gson.toJson(person);
           System.out.println(json);
           // {"name":"zhangsan","age":20}
    
           Person fromJson = gson.fromJson(json, Person.class);
           System.out.println(fromJson);
           // Person [name=zhangsan, age=20]
        }
    }

## **（5）jackson的使用** ##

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

import com.fasterxml.jackson.databind.ObjectMapper;
    import com.zzs.json.bean.Person;
    
    public class JacksonTest {
    
        @Test
        public void test1() throws IOException {
    
           Person person = new Person();
           person.setName("zhangsan");
           person.setAge(20);
    
           /**
            * ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现。
            * ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。
            * writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。
            * writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。
            * writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。
            * writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。
            */
           ObjectMapper mapper = new ObjectMapper();
           // User类转JSON
           String json = mapper.writeValueAsString(person);
           // 输出结果：{"name":"zhangsan","age":20}
           System.out.println(json);
    
           // JSON解析
           Person readValue = mapper.readValue(json, Person.class);
           // 输出结果：Person [name=zhangsan, age=20]
           System.out.println(readValue);
        }
    }

## **（6）fastjson的使用** ##

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

方法入口：

public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray
    public static final JSONObject parseObject(String text); // 把JSON文本parse成JSONObject   
    public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean
    public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
    public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合
    public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本
    public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本
    public static final Object toJSON(Object javaObject); // 将JavaBean转换为JSONObject或者JSONArray。

import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    
    public class FastjsonTest {
    
        /**
         * 创建JSON
         */
        @Test
        public void test1() {
           // 创建一个 Person 对象
           Person person = new Person();
           person.setName("zhangsan");
           person.setAge(20);
    
           // 将 Person 对象转为 json 字符串
           String json = JSON.toJSONString(person);
           // 输出结果：{"age":20,"name":"zhangsan"}
           System.out.println(json);
    
           // 将 Person 对象转为 json 字符串, 这个字符串是经过格式化的
           String format_json = JSON.toJSONString(person, true);
           System.out.println(format_json);
        }
    
        @Test
        public void test2() {
           String json_array = "[{\"age\":20,\"name\":\"zhangsan\"},{\"age\":22,\"name\":\"lisi\"}]";
    
           // 将 json 字符串转为 JSONArray 对象
           JSONArray array = JSON.parseArray(json_array);
           System.out.println(array);
    
           // 将 json 字符串转为 List 集合
           List<Person> list = JSON.parseArray(json_array, Person.class);
           for (Person person : list) {
               System.out.println(person);
           }
        }
    
        /**
         * JSON解析
         */
        @Test
        public void test3() {
           String json = "{\"age\":20,\"name\":\"zhangsan\"}";
    
           // 将 json 字符串转为 JSONObject 对象
           JSONObject object = JSON.parseObject(json);
           System.out.println(object);
    
           // 将 json 字符串转为 Student 对象
           Person person = JSON.parseObject(json, Person.class);
           System.out.println(person);
        }
    }

[http_json.org]: http://json.org/
[70]: /images/20220513/601521aff94c43ebaf2da91aa5c16198.png

发表评论取消回复

表情：

评论列表（有 0 条评论，205人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java中常用的几种JSON格式的转换

JSON在传输数据时，起到了特别大的作用，因此出现了各种各样五花八门的JSON转换第三方包，在这里做一个汇总，总结一些常用的目录 com.alibaba.fastjson

た入场券/ 2023年09月30日 21:11/ 0 赞/ 5 阅读

相关几种常用的数据库端口

1433　　sqlserver 1521　　oracle 1527　　Derby 3306　　mysql 5432　　pgsql 5000　　db2 909

野性酷女/ 2023年08月17日 17:32/ 0 赞/ 123 阅读

相关 Java常用的几种属性拷贝工具类使用总结

> 怕什么真理无穷，进一步有近一步的欢喜文章目录开头聊几句 Java属性拷贝工具类使用总结字段和属性使用说明

小咪咪/ 2022年12月03日 09:15/ 0 赞/ 258 阅读

相关几种常用的算法简介

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][] 1、穷举法穷举法是最基本的算法设计策略，其思想是

系统管理员/ 2022年10月02日 04:48/ 0 赞/ 195 阅读

相关 ajax常用的几种写法

1、 $.ajax({ url:"servlet", type:"post",//get

ゝ一纸荒年。/ 2022年10月01日 00:59/ 0 赞/ 318 阅读

相关 c# 解析JSON的几种办法

欲成为海洋大师，必知晓海中每一滴水的真名。刚开始只是想找一个转换JSON数组的方法，结果在MSDN翻到一大把。搜索过程中免不了碰到一大堆名词：WCF => Dat

朴灿烈づ我的快乐病毒、/ 2022年08月26日 01:19/ 0 赞/ 132 阅读

相关常用的json解析方式

public static Person getPerson(String key,String jsonString){ Person per

阳光穿透心脏的1/2处/ 2022年08月20日 04:16/ 0 赞/ 218 阅读

相关解析Json数据的几种方法

<table> <tbody> <tr> <td><font>Json解析</font></td> </tr> </tbody> </table>

墨蓝/ 2022年06月02日 06:47/ 0 赞/ 297 阅读

相关几种常用的JSON解析工具的使用

目录简介：（1）org.json的使用（2）net.sf.json的使用（3）json-simple的使用（4）gson的使用（5）jackson的使用

亦凉/ 2022年05月13日 02:24/ 0 赞/ 206 阅读

相关几种常用的 MySQL 图形化管理工具

点击上方 [Java后端][Java]，选择设为星标优质文章，及时送达 ![format_png][] 作者 | 陈万洲的专栏来源 | blog.csdn.net

系统管理员/ 2021年08月20日 00:14/ 0 赞/ 549 阅读