FastJson常用方法

最新推荐文章于 2023-10-25 17:11:10 发布

weixin_33878457

最新推荐文章于 2023-10-25 17:11:10 发布

阅读量123

点赞数

文章标签： json java

原文链接：http://www.cnblogs.com/java-jun-world2099/articles/9562712.html

版权

以前用的都是net.sf.json.JSONObject，目前项目用到了fastjson，边用边学。最近空闲时间比较少所以参考了两篇博客和自己的一些实践，博文水平有限，欢迎多多指正。

一、net.sf.json.JSONObject常用方法

String trace = (String)map.get("trace");
JSONObject obj = JSONObject.fromObject(trace);
JSONArray jsonArray = obj.getJSONArray("listexpressmail");
JSONObject jsonReturn = jsonArray.getJSONObject(0);
                     
if(jsonResult.has("success"))//判断是否含有该key
log.setSendstatus(jsonResult.getString("success"));     
if(jsonResult.has("errorCode"))
log.setSendstatuscode(jsonResult.getString("errorCode"));

二、FastJson概述

FastJSON是一个Java语言编写的高性能，功能完善，完全支持http://json.org的标准的JSON库。

FastJson对于json格式字符串的解析主要用到了一下三个类：

JSON：fastJson的解析器，用于JSON格式字符串与JSON对象及javaBean之间的转换。

JSONObject：fastJson提供的json对象。

JSONArray：fastJson提供json数组对象。

我们可以把JSONObject当成一个Map<String,Object>来看，只是JSONObject提供了更为丰富便捷的方法，方便我们对于对象属性的操作。我们看一下源码。

同样我们可以把JSONArray当做一个List<Object>，可以把JSONArray看成JSONObject对象的一个集合。

此外，由于JSONObject和JSONArray继承了JSON，所以说也可以直接使用两者对JSON格式字符串与JSON对象及javaBean之间做转换，不过为了避免混淆我们还是使用JSON。

三、常用的转换方法

首先定义三个json格式的字符串，作为我们的数据源。

//json字符串-简单对象型
private static final String  JSON_OBJ_STR = "{\"studentName\":\"lily\",\"studentAge\":12}";
//json字符串-数组类型
private static final String  JSON_ARRAY_STR = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";
//复杂格式json字符串
private static final String  COMPLEX_JSON_STR = "{\"teacherName\":\"crystall\",\"teacherAge\":27,\"course\":{\"courseName\":\"english\",\"code\":1270},\"students\":[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]}";

1、示例1：JSON格式字符串与JSON对象之间的转换

示例1.1-json字符串-简单对象型与JSONObject之间的转换

   /**
     * json字符串-简单对象型与JSONObject之间的转换
     */
    public static void testJSONStrToJSONObject(){

        JSONObject jsonObject = JSON.parseObject(JSON_OBJ_STR);
        //JSONObject jsonObject1 = JSONObject.parseObject(JSON_OBJ_STR); //因为JSONObject继承了JSON，所以这样也是可以的

        System.out.println(jsonObject.getString("studentName")+":"+jsonObject.getInteger("studentAge"));

    }

示例1.2-json字符串-数组类型与JSONArray之间的转换

   /**
     * json字符串-数组类型与JSONArray之间的转换
     */
    public static void testJSONStrToJSONArray(){

        JSONArray jsonArray = JSON.parseArray(JSON_ARRAY_STR);
        //JSONArray jsonArray1 = JSONArray.parseArray(JSON_ARRAY_STR);//因为JSONArray继承了JSON，所以这样也是可以的

        //遍历方式1
        int size = jsonArray.size();
        for (int i = 0; i < size; i++){
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            System.out.println(jsonObject.getString("studentName")+":"+jsonObject.getInteger("studentAge"));
        }

        //遍历方式2
        for (Object obj : jsonArray) {
            JSONObject jsonObject = (JSONObject) obj;
            System.out.println(jsonObject.getString("studentName")+":"+jsonObject.getInteger("studentAge"));
        }
    }

示例1.3-复杂json格式字符串与JSONObject之间的转换

   /**
     * 复杂json格式字符串与JSONObject之间的转换
     */
    public static void testComplexJSONStrToJSONObject(){

        JSONObject jsonObject = JSON.parseObject(COMPLEX_JSON_STR);
        //JSONObject jsonObject1 = JSONObject.parseObject(COMPLEX_JSON_STR);//因为JSONObject继承了JSON，所以这样也是可以的
        
        String teacherName = jsonObject.getString("teacherName");
        Integer teacherAge = jsonObject.getInteger("teacherAge");
        JSONObject course = jsonObject.getJSONObject("course");
        JSONArray students = jsonObject.getJSONArray("students");

    }

