JSON字符串和java对象的互转

 

在开发过程中，经常需要和别的系统交换数据，数据交换的格式有XML、JSON等，JSON作为一个轻量级的数据格式比xml效率要高，XML需要很多的标签，这无疑占据了网络流量，JSON在这方面则做的很好，下面先看下JSON的格式，

JSON可以有两种格式，一种是对象格式的，另一种是数组对象，

{"name":"JSON","address":"小明","age":25}//JSON的对象格式的字符串

[{"name":"JSON","address":"小明","age":25}]//数据对象格式

从上面的两种格式可以看出对象格式和数组对象格式唯一的不同则是在对象格式的基础上加上了[]，再来看具体的结构，可以看出都是以键值对的形式出现的，中间以英文状态下的逗号（,）分隔。

在前端和后端进行数据传输的时候这种格式也是很受欢迎的，后端返回json格式的字符串，前台使用js中的JSON.parse()方法把JSON字符串解析为json对象，然后进行遍历，供前端使用。

下面进入正题，介绍在JAVA中JSON和java对象之间的互转。

要想实现JSON和java对象之间的互转，需要借助第三方jar包，这里使用json-lib这个jar包，下载地址为：https://sourceforge.net/projects/json-lib/，json-lib需要commons-beanutils-1.8.0.jar、commons-collections-3.2.1.jar、commons-lang-2.5.jar、commons-logging-1.1.1.jar、ezmorph-1.0.6.jar五个包的支持，可以自行从网上下载，这里不再贴出下载地址。

json-lib提供了几个类可以完成此功能，例，JSONObject、JSONArray。从类的名字上可以看出JSONObject转化的应该是对象格式的，而JSONArray转化的则应该是数组对象（即，带[]形式）的。

一、java普通对象和json字符串的互转

  java对象--》》字符串

java普通对象指的是java中的一个java bean，即一个实体类，如，

package com.cn.study.day3;

public class Student {
    //姓名
    private String name;
    //年龄
    private String age;
    //住址
    private String address;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", address="
                + address + "]";
    }
    

}

上面是我的一个普通的java实体类，看json-lib如何把它转化为字符串形式，

public static void convertObject() {
        
        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("小明");

        //1、使用JSONObject net.sf.json.JSONObject
        JSONObject json = JSONObject.fromObject(stu);
        //2、使用JSONArray com.alibaba.fastjson.JSONObject
        JSONArray array=JSONArray.fromObject(stu);
        
        String strJson=json.toString();
        String strArray=array.toString();
        
        System.out.println("strJson:"+strJson);
        System.out.println("strArray:"+strArray);
    }

我定义了一个Student的实体类，然后分别使用了JSONObject和JSONArray两种方式转化为JSON字符串，下面看打印的结果，

strJson:{"address":"小明","age":"23","name":"JSON"}
strArray:[{"address":"小明","age":"23","name":"JSON"}]

 JSON字符串--》》java对象

上面说明了如何把java对象转化为JSON字符串，下面看如何把JSON字符串格式转化为java对象，

首先需要定义两种不同格式的字符串，需要使用\对双引号进行转义，

public static void jsonStrToJava(){
        //定义两种不同格式的字符串
        String objectStr="{\"name\":\"JSON\",\"age\":\"24\",\"address\":\"小明\"}";
        String arrayStr="[{\"name\":\"JSON\",\"age\":\"24\",\"address\":\"小明\"}]";
    
        //1、使用JSONObject
        JSONObject jsonObject=JSONObject.fromObject(objectStr);
        Student stu=(Student)JSONObject.toBean(jsonObject, Student.class);
        
        //2、使用JSONArray
        JSONArray jsonArray=JSONArray.fromObject(arrayStr);
        //获得jsonArray的第一个元素
        Object o=jsonArray.get(0);
        JSONObject jsonObject2=JSONObject.fromObject(o);
        Student stu2=(Student)JSONObject.toBean(jsonObject2, Student.class);
        System.out.println("stu:"+stu);
        System.out.println("stu2:"+stu2);
        
    }

打印结果为：

stu:Student [name=JSON, age=24, address=小明]
stu2:Student [name=JSON, age=24, address=小明]

从上面的代码中可以看出，使用JSONObject可以轻松的把JSON格式的字符串转化为java对象，但是使用JSONArray就没那么容易了，因为它有“[]”符号，所以我们这里在获得了JSONArray的对象之后，取其第一个元素即我们需要的一个student的变形，然后使用JSONObject轻松获得。

二、list和json字符串的互转

list--》》json字符串

public static void listToJSON(){
        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("北京");
        List<Student> lists=new ArrayList<Student>();
        lists.add(stu);
        //1、使用JSONObject
        //JSONObject listObject=JSONObject.fromObject(lists);
        //2、使用JSONArray
        JSONArray listArray=JSONArray.fromObject(lists);
        
        //System.out.println("listObject:"+listObject.toString());
        System.out.println("listArray:"+listArray.toString());
        
    }

我把使用JSONObject的方式给注掉了，我们先看注释之前的结果，

