Fastjson介绍

Fastjson是一个Java语言编写的JSON处理器,由阿里巴巴公司开发。
1、遵循http://json.org标准，为其官方网站收录的参考实现之一。
2、功能qiang打，支持JDK的各种类型，包括基本的JavaBean、Collection、Map、Date、Enum、泛型。
3、无依赖，不需要例外额外的jar，能够直接跑在JDK上。
4、开源，使用Apache License 2.0协议开源。http://code.alibabatech.com/wiki/display/FastJSON/Home
5、具有超高的性能，java世界里没有其他的json库能够和fastjson可相比了。

如果获得Fastjson？
SVN:http://code.alibabatech.com/svn/fastjson/trunk/
WIKI:http://code.alibabatech.com/wiki/display/FastJSON/Home
Issue Tracking:http://code.alibabatech.com/jira/browse/FASTJSON

如果你使用了Maven，maven repository配置如下：

  1. <repository>
  2. 	<id>opensesame</id>
  3. 	<name>Alibaba OpenSource Repsoitory</name>
  4. 	<url>http://code.alibabatech.com/mvn/releases/</url>
  5. 	<snapshots>
  6. 		<enabled>false</enabled>
  7. 	</snapshots>
  8. </repository>

pom.xml文件中加入依赖依赖：

  1. <dependency>
  2. 	<groupId>com.alibaba</groupId>
  3. 	<artifactId>fastjson</artifactId>
  4. 	<version>1.2.9</version>
  5. </dependency>

如果没有使用maven，可以直接下载：

Binary : http://code.alibabatech.com/mvn/releases/com/alibaba/fastjson/1.1.1/fastjson-1.1.1.jar
Source :http://code.alibabatech.com/mvn/releases/com/alibaba/fastjson/1.1.1/fastjson-1.1.1-sources.jar
Subversion : http://code.alibabatech.com/svn/fastjson/

使用介绍：
Fastjson的最主要的使用入口是com.alibaba.fastjson.JSON

  1. import com.alibaba.fastjson.JSON;
  2.  
  3. public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray
  4. public static final JSONObject parseObject(String text)； // 把JSON文本parse成JSONObject
  5. public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean
  6. public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
  7. public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合
  8. public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本
  9. public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本
  10. public static final Object toJSON(Object javaObject); 将JavaBean转换为JSONObject或者JSONArray。

使用例子：