2、示例2：JSON格式字符串与javaBean之间的转换

首先，我们针对数据源所示的字符串，提供三个javaBean

public class Student {

    private String studentName;
    private Integer studentAge;

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public Integer getStudentAge() {
        return studentAge;
    }

    public void setStudentAge(Integer studentAge) {
        this.studentAge = studentAge;
    }
}

public class Course {

    private String courseName;
    private Integer code;

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }
}

public class Teacher {

    private String teacherName;
    private Integer teacherAge;
    private Course course;
    private List<Student> students;

    public String getTeacherName() {
        return teacherName;
    }

    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }

    public Integer getTeacherAge() {
        return teacherAge;
    }

    public void setTeacherAge(Integer teacherAge) {
        this.teacherAge = teacherAge;
    }

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }
}

json字符串与javaBean之间的转换推荐使用 TypeReference<T> 这个类，使用泛型可以更加清晰，当然也有其它的转换方式，这里就不做探讨了。

示例2.1-json字符串-简单对象型与javaBean之间的转换

   /**
     * json字符串-简单对象与JavaBean_obj之间的转换
     */
    public static void testJSONStrToJavaBeanObj(){

        Student student = JSON.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});
        //Student student1 = JSONObject.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});//因为JSONObject继承了JSON，所以这样也是可以的

        System.out.println(student.getStudentName()+":"+student.getStudentAge());

    }

示例2.2-json字符串-数组类型与javaBean之间的转换

   /**
     * json字符串-数组类型与JavaBean_List之间的转换
     */
    public static void testJSONStrToJavaBeanList(){
        
        ArrayList<Student> students = JSON.parseObject(JSON_ARRAY_STR, new TypeReference<ArrayList<Student>>() {});
        //ArrayList<Student> students1 = JSONArray.parseObject(JSON_ARRAY_STR, new TypeReference<ArrayList<Student>>() {});//因为JSONArray继承了JSON，所以这样也是可以的
        
        for (Student student : students) {
            System.out.println(student.getStudentName()+":"+student.getStudentAge());
        }
    }

示例2.3-复杂json格式字符串与与javaBean之间的转换

   /**
     * 复杂json格式字符串与JavaBean_obj之间的转换
     */
    public static void testComplexJSONStrToJavaBean(){

        Teacher teacher = JSON.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});
        //Teacher teacher1 = JSON.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});//因为JSONObject继承了JSON，所以这样也是可以的
        String teacherName = teacher.getTeacherName();
        Integer teacherAge = teacher.getTeacherAge();
        Course course = teacher.getCourse();
        List<Student> students = teacher.getStudents();
    }

对于TypeReference<T>，由于其构造方法使用 protected 进行修饰，所以在其他包下创建其对象的时候，要用其实现类的子类：new TypeReference<Teacher>() {}

四、序列化

序列化就是指把JavaBean对象转成JSON格式的字符串。

com.alibaba.fastjson.JSON提供了许多方法（多态）实现序列化。

基本的序列化

String objJson = JSON.toJSONString(Object object);

传入一个对象，将对象转成JSON字符串。

例1：将Map转成JSON字符串

Map<String, Object> map = new HashMap<String, Object>();
map.put("key1", "One");
map.put("key2", "Two");
        
String mapJson = JSON.toJSONString(map);

输出结果：

{"key1":"One","key2":"Two"}

例1.1：Map与JSON互转

public static void main(String[] args) {
        Map map = new HashMap();
        map.put("a","战士");
        JSONObject o = (JSONObject)JSONObject.toJSON(map);
        System.out.println(o.getString("a"));
        JSONObject o1 = new JSONObject(map);
        System.out.println(o1.getString("a"));
        System.out.println("------------------------------");
        JSONObject obj = new JSONObject();
        obj.put("b","掌声");
        Map map1 = obj;
        System.out.println(map1.get("b"));
    }

输出结果：

例2：将List<Map>转成JSON

List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
         
Map<String, Object> map1 = new HashMap<String, Object>();
map1.put("key1", "One");
map1.put("key2", "Two");
        
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put("key1", "Three");
map2.put("key2", "Four");
        
