• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

工具类-Fastjson入门使用

开发技术 开发技术 2周前 (09-15) 18次浏览

简介

什么是Fastjson?

fastjson是阿里巴巴的开源JSON解析库,它可以解析JSON格式的字符串,支持将Java Bean序列化为JSON字符串,也可以从JSON字符串反序列化到JavaBean。
Fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法,把JSON Parse的性能提升到极致,是目前Java语言中最快的JSON库。Fastjson接口简单易用,已经被广泛使用在缓存序列化、协议交互、Web输出、Android客户端等多种应用场景
主要特点:
快速FAST (比其它任何基于Java的解析器和生成器更快,包括jackson)
强大(支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum)
零依赖(没有依赖其它任何类库除了JDK)
开源,使用Apache License 2.0协议开源。
源码:https://github.com/alibaba/fastjson
wiki:https://github.com/alibaba/fastjson/wiki/Quick-Start-CN

Fastjson使用场景

fastjson已经被广泛使用在各种场景,包括cache存储、RPC通讯、MQ通讯、网络协议通讯、Android客户端、Ajax服务器处理程序等等。

Fastjson的优点

  1. 速度快
    fastjson相对其他JSON库的特点是快,从2011年fastjson发布1.1.x版本之后,其性能从未被其他Java实现的JSON库超越。
  2. 使用广泛
    fastjson在阿里巴巴大规模使用,在数万台服务器上部署,fastjson在业界被广泛接受。在2012年被开源中国评选为最受欢迎的国产开源软件之一。
  3. 测试完备
    fastjson有非常多的testcase,在1.2.11版本中,testcase超过3321个。每次发布都会进行回归测试,保证质量稳定。
  4. 使用简单
    fastjson的API十分简洁。
String text = JSON.toJSONString(obj); //序列化
Model vo = JSON.parseObject("{...}", Mpode.class); //反序列化
  1. 功能完备
    支持泛型,支持流处理超大文本,支持枚举,支持序列化和反序列化扩展。

下载和使用

下载

你可以在maven中央仓库中直接下载:

http://repo1.maven.org/maven2/com/alibaba/fastjson/

或者配置maven依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>x.x.x</version>
</dependency>

其中x.x.x是版本号,跟进需要使用特定版本,建议使用最新版本,目前最新版本为1.2.58

简单使用

JSON这个类是fastjson API的入口,主要的功能都通过这个类提供。
序列化API

package com.alibaba.fastjson;
public abstract class JSON {
    // 将Java对象序列化为JSON字符串,支持各种各种Java基本类型和JavaBean
    public static String toJSONString(Object object, SerializerFeature... features);
    // 将Java对象序列化为JSON字符串,返回JSON字符串的utf-8 bytes
    public static byte[] toJSONBytes(Object object, SerializerFeature... features);
    // 将Java对象序列化为JSON字符串,写入到Writer中
    public static void writeJSONString(Writer writer, Object object,SerializerFeature... features);
    // 将Java对象序列化为JSON字符串,按UTF-8编码写入到OutputStream中
    public static final int writeJSONString(OutputStream os, // 
                                           Object object, // 
                                            SerializerFeature... features);
}

JSON字符串反序列化API

package com.alibaba.fastjson;
public abstract class JSON {
    // 将JSON字符串反序列化为JavaBean
    public static <T> T parseObject(String jsonStr, 
                                    Class<T> clazz, 
                                    Feature... features);
    // 将JSON字符串反序列化为JavaBean
    public static <T> T parseObject(byte[] jsonBytes,  // UTF-8格式的JSON字符串
                                    Class<T> clazz, 
                                    Feature... features);
    // 将JSON字符串反序列化为泛型类型的JavaBean
    public static <T> T parseObject(String text, 
                                    TypeReference<T> type, 
                                    Feature... features);
    // 将JSON字符串反序列为JSONObject
    public static JSONObject parseObject(String text);
}

简单示例
parse Tree

import com.alibaba.fastjson.*;
JSONObject jsonObj = JSON.parseObject(jsonStr);

parse POJO

import com.alibaba.fastjson.JSON;
Model model = JSON.parseObject(jsonStr, Model.class);

parse POJO Generic

import com.alibaba.fastjson.JSON;
Type type = new TypeReference<List<Model>>() {}.getType(); 
List<Model> list = JSON.parseObject(jsonStr, type);

convert POJO to json string

import com.alibaba.fastjson.JSON;
Model model = ...; 
String jsonStr = JSON.toJSONString(model);

convert POJO to json bytes

import com.alibaba.fastjson.JSON;
Model model = ...; 
byte[] jsonBytes = JSON.toJSONBytes(model);

write POJO as json string to OutputStream

import com.alibaba.fastjson.JSON;
Model model = ...; 
OutputStream os;
JSON.writeJSONString(os, model);