两个基础类：

  1.  public class Student {
  2.      private int id;
  3.  
  4.      private String name;
  5.  
  6.      /**
  7.       * 默认的构造方法必须不能省，不然不能通过json字符串解析成java对象
  8.       */
  9.      public Student() {
  10.      }
  11.  
  12.      public Student(int id, String name) {
  13.          this.id = id;
  14.          this.name = name;
  15.      }
  16.  
  17.      public int getId() {
  18.          return id;
  19.      }
  20.  
  21.      public void setId(int id) {
  22.          this.id = id;
  23.      }
  24.  
  25.      public String getName() {
  26.          return name;
  27.      }
  28.  
  29.      public void setName(String name) {
  30.          this.name = name;
  31.      }
  32.  }
  1.  public class Teacher {
  2.      private int id;
  3.  
  4.      private String name;
  5.  
  6.      private List<Student> stus;
  7.      /**
  8.       * 默认的构造方法必须不能省，不然不能通过json字符串解析成java对象
  9.       */
  10.      public Teacher() {
  11.      }
  12.  
  13.      public Teacher(int id, String name) {
  14.          this.id = id;
  15.          this.name = name;
  16.      }
  17.  
  18.      public int getId() {
  19.          return id;
  20.      }
  21.  
  22.      public void setId(int id) {
  23.          this.id = id;
  24.      }
  25.  
  26.      public String getName() {
  27.          return name;
  28.      }
  29.  
  30.      public void setName(String name) {
  31.          this.name = name;
  32.      }
  33.  
  34.      public List<Student> getStus() {
  35.          return stus;
  36.      }
  37.  
  38.      public void setStus(List<Student> stus) {
  39.          this.stus = stus;
  40.      }
  41.  
  42.      public void addStudent(Student stu){
  43.          this.stus.add(stu);
  44.      }
  45.  
  46.      public void addStudents(List<Student> stus){
  47.          for (Student stu : stus) {
  48.              this.stus.add(stu);
  49.          }
  50.      }
  51.  
  52.      public void setStudents(List<Student> stus){
  53.          this.stus=stus;
  54.      }
  55.  }
  1.  public class JsonTest1 {
  2.      public static void main(String[] args) {
  3.          Student stu=new Student(1,"one");
  4.          //java实例转化成json字符串
  5.          String jsonStr=test1(stu);
  6.          print();
  7.          //json字符串转成java实例
  8.          stu=test2(jsonStr);
  9.          print();
  10.          //集合转成json字符串
  11.          jsonStr=test3();
  12.          print();
  13.  
  14.          //复杂集合转成json字符串
  15.          test4();
  16.          print();
  17.  
  18.      }
  19.      //java实例转化成json字符串
  20.      public static String test1(Student stu){
  21.          String jsonStr=JSON.toJSONString(stu);
  22.          System.out.println(jsonStr);
  23.          return jsonStr;
  24.      }
  25.  
  26.      //json字符串转成java实例
  27.      public static Student test2(String jsonStr){
  28.          Student stu=JSON.parseObject(jsonStr,Student.class);
  29.          System.out.println("转换前json字符串："+jsonStr);
  30.          System.out.println("转换后：id="+stu.getId()+",name="+stu.getName());
  31.          return stu;
  32.      }
  33.  
  34.      //集合转成json字符串
  35.      public static String test3(){
  36.          List<Student> list=new ArrayList<Student>();
  37.          for(int i=1;i<=3;i++){
  38.              list.add(new Student(i,"name "+i));
  39.          }
  40.          String jsonStr=JSON.toJSONString(list);
  41.          System.out.println(jsonStr);
  42.          return jsonStr;
  43.      }
  44.  
  45.      //复杂集合转成json字符串
  46.      public static String test4(){
  47.          List<Teacher> teaList = new ArrayList<Teacher>();
  48.          long time = System.currentTimeMillis();
  49.          for(int i=0;i<10;i++) {
  50.              Teacher teacher = new Teacher(i, "Teacher " + i);
  51.              List<Student> stus = new ArrayList<Student>();
  52.              for(int j = 0 ;j<4;j++) {
  53.                  Student s = new Student(j, "Student" + j);
  54.                  stus.add(s);
  55.              }
  56.              teacher.setStudents(stus);
  57.              teaList.add(teacher);
  58.          }
  59.          //true表示按照json格式输出
  60.          String jsonStr = JSON.toJSONString(teaList,true);
  61.          System.out.println(jsonStr);
  62.          return jsonStr;
  63.      }
  64.      public static void print(){
  65.          System.out.println("....................................");
  66.      }
  67.  }

