1、Json串与对象之间的转换

JSON JavaScript Object Notation

JavaScript对象简谱

JSON字符串和java对象的互转【json-lib】

JavaScript Object

在开发过程中，经常需要和别的系统交换数据，数据交换的格式有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转化的则应该是数组对象（即，带[]形式）的。

（1）、java普通对象和json字符串的互转

java对象–》》字符串

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

package test.edu.xalead;

public class Student {
    private int no;
    private int age;
    private String name;
    private Address address;

    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", age=" + age +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }

    public Student(){}
    public Student(int no, int age, String name, Address address) {
        this.no = no;
        this.age = age;
        this.name = name;
        this.address = address;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}

如果是复杂的对象（对象中还包含其它对象的引用），如果学生类还有地址类

package test.edu.xalead;

public class Address {
    private String homeAddr;
    private String collegeAdder;

    @Override
    public String toString() {
        return "Address{" +
                "homeAddr='" + homeAddr + '\'' +
                ", collegeAdder='" + collegeAdder + '\'' +
                '}';
    }

    public String getHomeAddr() {
        return homeAddr;
    }

    public void setHomeAddr(String homeAddr) {
        this.homeAddr = homeAddr;
    }

    public String getCollegeAdder() {
        return collegeAdder;
    }

    public void setCollegeAdder(String collegeAdder) {
        this.collegeAdder = collegeAdder;
    }
}

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

@Test
    public void test1() {
        Student s = new Student();
        s.setNo(2435);
        s.setAge(23);
        s.setName("hah");


        Address adr = new Address();
        adr.setCollegeAdder("未央");
        adr.setHomeAddr("金华");
        s.setAddress(adr);

        // 使用jsonObject
        JSONObject ob = JSONObject.fromObject(s);
        // 使用jsonArray
        JSONArray jsonArray = JSONArray.fromObject(s);

        System.out.println(ob.toString());
        System.out.println("jasonArray:" + jsonArray);

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

{"address":{"collegeAdder":"未央","homeAddr":"金华"},"age":23,"name":"hah","no":2435}
jasonArray:[{"address":{"collegeAdder":"未央","homeAddr":"金华"},"age":23,"name":"hah","no":2435}]

从结果中可以看出两种方法都可以把java对象转化为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串转化为java对象的内容，在下篇中会继续说明。

互联网上数据的一种传输标准

`{"firstName": "Json"}`
 {a:'hello',b:'world'}
["zhangsan","lisi","wangmazi"]
[
    {"name":"zhangsan","age":20,"adr":{"busiadr":"xian","home":"beijing"}},
    {"name":"lisi","age":20,"adr":{"busiadr":"xian","home":"beijing"}},
    {"name":"wangmazi","age":20,"adr":{"busiadr":"xian","home":"beijing"}},
]

（2）.对象转JSON

1.1 布署json-lib 的jar包

1.2创建测试类

首先测试从对象到json字符串转换

1.2.1创建一个实体对象

package test.edu.xalead;

public class Student {
    private int no;
    private String name;
    private int age;
	@Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

JSONObject.fromObject(s)方法既可以把对象转换成中间(json)对象，也可以把json字符串转换成对象）

/**
     * 测试从对象到JSON字符串
     */
    @Test
    public void test1(){
        //创建学生对象
        Student s = new Student();
        s.setNo(2222);
        s.setName("张三");
        s.setAge(20);

        //转换成Json串
        JSONObject ob = JSONObject.fromObject(s);//把对象转换成中间JSONObject对象
        System.out.println(ob.toString());//调用中间对象（JSONObject对象）的toString()得到json字符串
    }

输出结果

{"no":2222,"name":"张三","age":20}

如果是复杂的对象（对象中还包含其它对象的引用），如果学生类还有地址类

package test.edu.xalead;

public class Address {
    private String homeAddr;
    private String collegeAddr;

    public String toString() {
        return "Address{" +
                "homeAddr='" + homeAddr + '\'' +
                ", collegeAddr='" + collegeAddr + '\'' +
                '}';
    }
    public String getHomeAddr() {
        return homeAddr;
    }

    public void setHomeAddr(String homeAddr) {
        this.homeAddr = homeAddr;
    }

    public String getCollegeAddr() {
        return collegeAddr;
    }

    public void setCollegeAddr(String collegeAddr) {
        this.collegeAddr = collegeAddr;
    }
}

学生类添加地址的引用
package test.edu.xalead;

public class Student {
    private int no;
    private String name;
    private int age;
    private Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1.2.2测试类

@Test
    public void test1(){
        //创建学生对象
        Student s = new Student();
        s.setNo(2222);
        s.setName("张三");
        s.setAge(20);

        Address adr = new Address();
        adr.setCollegeAddr("未央区");
        adr.setHomeAddr("大雁塔");
        s.setAddress(adr);

        //转换成Json串
        JSONObject ob = JSONObject.fromObject(s);
        System.out.println(ob.toString());
    }

输出结果

{"no":2222,"address":{"collegeAddr":"未央区","homeAddr":"大雁塔"},"name":"张三","age":20}

2.JSON转对象

 /**
     * 把json串转换成对象
     */
    @Test
    public void test2(){
        String jsonStr = "{\"no\":2222,\"address\":{\"collegeAddr\":\"未央区\",\"homeAddr\":\"大雁塔\"},\"name\":\"张三\",\"age\":20}";
        JSONObject object = JSONObject.fromObject(jsonStr);//把上面的json字符串转换成中间对象
        Student o = (Student)JSONObject.toBean(object, Student.class);//toBean()方法把中间对象转换成对象
        System.out.println(o);
    }

• 注意：JSONObject object = JSONObject.fromObject(jsonStr)有两个参数，一个是中间对象，一个是我们要转换成的类型的反射类（描述类型信息的类），要注意的是我们要把json转换成的类一定要具备默认构造函数hetoString()方法，否则转换会报出异常。