list.add(map1);
list.add(map2);
         
String listJson = JSON.toJSONString(list);

输出结果：

[{"key1":"One","key2":"Two"},{"key3":"Three","key4":"Four"}]

例3：自定义JavaBean User转成JSON

User user = new User();
user.setUserName("李四");
user.setAge(24);
        
String userJson = JSON.toJSONString(user);

输出结果：

{"age":24,"userName":"李四"}

可以输出格式化后的 JSON 字符串。

String objJson = JSON.toJSONString(Object object, boolean prettyFormat);

传入一个对象和一个布尔类型（是否格式化），将对象转成格式化后的JSON字符串。

例4：以例2代码为例

String listJson = JSON.toJSONString(list, true);

输出结果为：

[
      {
          "key1":"One",
          "key2":"Two"
      },
      {
          "key3":"Three",
          "key4":"Four"
      }
]

FastJSON提供了许多特性支持。

String objJson = JSON.toJSONString(Object object, SerializerFeature... features)

传入一个对象和SerializerFeature类型的可变变量。SerializerFeature是一个枚举。

com.alibaba.fastjson.serializer.SerializerFeature

你可以根据自己的情况使用这些特性。

简单说下几个常用的特性：

1.日期格式化：

FastJSON可以直接对日期类型格式化，在缺省的情况下，FastJSON会将Date转成long。

例5：FastJSON将java.util.Date转成long

String dateJson = JSON.toJSONString(new Date());
         
System.out.println(dateJson);

输出结果：

1401370199040

例6：使用SerializerFeature特性格式化日期

String dateJson = JSON.toJSONString(new Date(), SerializerFeature.WriteDateUseDateFormat);
        
System.out.println(dateJson);

输出结果：

"2014-05-29 21:36:24"

也可以指定输出日期格式。

例7：指定输出日期格式