输出结果：

  1. {"id":1,"name":"one"}
  2. ....................................
  3. 转换前json字符串：{"id":1,"name":"one"}
  4. 转换后：id=1,name=one
  5. ....................................
  6. [{"id":1,"name":"name 1"},{"id":2,"name":"name 2"},{"id":3,"name":"name 3"}]
  7. ....................................
  8. [
  9.     {
  10.         "id":0,
  11.         "name":"Teacher 0",
  12.         "stus":[
  13.             {
  14.                 "id":0,
  15.                 "name":"Student0"
  16.             },
  17.             {
  18.                 "id":1,
  19.                 "name":"Student1"
  20.             },
  21.             {
  22.                 "id":2,
  23.                 "name":"Student2"
  24.             },
  25.             {
  26.                 "id":3,
  27.                 "name":"Student3"
  28.             }
  29.         ]
  30.     },
  31.     {
  32.         "id":1,
  33.         "name":"Teacher 1",
  34.         "stus":[
  35.             {
  36.                 "id":0,
  37.                 "name":"Student0"
  38.             },
  39.             {
  40.                 "id":1,
  41.                 "name":"Student1"
  42.             },
  43.             {
  44.                 "id":2,
  45.                 "name":"Student2"
  46.             },
  47.             {
  48.                 "id":3,
  49.                 "name":"Student3"
  50.             }
  51.         ]
  52.     },
  53.     {
  54.         "id":2,
  55.         "name":"Teacher 2",
  56.         "stus":[
  57.             {
  58.                 "id":0,
  59.                 "name":"Student0"
  60.             },
  61.             {
  62.                 "id":1,
  63.                 "name":"Student1"
  64.             },
  65.             {
  66.                 "id":2,
  67.                 "name":"Student2"
  68.             },
  69.             {
  70.                 "id":3,
  71.                 "name":"Student3"
  72.             }
  73.         ]
  74.     },
  75.     {
  76.         "id":3,
  77.         "name":"Teacher 3",
  78.         "stus":[
  79.             {
  80.                 "id":0,
  81.                 "name":"Student0"
  82.             },
  83.             {
  84.                 "id":1,
  85.                 "name":"Student1"
  86.             },
  87.             {
  88.                 "id":2,
  89.                 "name":"Student2"
  90.             },
  91.             {
  92.                 "id":3,
  93.                 "name":"Student3"
  94.             }
  95.         ]
  96.     },
  97.     {
  98.         "id":4,
  99.         "name":"Teacher 4",
  100.         "stus":[
  101.             {
  102.                 "id":0,
  103.                 "name":"Student0"
  104.             },
  105.             {
  106.                 "id":1,
  107.                 "name":"Student1"
  108.             },
  109.             {
  110.                 "id":2,
  111.                 "name":"Student2"
  112.             },
  113.             {
  114.                 "id":3,
  115.                 "name":"Student3"
  116.             }
  117.         ]
  118.     },
  119.     {
  120.         "id":5,
  121.         "name":"Teacher 5",
  122.         "stus":[
  123.             {
  124.                 "id":0,
  125.                 "name":"Student0"
  126.             },
  127.             {
  128.                 "id":1,
  129.                 "name":"Student1"
  130.             },
  131.             {
  132.                 "id":2,
  133.                 "name":"Student2"
  134.             },
  135.             {
  136.                 "id":3,
  137.                 "name":"Student3"
  138.             }
  139.         ]
  140.     },
  141.     {
  142.         "id":6,
  143.         "name":"Teacher 6",
  144.         "stus":[
  145.             {
  146.                 "id":0,
  147.                 "name":"Student0"
  148.             },
  149.             {
  150.                 "id":1,
  151.                 "name":"Student1"
  152.             },
  153.             {
  154.                 "id":2,
  155.                 "name":"Student2"
  156.             },
  157.             {
  158.                 "id":3,
  159.                 "name":"Student3"
  160.             }
  161.         ]
  162.     },
  163.     {
  164.         "id":7,
  165.         "name":"Teacher 7",
  166.         "stus":[
  167.             {
  168.                 "id":0,
  169.                 "name":"Student0"
  170.             },
  171.             {
  172.                 "id":1,
  173.                 "name":"Student1"
  174.             },
  175.             {
  176.                 "id":2,
  177.                 "name":"Student2"
  178.             },
  179.             {
  180.                 "id":3,
  181.                 "name":"Student3"
  182.             }
  183.         ]
  184.     },
  185.     {
  186.         "id":8,
  187.         "name":"Teacher 8",
  188.         "stus":[
  189.             {
  190.                 "id":0,
  191.                 "name":"Student0"
  192.             },
  193.             {
  194.                 "id":1,
  195.                 "name":"Student1"
  196.             },
  197.             {
  198.                 "id":2,
  199.                 "name":"Student2"
  200.             },
  201.             {
  202.                 "id":3,
  203.                 "name":"Student3"
  204.             }
  205.         ]
  206.     },
  207.     {
  208.         "id":9,
  209.         "name":"Teacher 9",
  210.         "stus":[
  211.             {
  212.                 "id":0,
  213.                 "name":"Student0"
  214.             },
  215.             {
  216.                 "id":1,
  217.                 "name":"Student1"
  218.             },
  219.             {
  220.                 "id":2,
  221.                 "name":"Student2"
  222.             },
  223.             {
  224.                 "id":3,
  225.                 "name":"Student3"
  226.             }
  227.         ]
  228.     }
  229. ]
  230. ....................................

如果对类中有些字段不解析，可以通过SimplePropertyPreFilter来选取需要需要解析的属性，例子如下：

  1.   //类中有个别字段不解析
  2.      public static void test5(){
  3.          Student stu=new Student(1,"one");
  4.          SimplePropertyPreFilter filter=new SimplePropertyPreFilter(Student.class,"id");
  5.          String jsonStr=JSON.toJSONString(stu,filter);
  6.          System.out.println(jsonStr);
  7.      }

输出结果：

  1. {"id":1}

把list集合的json字符串反序列为list集合：

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

代码输出：

  1. [{"id":0,"name":"Student0"},{"id":1,"name":"Student1"},{"id":2,"name":"Student2"},{"id":3,"name":"Student3"},{"id":4,"name":"Student4"}]
  2. com.main.etl.server.json.Student@60682430
  3. com.main.etl.server.json.Student@551ffcc2
  4. com.main.etl.server.json.Student@270b5037
  5. com.main.etl.server.json.Student@57bf5ee7
  6. com.main.etl.server.json.Student@54efbcb2

