理论我就不多废话了，直接看代码吧。使用的是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, int price, 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",
"jerry",
"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，这个网站听过没？没听过的话，作为程序员，可就渣渣啦。