Exception in thread "main" net.sf.json.JSONException: 'object' is an array. Use JSONArray instead

告诉我说有一个异常，通过查看源码发现，在使用fromObject方法的时候会先进行参数类型的判断，这里就告诉我们，传入的参数是一个array类型，因为使用的ArrayList，再来看，注释之后的结果，

listArray:[{"address":"北京","age":"23","name":"JSON"}]

这样结果是正常的。
json字符串--》》list

从上面的例子可以看出list的对象只能转化为数组对象的格式，那么我们看下面的字符串到list的转化，

public static void jsonToList(){
        String arrayStr="[{\"name\":\"JSON\",\"age\":\"24\",\"address\":\"北京\"}]";
        //转化为list
                List<Student> list2=(List<Student>)JSONArray.toList(JSONArray.fromObject(arrayStr), Student.class);
                
                for (Student stu : list2) {
                    System.out.println(stu);
                }
                //转化为数组
                Student[] ss =(Student[])JSONArray.toArray(JSONArray.fromObject(arrayStr),Student.class);
                for (Student student : ss) {
                    System.out.println(student);
                }
        
        
    }

打印结果，

Student [name=JSON, age=24, address=北京]
Student [name=JSON, age=24, address=北京]

由于字符串的格式为带有“[]”的格式，所以这里选择JSONArray这个对象，它有toArray、toList方法可供使用，前者转化为java中的数组，或者转化为java中的list，由于这里有实体类进行对应，所以在使用时指定了泛型的类型（Student.class），这样就可以得到转化后的对象。

三、map和json字符串的互转

map--》》json字符串

public static void mapToJSON(){
        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("中国");
        Map<String,Student> map=new HashMap<String,Student>();
        map.put("first", stu);
        
        //1、JSONObject
        JSONObject mapObject=JSONObject.fromObject(map);
        System.out.println("mapObject"+mapObject.toString());
        
        //2、JSONArray
        JSONArray mapArray=JSONArray.fromObject(map);
        System.out.println("mapArray:"+mapArray.toString());
    }

打印结果，

mapObject{"first":{"address":"中国","age":"23","name":"JSON"}}
mapArray:[{"first":{"address":"中国","age":"23","name":"JSON"}}]

上面打印了两种形式。

json字符串--》》map

JSON字符串不能直接转化为map对象，要想取得map中的键对应的值需要别的方式，

public static void jsonToMap(){
        String strObject="{\"first\":{\"address\":\"中国\",\"age\":\"23\",\"name\":\"JSON\"}}";
        
        //JSONObject
        JSONObject jsonObject=JSONObject.fromObject(strObject);
        Map map=new HashMap();
        map.put("first", Student.class);

        //使用了toBean方法，需要三个参数 
        MyBean my=(MyBean)JSONObject.toBean(jsonObject, MyBean.class, map);
        System.out.println(my.getFirst());
        
    }

打印结果，

Student [name=JSON, age=23, address=中国]

下面是MyBean的代码，

package com.cn.study.day4;

import java.util.Map;

import com.cn.study.day3.Student;

public class MyBean {
    
    private Student first;

    public Student getFirst() {
        return first;
    }

    public void setFirst(Student first) {
        this.first = first;
    }

    

}

使用toBean()方法是传入了三个参数，第一个是JSONObject对象，第二个是MyBean.class，第三个是一个Map对象。通过MyBean可以知道此类中要有一个first的属性，且其类型为Student，要和map中的键和值类型对应，即，first对应键 first类型对应值的类型。

 

上面主要集中在了使用json-lib来实现JSON字符串和java中的对象的互转上，忽视了json-lib本身的功能，json-lib中有两个类比较重要：JSONObject和JSONArray，这两个类因其名称不同，所实现的功能也不尽相同，JSONObject处理的是对象格式的（{}），JSONArray处理的是数组格式的（[]），下面看具体的使用方法。

JSONObject

一、源码

JSONObject类中有多个重载的element()，此方法是向JSONObject类中存储数据的方法，通过查看源代码，发现JSONObject是通过Map实现数据存储的，看下面的源码，

 private Map properties;

   /**
    * Construct an empty JSONObject.
    */
   public JSONObject() {
      this.properties = new ListOrderedMap();
   }

在JSONObject中有Map属性，此属性是一个ListOrderMap的对象，element()方法则是向properties中添加数据，因为properties是map，则可以使用操作Map的方法操作properties属性，JSONObject对properties的操作方式进行了包装；从源码中可以发现还有好多重载的get()方法，如，

 public Object get( String key ) {
      verifyIsNull();
      return this.properties.get( key );
   }

从get方法中可以看出使用的便是Map的get方法。

经过以上的源码分析，可以知道对JSONObject的操作即是对Map的操作。

使用

public static void TestJSONObject(){
        //创建一个JSONObject对象
        JSONObject jsonObject=new JSONObject();
        
        jsonObject.element("my", "this is my first");
        String str=jsonObject.toString();
        String keyValue=jsonObject.getString("my");
        System.out.println("str:"+str);
        System.out.println("keyValue:"+keyValue);
        
    }

打印结果