8 fastJson的使用的更多相关文章

  1. fastjson 混淆注意事项

    使用fastjson 注意事项,主要表现: 1.加了符号Annotation 的实体类,一使用就会奔溃 2.当有泛型属性时,一使用就奔溃 在调试的时候不会报错,当你要打包签名混淆包的时候,就会出现上述 ...

  2. Java的Json解析包FastJson使用

    阿里巴巴FastJson是一个Json处理工具包,包括“序列化”和“反序列化”两部分,它具备如下特征:速度最快,测试表明,fastjson具有极快的性能,超越任其他的Java Json parser. ...

  3. fastJson使用

    fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器,由阿里巴巴的工程师开发. 主要特点: 快速FAST (比其它任何基于Java的解析器和生成器更快,包括jackson ...

  4. FASTJSON

    package com.hanqi.test; import java.util.ArrayList;import java.util.Date;import java.util.List; impo ...

  5. Android总结之json解析（FastJson Gson 对比）

    前言: 最近为了统一项目中使用的框架,发现项目中用到了两种json解析框架,他们就是当今非常主流的json解析框架:google的Gson 和阿里巴巴的FastJson,为了废除其中一个所以来个性能和 ...

  6. Android原生json和fastjson的简单使用

    android原生操作json数据 主要是两个类 JSONObject 操作对象     JONSArray操作json数组 对象转json //创建学生对象 Student student=new ...

  7. FastJson的简单实用

    一.FastJson的理解 在工作中,经常客服端需要和服务端进行通信,目前很多项目都采用JSON的方式进行数据传输,简单的参数可以通过手动拼接JSON字符串,但如果请求的参数过多,采用手动拼接JSON ...

  8. Android JSON、GSON、FastJson的封装与解析

    声明: 1.本帖只提供代码,不深入讲解原理.如果读者想要深入了解,那就不要在这个帖子上浪费时间了 2.客户端用的是Google官方的Volley访问服务器,具体了解Volley请戳 这里 3.本帖三种 ...

  9. java分享第十三天（fastjson生成和解析json数据，序列化和反序列化数据）

     fastjson简介:Fastjson是一个Java语言编写的高性能功能完善的JSON库.fastjson采用独创的算法,将parse的速度提升到极致,超过所有json库,包括曾经号称最快的jack ...

  10. FastJson和AsyncHttpCLient

    Android的展示数据,除了上章所讲的本地存储外,大部分数据都来自于网络.首先介绍一下Android APP开发常见的网络操作方式.从网络层面上有底层的tcp/ip,也就是我们常见的socket套接 ...

随机推荐

  1. GDI相关基础知识

    原文链接:http://blog.csdn.net/poem_qianmo/article/details/7333886 GDI(Graphics Device Interface) 图形设备接口, ...

  2. （原）windows8.1上使用opencv for python

    转载请注明出处: http://www.cnblogs.com/darkknightzh/p/6204100.html 参考网址: http://www.docs.opencv.org/master/ ...

  3. 《APUE》读书笔记第十二章-线程控制

    本章中,主要是介绍控制线程行为方面的内容,同时介绍了在同一进程中的多个线程之间如何保持数据的私有性以及基于进程的系统调用如何与线程进行交互. 一.线程属性 我们在创建线程的时候可以通过修改pthrea ...

  4. C# 调用浏览器打开网址

    private void button1_Click(object sender, EventArgs e) { //调用系统默认的浏览器 System.Diagnostics.Process.Sta ...

  5. HTML5 布局标签

    HTML5是HTML标准的下一个版本.越来越多的程序员开始HTML5来构建网站,相对HTML4,HTML5新增的带有语义化的标签可以代替div进行页面布局(与html5.js结合起来时可以放心使用 ) ...

  6. WF学习

    1.添加argument 类的argument必须先在表达式里面实例化 argument和variable 没有区别啊??????? http://msdn.microsoft.com/en-us/l ...

  7. JAVA回调函数ANDROID中典型的回调地方

    在计算机中回调函数是指通过函数参数传递到其他代码类的,某一块可执行代码的引用,这以设计允许了底层代码调用者在高层定义的子程序. 在JAVA里面我们使用接口的方式来实现函数的回调. 回调的通俗就是:程序 ...

  8. Codeforces 566F Clique in the Divisibility Graph

    http://codeforces.com/problemset/problem/566/F 题目大意: 有n个点,点上有值a[i], 任意两点(i, j)有无向边相连当且仅当 (a[i] mod a ...

  9. Qt下使用的静态链接库------ *.lib转化为mingw使用的.a格式的静态库

    使用MinGW附带的工具reimp.exe,该工具一般在MinGW in目录下,其readme文档在MinGWdoc eimp目录下, 方法很简单,比如: C:CodeBlocksMinGWlibdx ...

  10. WPF中的换行符

    原文:WPF中的换行符 WPF中UI上和后台代码中的换行符不同. 其中: XAML中为 C#代码中为 \r\n 或者: Environment.NewLine 版权声明:本文为博主原创文章,未经博主允 ...