pom.xml文件中加入依赖依赖：
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.15</version>
</dependency>

首先建立两个实体类，Student.Java 和 Teacher.java 

Student.java 和Teacher.java 的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public  class  Student {  
       
     private  int  id;  
     private  String name;  
     private  int  age;  
       
     /** 
      * 默认的构造方法必须不能省，不然不能解析 
      */  
       
     public  Student(){  
           
     }  
     public  Student( int  id,String name, int  age) {  
         this .id = id;  
         this .name = name;  
         this .age = age;  
     }  
   
     public  int  getId() {  
         return  id;  
     }  
   
     public  void  setId( int  id) {  
         this .id = id;  
     }  
   
     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;  
     }  
       
     @Override  
     public  String toString() {  
         return  "Student [id="  + id +  ", name="  + name +  ", age="  + age +  "]" ;  
     }  
       
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import  java.util.List;  
   
public  class  Teacher {  
       
     private  int  id;  
     private  String name;  
       
     private  List<Student> students;  
       
   
     /** 
      * 默认的构造方法必须不能省，不然不能解析 
      */  
     public  Teacher() {  
           
     }  
     public  Teacher( int  id,String name) {  
         this .id = id;  
         this .name = name;  
     }  
       
     public  int  getId() {  
         return  id;  
     }  
     public  void  setId( int  id) {  
         this .id = id;  
     }  
     public  String getName() {  
         return  name;  
     }  
     public  void  setName(String name) {  
         this .name = name;  
     }  
   
     public  List<Student> getStudents() {  
         return  students;  
     }  
     public  void  setStudents(List<Student> students) {  
         this .students = students;  
     }  
     @Override  
     public  String toString() {  
         return  "Teacher [id="  + id +  ", name="  + name +  ", mStudents="  
                 + students +  "]" ;  
     }  
       
       
}


上面 的代码比较简单，主要就几个属性，这里值得注意的是， 默认的构造函数一定要写，不然是无法解析的。（对于fastjson 严格按照JavaBean的规范来，有一点不对就无法解析，这里一定要切记，每一个实体类的属性的get , set 方法必须写，切方法第四个字母必须大写，最好使用Eclipse的source->genreal setters and getters 生成get,set 方法，切记，切记 ）。对于Gson 这里就没有这么多的要求了，但最好还是按照JavaBean来写，避免一些位置的错误。


首先看 fastjson 的解析


首先解析一个实体类为json 格式。

1
2
Student student =  new  Student( 0 ,  "Aaron" ,  24 );  
         System.out.println(JSON.toJSONString(student));


1
输出结果为：{ "age" : 24 , "id" : 0 , "name" : "Aaron" }


输出的json格式与我们的Student中定义的属性其实是不一致的，这个其实不影响我们生成以及后面的解析，因为他有严格的get和set方法定义。


更复杂一点的数据类型也可以很方便的使用JSON.toJsonString(Object o) 这个方法进行解析成json格式。

1
2
3
4
5
List<Student> students =  new  ArrayList<Student>();  
         for ( int  i= 0 ;i< 5 ;i++) {  
             Student stu =  new  Student(i,  "Student"  + i,  18  +i);   
             students.add(stu);  
         }

解析结果为：

1
[{ "age" : 18 , "id" : 0 , "name" : "Student0" },{ "age" : 19 , "id" : 1 , "name" : "Student1" },{ "age" : 20 , "id" : 2 , "name" : "Student2" },{ "age" : 21 , "id" : 3 , "name" : "Student3" },{ "age" : 22 , "id" : 4 , "name" : "Student4" }]

   我们来看看更复杂一点的结构。  我们将一个Teacher 列表来解析，一个Teacher对象中是包含Student 列表的这个也在我们常用的数据模型，下面看看代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
List<Teacher> teaList =  new  ArrayList<Teacher>();  
         long  time = System.currentTimeMillis();  
         for ( int  i= 0 ;i< 10 ;i++) {  
             Teacher teacher =  new  Teacher(i,  "Teacher "  + i);  
             List<Student> stus =  new  ArrayList<Student>();  
             for ( int  j =  0  ;j< 4 ;j++) {  
                 Student s =  new  Student(j,  "Student"  + j,  18  +j);   
                 stus.add(s);  
             }  
             teacher.setStudents(stus);  
             teaList.add(teacher);  
         }  
         String jsonTeach = JSON.toJSONString(teaList);  
         System.out.println( "fastjson = "  + jsonTeach);


结果为：