write POJO as json string to Writer

import com.alibaba.fastjson.JSON;
Model model = ...; 
Writer writer = ...;
JSON.writeJSONString(writer, model);

高级使用

Fastjson 定制序列化

  1. 简介

fastjson支持多种方式定制序列化。
通过@JSONField定制序列化
通过@JSONType定制序列化
通过SerializeFilter定制序列化
通过ParseProcess定制反序列化

  1. 使用@JSONField配置

可以把@JSONField配置在字段或者getter/setter方法上。例如:

public class VO {
      @JSONField(name="ID")
      private int id;
 }

或者

 public class VO {
      private int id;

      @JSONField(name="ID")
      public int getId() { return id;}

      @JSONField(name="ID")
      public void setId(int value) {this.id = id;}
 }
  1. 使用@JSONType配置
    和JSONField类似,但JSONType配置在类上,而不是field或者getter/setter方法上。
  2. 通过SerializeFilter定制序列化
    通过SerializeFilter可以使用扩展编程的方式实现定制序列化。fastjson提供了多种SerializeFilter:
  • PropertyPreFilter 根据PropertyName判断是否序列化
  • PropertyFilter 根据PropertyName和PropertyValue来判断是否序列化
  • NameFilter 修改Key,如果需要修改Key,process返回值则可
  • ValueFilter 修改Value
  • BeforeFilter 序列化时在最前添加内容
    *AfterFilter 序列化时在最后添加内容
    以上的SerializeFilter在JSON.toJSONString中可以使用。
  SerializeFilter filter = ...; // 可以是上面5个SerializeFilter的任意一种。
  JSON.toJSONString(obj, filter);
  1. 通过ParseProcess定制反序列化

Fastjson 实例

Fastjson 对象或数组转JSON