str:{"my":"this is my first"}
keyValue:this is my first

有了JSONObject实例之后，使用element()方法把键和键对应的值添加进去，打印出字符串可以看出是JSON对象的格式，可以看出这种形式和把一个类转化为JSON格式的字符串是一致的，可以把“my”当做是类的属性，“this is my first”是属性的值。
有了这样的理解之后，可以把一个JSON字符串转化为一个JSONObjec对象，然后取得对象中的值，如下，

public static void getValue(){
        String str="{\"my\":\"this is my first\",\"second\":\"this is second!\"}";
        JSONObject jsonObject=JSONObject.fromObject(str);
        String my=jsonObject.getString("my");
        String second=jsonObject.getString("second");
        System.out.println("my:"+my);
        System.out.println("secode:"+second);
        
    }

打印结果

my:this is my first
secode:this is second!

可以看出我们完全可以不把JSON字符串转化为相应的类，同样可以获得想要的值，如果要转化为相应的类，必须要有如下的类，

package com.cn.study.day3;

public class TestAndMy {
    private String my;
    private String second;
    public String getMy() {
        return my;
    }
    public void setMy(String my) {
        this.my = my;
    }
    public String getSecond() {
        return second;
    }
    public void setSecond(String second) {
        this.second = second;
    }
    

}

生成类的代码如下，

public static void getValue(){
        String str="{\"my\":\"this is my first\",\"second\":\"this is second!\"}";
        JSONObject jsonObject=JSONObject.fromObject(str);
        String my=jsonObject.getString("my");
        String second=jsonObject.getString("second");
        System.out.println("my:"+my);
        System.out.println("secode:"+second);
        System.out.println("-------------------------------");
        //生成类
        TestAndMy test=(TestAndMy)jsonObject.toBean(jsonObject, TestAndMy.class);
        System.out.println("my:"+test.getMy()+",second:"+test.getSecond());
        
    }

在有些情况下，可能不是这种简单的字符串，而是比较复杂的，我们应该如何取得想要的值呢，看下面的例子，

public static void complex(){
        String str="{\"data\":{\"my\":\"this is my first\",\"second\":\"this is second!\"}}";
        
        JSONObject jsonObject=JSONObject.fromObject(str);
        JSONObject dataObject=jsonObject.getJSONObject("data");
        System.out.println("dd:"+dataObject.toString());
    }

打印结果 

dd:{"my":"this is my first","second":"this is second!"}

在上边的例子中不再是一个JSON对象，而是data对应一个JSON对象，在获得了JSONObject实例之后，我们知道一个JSONObject实例，其底层存储是Map的，那么使用get方法可以获得其键对应的值，可以使用get(String key)方法，此方法返回一个Object对象，返回Object对象之后就不好处理了，此种方法行不通，可以使用getString(String key)，此方法是返回key对应的值的字符串形式，那么针对上边的例子，我们返回的应该是{"my":"this is my first","second":"this is second!"}，还是达不到最终解析的目的。最终发现使用getJSONObject(String key)方法可以，返回的是JSONObject的对象，那么我们可以接着使用此对象进行完全解析。

JSONArray

一、源码

查看JSONArray的源码，可以发现JSONArray的底层是List实现的，即使用JSONArray对象存储数据是放在List中的，

/**
    * The List where the JSONArray's properties are kept.
    */
   private List elements;
/**    * Construct an empty JSONArray.    */  
 public JSONArray() {      this.elements = new ArrayList();   }

JSONArray中所有的值都是放在elements中的，elements又是ArrayList的一个实例。ArrayList底层是通过数组实现的。那么对于JSONArray的操作就是基于数组的。
JSONArray提供了重载的element()方法，用来新增数据，提供了重载的get()方法来取出数据

二、使用

下面是一个使用JSONArray的例子，

public static void testJSONArray(){
        String array="[\"123\",\"this is my test\",{\"address\":\"北京\",\"age\":\"23\",\"name\":\"JSON\"}]";
        JSONArray jsonArray=JSONArray.fromObject(array);
        //由于JSONArray底层是数组，所以这里使用下标的方式来访问其中的元素
        String str1=jsonArray.getString(0);
        String str2=jsonArray.getString(1);
        String str3=jsonArray.getString(2);
        System.out.println("str1:"+str1+",str2:"+str2+",str3:"+str3);
        //由于第三个元素本身是一个对象形式的JSON串，可以这样获得第三个元素
        JSONObject o3=jsonArray.getJSONObject(2);//获得JSONObject对象
        System.out.println("address:"+o3.getString("address")+",age:"+o3.getString("age"));
        
    }

打印结果

str1:123,str2:this is my test,str3:{"address":"北京","age":"23","name":"JSON"}
address:北京,age:23

由于JOSNArray是由ArrayList实现的，所有这里是使用getString()方法，可以获得每个索引处的字符串，但是无法做到完全解析此字符串的目的，所以可以使用getJSONObject()方法获得第三个位置的对象，然后解析此对象。

从上边的叙述中可以JSONArray、JOSNObject两个类都可以存储数据，只是使用的方式不同，正是这种不同造成了解析方式不同。