1
fastjson = [{ "id" : 0 , "name" : "Teacher 0" , "students" :[{ "age" : 18 , "id" : 0 , "name" : "Student0" },{ "age" : 19 , "id" : 1 , "name" : "Student1" }]},{ "id" : 1 , "name" : "Teacher 1" , "students" :[{ "age" : 18 , "id" : 0 , "name" : "Student0" },{ "age" : 19 , "id" : 1 , "name" : "Student1" }]},{ "id" : 2 , "name" : "Teacher 2" , "students" :[{ "age" : 18 , "id" : 0 , "name" : "Student0" },{ "age" : 19 , "id" : 1 , "name" : "Student1" }]},{ "id" : 3 , "name" : "Teacher 3" , "students" :[{ "age" : 18 , "id" : 0 , "name" : "Student0" },{ "age" : 19 , "id" : 1 , "name" : "Student1" }]}]

还是一个简单的函数而已，就能办到。 

这个还有toJSONString 重载的方法，有很多，在给一个就是可以按照标准的json 格式输出，上面的输出都不规范，我们来看看。

  

1
2
3
4
5
6
7
8
Student student =  new  Student( 0 ,  "Aaron" ,  24 );  
         System.out.println(JSON.toJSONString(student, true ));  
输出为：  
{  
"age" : 24 ,  
"id" : 0 ,  
"name" : "Aaron"  
}


如果我们想要将实体类中的某个字段或某几个不进行解析呢？那么我们可以使用transient 关键字，来标记它为不需要的，在fastjson中还提供了一种便捷的方法来自定义我们需要序列化的字段，

1
SimplePropertyPreFilter filter =  new  SimplePropertyPreFilter(实体类. class ,  "字段1" , "字段2" ); 字段为我们需要序列化的字段，如果实体类中没有改字段则不解析放弃该字段而不会报错。

如下：

1
2
SimplePropertyPreFilter filter =  new  SimplePropertyPreFilter(Student. class ,  "id" , "age" );  
         String jsonStu =JSON.toJSONString(students,filter);


下面进行fastjson 的反序列化，这个也是很常用的功能，

还是拿最简单的来进行示范，

1
2
3
Student student =  new  Student( 0 ,  "Aaron" ,  24 );  
         String str = JSON.toJSONString(student, true );  
         System.out.println(JSON.parseObject(str,Student. class ));

 

反序列化主要使用的是JSON.parseObject(str,class); 它就能把我们的str 转化为class 类型的对象，当然还有更复杂的对象，比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
         List<Student> students =  new  ArrayList<Student>();  
         for ( int  i= 0 ;i< 5 ;i++) {  
             Student stu =  new  Student(i,  "Student"  + i,  18  +i);   
             students.add(stu);  
         }  
         // 过滤哪些属性需要转换  
//      SimplePropertyPreFilter filter = new SimplePropertyPreFilter(Student.class, "id","age");  
//      String jsonStu =JSON.toJSONString(students,filter);  
         String jsonStu =JSON.toJSONString(students);  
         System.out.println(jsonStu);  
           
         List<Student> stu =JSON.parseObject(jsonStu,  new  TypeReference<List<Student>>(){});  
         for ( int  i= 0 ;i<stu.size();i++)   
         {  
             System.out.println(stu.get(i));  
         }


前面就是添加数据，然后在后面解析为json格式，然后在转化为类的对象，这里转为List<Student> 对象，主要用到new TypeReference<数据返回类型> (){}，我们使用的就是new TypeReference<List<Student>>(){} 返回的结果就是List<Student> 也不需要强制转化，我们看看上面输出的结果为:

1
2
3
4
5
Student [id= 0 , name=Student0, age= 18 ]  
Student [id= 1 , name=Student1, age= 19 ]  
Student [id= 2 , name=Student2, age= 20 ]  
Student [id= 3 , name=Student3, age= 21 ]  
Student [id= 4 , name=Student4, age= 22 ]


附带，fastjson对时间的操作：

1
2
3
4
5
6
7
8
9
Date date =  new  Date();
// 输出毫秒值
System.out.println(JSON.toJSONString(date));
// 默认格式为yyyy-MM-dd HH:mm:ss
System.out.println(JSON.toJSONString(date,
         SerializerFeature.WriteDateUseDateFormat));
// 根据自定义格式输出日期
System.out.println(JSON.toJSONStringWithDateFormat(date,  "yyyy-MM-dd" ,
         SerializerFeature.WriteDateUseDateFormat));

输出结果：

1
2
3
1476085821568
"2016-10-10 15:50:21"
"2016-10-10"