fastjson-1.2.21 使用实例，复杂嵌套Java对象转json对象，复杂嵌套json对象转对应Java对象的代码实现

理论我就不多废话了，直接看代码吧。使用的是fastjson-1.2.21版本的来实现下面代码的。

主要是实现复杂的嵌套的Java对象，也就是对象嵌套对象的复杂对象，转换成json字符串。然后就是反过来，把复杂的json字符串转换成对应的嵌套的Java对象。

先上工具类。如下。

package com.lxk.json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

/**
 * JSON 转换
 */
public final class JsonUtils {

    /**
     * 把Java对象转换成json字符串
     *
     * @param object 待转化为JSON字符串的Java对象
     * @return json 串 or null
     */
    public static String parseObjToJson(Object object) {
        String string = null;
        try {
            //string = JSON.toJSONString(object);
            string = JSONObject.toJSONString(object);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return string;
    }

    /**
     * 将Json字符串信息转换成对应的Java对象
     *
     * @param json json字符串对象
     * @param c    对应的类型
     */
    public static <T> T parseJsonToObj(String json,Class<T> c) {
        try {
            //两个都是可行的，起码我测试的时候是没问题的。
            //JSONObject jsonObject = JSONObject.parseObject(json);
            JSONObject jsonObject = JSON.parseObject(json);
            return JSON.toJavaObject(jsonObject,c);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return null;
    }
}

从代码中引入的包来看，真就是简单的只是引用了com.alibaba.fastjson这个包里面的2个类。所以，使用这个包，就很简单，不耦合其他工具包。

上面对象转json字符串的方法还可以如下修改下。

    /**
     * 把Java对象转换成json字符串
     *
     * @param object 待转化为JSON字符串的Java对象
     * @return json 串 or null
     */
    public static <T> String parseObjToJson(T object) {
        String string = null;
        try {
            //string = JSON.toJSONString(object);
            string = JSONObject.toJSONString(object);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return string;
    }

把穿进去的Object类给换成泛型，显得高级点点。这样的话，2个方法都是使用的泛型啦。可以让你写代码的水平，稍微闷骚一下。这只是泛型的简单用法。所以说只是稍微。

关于泛型，不懂的可以看下面的链接：包教包不会。

Java泛型详解：和Class的使用。泛型类，泛型方法的详细使用实例
 Java泛型：中的？和 extends 的理解和使用实例

pom.xml中引入如下配置。

        <!-- json转换很是方便的工具jar -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.21</version>
        </dependency>

非maven项目，也可以去找这个jar包：fastjson-1.2.21.jar

我给放到云盘上，这里分享下：链接：http://pan.baidu.com/s/1dE1CLc1 密码：xg2c 有需要的可以直接下载使用，省的麻烦。嫌弃版本旧的也可自己找最新的。

下面是测试类。

package com.lxk.json;

import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.Dog;
import com.lxk.model.Student;

import java.util.List;

/**
 * 测试json和Java对象之间的转换
 * <p>
 * Created by lxk on 2017/6/15
 */
public class TestJsonMain {
    public static void main(String[] args) {
        Student student = getStudent();
        String studentJson = JsonUtils.parseObjToJson(student);
        System.out.println(studentJson);
        Student studentFromJson = JsonUtils.parseJsonToObj(studentJson,Student.class);
        System.out.println(studentFromJson);
    }

    private static Student getStudent() {
        Dog dog1 = new Dog("大师兄的dog",true,true);
        Dog dog2 = new Dog("大师兄的dog",false,false);
        List<Dog> dogs = Lists.newArrayList();
        dogs.add(dog1);
        dogs.add(dog2);
        List<String> boys = Lists.newArrayList("tom","jerry","jack");
        Car car = new Car("q7",182,dogs,boys);
        Student student = new Student();
        student.setName("Lxk");
        student.setCar(car);
        return student;
    }
}

然后就是看代码的运行结果。

这个乍一看，看不出来什么，我把我用到的几个Java bean也给放这吧，看官，别嫌弃文章太长。已经删掉getter和setter了

先是主体类Student类

package com.lxk.model;

/**
 * Created by lxk on 2017/3/23
 */
public class Student implements Cloneable {
    private String name;
    private Car car;

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

    @Override
    public Student clone() {
        Student student = null;
        try {
            student = (Student) super.clone();
            if (car != null) {
                student.setCar(car.clone());
            }
        } catch (CloneNotSupportedException ignored) {
            System.out.println(ignored.getMessage());
        }
        return student;
    }
}

这个是我原来测试clone方法的使用（Java中的深浅克隆）的时候，使用的类，现在顺道带过来测试这个，也是可以的。

只要你暂时没用到过这个clone方法，估计你也是不会去研究这个深浅克隆的，我还是附上链接吧。看链接：

java之实现Cloneable接口的详解，克隆一个对象--对应有浅克隆和深克隆，概念结合代码深入理解

然后就是学生的属性Car类。

package com.lxk.model;

import com.google.common.collect.Lists;

import java.util.List;

public class Car implements Cloneable,Comparable<Car> {
    private String sign;
    private int price;
    private List<Dog> myDog;
    private List<String> boys;

    public Car() {
    }

    public Car(String sign,int price) {
        this.sign = sign;
        this.price = price;
    }

    public Car(String sign,int price,List<Dog> myDog) {
        this.sign = sign;
        this.price = price;
        this.myDog = myDog;
    }

    public Car(String sign,List<Dog> myDog,List<String> boys) {
        this.sign = sign;
        this.price = price;
        this.myDog = myDog;
        this.boys = boys;
    }

    @Override
    public int compareTo(Car o) {
        //同理也可以根据sign属性排序，就不举例啦。
        return this.getPrice() - o.getPrice();
    }

    @Override
    public String toString() {
        return "Car{" +
                "sign='" + sign + '\'' +
                ",price=" + price +
                ",myDog=" + myDog +
                ",boys=" + boys +
                '}';
    }

    @Override
    public Car clone() {
        Car car = null;
        try {
            car = (Car) super.clone();
            if (myDog != null) {
                car.setMyDog(Lists.newArrayList(myDog));
            }
            if (boys != null) {
                car.setBoys(Lists.newArrayList(boys));
            }
        } catch (CloneNotSupportedException ignored) {
            System.out.println(ignored.getMessage());
        }
        return car;
    }
}

这个也是，在测试clone，Java的深浅克隆用法的时候，使用的Javabean。顺道实现了comparable接口，好像是测试集合类排序的时候使用的吧。

下面就是Dog类。

package com.lxk.model;

import com.google.common.base.Objects;

/**
 * 测试boolean属性的getter和setter
 * <p>
 * Created by lxk on 2016/12/23
 */
public class Dog {
    private String name;
    private boolean isLoyal;//是忠诚的
    private boolean alive;//活蹦乱跳的

    public Dog() {
    }

    public Dog(boolean isLoyal,boolean alive) {
        this.isLoyal = isLoyal;
        this.alive = alive;
    }

    public Dog(String name,boolean isLoyal,boolean alive) {
        this.name = name;
        this.isLoyal = isLoyal;
        this.alive = alive;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Dog)) return false;
        Dog dog = (Dog) o;
        return Objects.equal(getName(),dog.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(getName());
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ",isLoyal=" + isLoyal +
                ",alive=" + alive +
                '}';
    }
}

这个的测试目的，在类注释上说了，主要是boolean类型的属性要是以is开头，可能自动生成getter，setter的时候，会产生一些bug。看链接：

POJO 类中的任何boolean布尔类型的变量，都不要加 is，否则部分框架解析会引起序列化错误

好了，到这里，就把使用的三个model类啰嗦完了。下面再看主代码运行结果吧。

先是把复杂嵌套Java对象转换成json字符串对象，对json对象稍加格式化，展示如下。

{
    "car": {
        "boys": [
            "tom","jack"
        ],"myDog": [
            {
                "alive": true,"loyal": true,"name": "大师兄的dog"
            },{
                "alive": false,"loyal": false,"name": "大师兄的dog"
            }
        ],"price": 182,"sign": "q7"
    },"name": "Lxk"
}

然后就是把这个 json字符串再转乘Java对象的运行结果。也格式化下，展示如下。

Student{
    name='Lxk',car=Car{
        sign='q7',price=182,myDog=[
            Dog{
                name='大师兄的dog',isLoyal=true,alive=true
            },Dog{
                name='大师兄的dog',isLoyal=false,alive=false
            }
        ],boys=[
            tom,jerry,jack
        ]
    }
}

还有关于这个Student类实例化的对象，调用toString（）方法，可以可以这么完美，你们不好奇么？为什么不是返回的一个Java内存地址，而是我们可以看的懂的一个类似json对象的字符串格式呢？这里面也是大有文章的，细心的小伙伴们，可以回头看下我的三个javabean，这三个Java model都是重写了toString（）方法的，所以，你在调用最上层的toString（）方法的时候，他会一次嵌套调用的。所以，才会这样，这个好像我当时测试什么的时候发现的，既然总结到这了，就多啰嗦两句吧，看官要是不信的话，大可以把这个代码贴出来，去掉某个复写的toString（）方法，再自己测试一下，就可以看到，我所言非虚啦。

关于使用中的问题。

在使用json字符串转Java对象的时候，可能会抛异常，我这遇到的是因为，我的Dog类，没有默认的构造函数，所以，就转换失败了，当添加了默认构造函数之后，就OK啦。看下图的异常截图。

可以看到，我这个默认的构造函数是刚刚添加的。

关于这个默认的构造函数，我们在实际开发的时候，还是一定要记的随时都给写上，不管自己用不用，都要加上，下面是我因为这个默认构造函数又出的bug。看链接：

ajax 报错 400 (Failed to load resource: the server responded with a status of 400 (Bad Request))

好了，到此算是啰嗦完了。

等下，还是再啰嗦一下，

这个fastjson是在github上开源的，看链接：

Github，这个网站听过没？没听过的话，作为程序员，可就渣渣啦。

fastjson-1.2.21 使用实例，复杂嵌套Java对象转json对象，复杂嵌套json对象转对应Java对象的代码实现

相关推荐