Fastjson阿里巴巴工程师开源的一个 json 库:Fastjson,这个库在解析速度和易用性上来说都很不错。
在日志解析,前后端数据传输交互中,经常会遇到String与map、json、xml等格式相互转换与解析的场景,其中json基本成为了跨语言、跨前后端的事实上的标准数据交互格式。应该来说各个语言中解析json的库都一大片(具体 json 格式与三方库的介绍请见:http://www.json.org/json-zh.html ),比如python都集成在了内置库中,成为标准API,今天我们要聊的是java中如何方便的使用json格式。
下面一个示例是如何使用Fastjson 把对象或数组转JSON

package com.ohaotian.feifz.style.study.utils;

/**
 * @author feifz
 * @version 1.0.0
 * @Description alibaba fastjson工具类
 * @createTime 2019年06月10日 11:45:00
 */

import com.alibaba.fastjson.JSON;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

class FastJsonTest {
    public static void main(String[] args) {
        // 构建用户geust
        User guestUser = new User();
        guestUser.setName("guest");
        guestUser.setAge(28);
        // 构建用户root
        User rootUser = new User();
        rootUser.setName("root");
        guestUser.setAge(35);
        // 构建用户组对象
        UserGroup group = new UserGroup();
        group.setName("admin");
        group.getUsers().add(guestUser);
        group.getUsers().add(rootUser);
        // 用户组对象转JSON串
        String jsonString = JSON.toJSONString(group);
        System.out.println("jsonString:" + jsonString);
        // JSON串转用户组对象
        UserGroup group2 = JSON.parseObject(jsonString, UserGroup.class);
        System.out.println("group2:" + group2);

        // 构建用户对象数组
        User[] users = new User[2];
        users[0] = guestUser;
        users[1] = rootUser;
        // 用户对象数组转JSON串
        String jsonString2 = JSON.toJSONString(users);
        System.out.println("jsonString2:" + jsonString2);
        // JSON串转用户对象列表
        List<User> users2 = JSON.parseArray(jsonString2, User.class);
        System.out.println("users2:" + users2);
    }
}
@Data
class User {
    private String name;
    private int age;
}
@Data
class UserGroup {
    private String name;
    private List<User> users = new ArrayList<>();
}

输出结果:

jsonString:{"name":"admin","users":[{"age":35,"name":"guest"},{"age":0,"name":"root"}]}  
group2:UserGroup [name=admin, users=[User [name=guest, age=35], User [name=root, age=0]]]  
jsonString2:[{"age":35,"name":"guest"},{"age":0,"name":"root"}]  
users2:[User [name=guest, age=35], User [name=root, age=0]] 

fastjson通过各方面测试都很好,功能性能都是No.1,喜欢,它的源代码质量很高,作者也煞费苦心,将性能做到了最好,全面超越其他的json类库。
通过fastjson我们可以快速进行开发

Fastjson Obejct/Map/JSON/String 互转

fastjson主要的使用入口

Fastjson API入口类是com.alibaba.fastjson.JSON,常用的序列化操作都可以在JSON类上的静态方法直接完成。

public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray 
public static final JSONObject parseObject(String text); // 把JSON文本parse成JSONObject    
public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean 
public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray 
public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合 
public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本 
public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本 
public static final Object toJSON(Object javaObject); 将JavaBean转换为JSONObject或者JSONArray。

有关类库的一些说明

  SerializeWriter:相当于StringBuffer
  JSONArray:相当于List<Object>
  JSONObject:相当于Map<String, Object>
  JSON反序列化没有真正数组,本质类型都是List<Object>

示例代码

package com.ohaotian.feifz.style.study.utils;

/**
 * @author feifz
 * @version 1.0.0
 * @Description fastjson 高级应用
 * @createTime 2019年06月10日 15:43:00
 */

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;
import lombok.Data;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
 * @author feifz
 * @version 1.0.0
 * @Description alibaba fastjson高级应用
 * @createTime 2019年06月10日 11:45:00
 */
public class FastjsonTest {
    private static SerializeConfig mapping = new SerializeConfig();

    static {
        mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
    }

    public static void main(String[] args) {
        Date date = new Date();
        String text = JSON.toJSONString(date, mapping);
        System.out.println(text);
    }

    public static void json2List() {
        /**List -> JSON array*/
        List<Bar> barList = new ArrayList<Bar>();
        barList.add(new Bar());
        barList.add(new Bar());
        barList.add(new Bar());
        String json = JSON.toJSONString(barList);
        System.out.println(json);
        json = JSON.toJSONString(barList, true);
        System.out.println(json);
        /**JSON array -> List*/
        List<Bar> barList1 = JSON.parseArray(json, Bar.class);
        for (Bar bar : barList1) {
            System.out.println(bar.toString());
        }
    }

    public static void json2Map() {
        //Map -> JSON
        Map<String, Bar> map = new HashMap<String, Bar>();
        map.put("a", new Bar());
        map.put("b", new Bar());
        map.put("c", new Bar());
        String json = JSON.toJSONString(map, true);
        System.out.println(json);
        //JSON -> Map
        Map<String, Bar> map1 = (Map<String, Bar>) JSON.parse(json);
        for (String key : map1.keySet()) {
            System.out.println(key + ":" + map1.get(key));
        }
    }

    public static void array2JSON() {
        String[] arr_String = {"a", "b", "c"};
        String json_arr_String = JSON.toJSONString(arr_String, true);
        System.out.println(json_arr_String);
        JSONArray jsonArray = JSON.parseArray(json_arr_String);
        for (Object o : jsonArray) {
            System.out.println(o);
        }
        System.out.println(jsonArray);
    }

    public static void array2JSON2() {
        Bar[] arr_Bar = {new Bar(), new Bar(), new Bar()};
        String json_arr_Bar = JSON.toJSONString(arr_Bar, true);
        System.out.println(json_arr_Bar);
        JSONArray jsonArray = JSON.parseArray(json_arr_Bar);
        for (Object o : jsonArray) {
            System.out.println(o);
        }
        System.out.println(jsonArray);
    }

    public static void map2JSON() {
        Map map = new HashMap();
        map.put("a", "aaa");
        map.put("b", "bbb");
        map.put("c", "ccc");
        String json = JSON.toJSONString(map);
        System.out.println(json);
        Map map1 = JSON.parseObject(json);
        for (Object o : map.entrySet()) {
            Map.Entry<String, String> entry = (Map.Entry<String, String>) o;
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
    }
}

@Data
class Bar {
    public static SerializeConfig mapping = new SerializeConfig();
    private String barName;
    private int barAge;
    private Date barDate = new Date();

    static {
        mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd"));
    }

    {
        Random r = new Random();
        barName = "sss_" + String.valueOf(r.nextFloat());
        barAge = r.nextInt();
    }

    public static void main(String[] args) {
        String x1 = JSON.toJSONString(new Bar(), true);
        System.out.println(x1);
        String x2 = JSON.toJSONString(new Bar(), mapping);
        System.out.println(x2);
    }
}

Fastjson API

  • Fastjson JSONField
  • Fastjson JSONPath
  • Fastjson toJSONString
  • Fastjson writeJSONString
  • Fastjson parseObject
  • Fastjson Api Compare
  • Fastjson API Stream
  • Fastjson API ParseProcess
  • Fastjson API SerializeFilter

Fastjson 常见问题

参考

结语

欢迎关注微信公众号『码仔zonE』,专注于分享Java、云计算相关内容,包括SpringBoot、SpringCloud、微服务、Docker、Kubernetes、Python等领域相关技术干货,期待与您相遇!
工具类-Fastjson入门使用


喜欢 (0)