String dateJson = JSON.toJSONStringWithDateFormat(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");
         
System.out.println(dateJson);

输出结果：

"2014-05-29 21:47:00.154"

例8：以例2为例，使用单引号

String listJson = JSON.toJSONString(list, SerializerFeature.UseSingleQuotes);

输出结果：

[{'key1':'One','key2':'Two'},{'key3':'Three','key4':'Four'}]

例9：JSON格式化

String listJson = JSON.toJSONString(list, SerializerFeature.PrettyFormat);

输出结果为这种格式化后的：

[
      {
          "key1":"One",
          "key2":"Two"
      },
      {
          "key3":"Three",
          "key4":"Four"
      }
]

例10：输出Null字段

缺省情况下FastJSON不输出为值Null的字段，可以使用SerializerFeature.WriteMapNullValue使其输出。

Map<String, Object> map = new HashMap<String,Object>();
         
String b = null;
Integer i = 1;
         
map.put("a", b);
map.put("b", i);
        
String listJson = JSON.toJSONString(map, SerializerFeature.WriteMapNullValue);

输出结果：

{"a":null,"b":1}

例11：序列化是写入类型信息

User user = new User();
         
user.setAge(18);
user.setUserName("李四");
         
String listJson = JSON.toJSONString(user, SerializerFeature.WriteClassName);

输出结果：

{"@type":"User","age":18,"userName":"李四"}

由于序列化带了类型信息，使得反序列化时能够自动进行类型识别。

例12：将例11的javabean反序列化

User user1 = (User) JSON.parse(listJson);
         
System.out.println(user1.getAge());

输出结果：18

如果User序列化是没有加入类型信息（SerializerFeature.WriteClassName），按照例12的做法就会报错（java.lang.ClassCastException）。

五、反序列化

反序列化就是把JSON格式的字符串转化为Java Bean对象。

com.alibaba.fastjson.JSON提供了许多方法（多态）实现反序列化。

简单举几个例子。

指定Class信息反序列化。

例13：将例3反序列化

User user1 = JSON.parseObject(userJson, User.class);
System.out.println(user1.getUserName());

输出结果：李四

集合反序列化。

例14：将例2反序列化

List<Map> list1 = JSON.parseArray(listJson, Map.class);
          
for(Map<String, Object> map : list1){
     System.out.println(map.get("key1"));
     System.out.println(map.get("key2"));         
}

输出结果：

One
Two
Three
Four

泛型的反序列化（使用TypeReference传入类型信息）。

例15：将例1反序列化

Map<String, Object> map1 = JSON.parseObject(mapJson, new TypeReference<Map<String, Object>>(){});
System.out.println(map1.get("key1"));
System.out.println(map1.get("key2"));

输出结果：

One
Two

六、JSONObject 与 JSONArray

JSONObject，JSONArray是JSON的两个子类。

JSONObject相当于Map<String, Object>，

JSONArray相当于List<Object>。

简单方法示例：

例16：将Map转成JSONObject，然后添加元素，输出

Map<String, Object> map = new HashMap<String, Object>();
map.put("key1", "One");
map.put("key2", "Two");
                            
JSONObject j = new JSONObject(map);
                   
j.put("key3", "Three");
          
System.out.println(j.get("key1"));
System.out.println(j.get("key2"));
System.out.println(j.get("key3"));

输出结果：

One
Two
Three

例17：将List对象转成JSONArray，然后输出

List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
         
Map<String, Object> map = new HashMap<String, Object>();
map.put("key1", "One");
map.put("key2", "Two");
       
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put("key1", "Three");
map2.put("key2", "Four");
       
list.add(map);
list.add(map2);
         
JSONArray j = JSONArray.parseArray(JSON.toJSONString(list));
         
for(int i=0; i<j.size(); i++){
    System.out.println(j.get(i));
}

输出结果：

{"key1":"One","key2":"Two"}
{"key1":"Three","key2":"Four"}

七、FastJson过滤属性、判断json是否存在某个key

以下是一个通用的对象转json的方法,使用的fastjson的SimplePropertyPreFilter 对象,个人感觉比使用PropertyPreFilter的匿名内部类形式的过滤器更好用。

/**
 * 将对象序列化为json,并回写到客户端浏览器
 */
public void objectToJson(Object obj, String[] args) {
   //属性过滤器对象
   SimplePropertyPreFilter filter = new SimplePropertyPreFilter();

   //属性排斥集合,强调某些属性不需要或者一定不能被序列化
   Set<String> excludes = filter.getExcludes();

   //属性包含集合,强调仅需要序列化某些属性.具体用哪一个,看实际情况.此处我用的前者
   //Set<String> includes = filter.getIncludes();

   //排除不需序列化的属性
   for (String string : args) {
      excludes.add(string);
   }

   //调用fastJson的方法,对象转json,
   //参数一:需要被序列化的对象
   //参数二:用于过滤属性的过滤器
   //参数三:关闭循环引用,若不加这个,页面无法展示重复的属性值
   String string = JSON.toJSONString(obj, filter,SerializerFeature.DisableCircularReferenceDetect);

}

页面判断json对象是否包含某个key 或value
containsKey

containsValue

包含返回true,反之返回false。

八、简单附上一个json工具类：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
 
public class MyJsonUtil {
 
    private static final SerializerFeature[] features = {SerializerFeature.WriteMapNullValue, // 输出空置字段
                                                         // SerializerFeature.WriteNullListAsEmpty,
                                                         // // list字段如果为null，输出为[]，而不是null
                                                         // SerializerFeature.WriteNullNumberAsZero,
                                                         // // 数值字段如果为null，输出为0，而不是null
                                                         // SerializerFeature.WriteNullBooleanAsFalse,
                                                         // // Boolean字段如果为null，输出为false，而不是null
                                                         // SerializerFeature.WriteNullStringAsEmpty,
                                                         // // 字符类型字段如果为null，输出为""，而不是null
                                                         SerializerFeature.WriteDateUseDateFormat // 日期格式化yyyy-MM-dd
                                                                                                  // HH:mm:ss
    };
 
    public static String toJson(Object object) {
        return JSON.toJSONString(object, features);
    }
}

参考资料：

https://blog.csdn.net/flysun3344/article/details/54707965

https://www.cnblogs.com/cdf-opensource-007/p/7106018.html

https://blog.csdn.net/jimoandgudu/article/details/79737171

转载于:https://www.cnblogs.com/java-jun-world2099/articles/9562712.html

weixin_33878457

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
FastJson常用方法

以前用的都是net.sf.json.JSONObject，目前项目用到了fastjson，边用边学。最近空闲时间比较少所以参考了两篇博客和自己的一些实践，博文水平有限，欢迎多多指正。一、net.sf.json.JSONObject常用方法String trace = (String)map.get("trace");JSONObject obj = JSONObject.fromO...
复制链接

扫一扫