文章目录
什么是 fastjson?
fastjson 是阿里巴巴的开源 JSON 解析库，它可以解析 JSON 格式的字符串，支持将 Java Bean 序列化为 JSON 字符串，也可以从 JSON 字符串反序列化到 JavaBean。
fastjson 的优点
-
速度快
fastjson 相对其他 JSON 库的特点是快，从 2011 年`fastjson 发布 1.1.x 版本之后，其性能从未被其他 Java 实现的 JSON 库超越。 -
使用广泛
fastjson 在阿里巴巴大规模使用，在数万台服务器上部署，fastjson 在业界被广泛接受。在 2012 年被开源中国评选为最受欢迎的国产开源软件之一。 -
测试完备
fastjson 有非常多的 testcase，在 1.2.11 版本中，testcase 超过 3321 个。每次发布都会进行回归测试，保证质量稳定。 -
使用简单
fastjson 的 API 十分简洁。
String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化
- 功能完备
支持泛型，支持流处理超大文本，支持枚举，支持序列化和反序列化扩展。
准备工作
相关依赖
下载 jar 包：最新版 jar 包下载：1.2.53.jar
或者使用 Maven 引入
<!-- fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>x.x.x</version>
</dependency>
版本号可以通过 Maven Repository 查询，https://mvnrepository.com/
测试实体类
这里使用了lombok插件，不会的可以根据注解的意思，自己加上相应的方法。
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
测试实体类
@Data // get,set
@NoArgsConstructor // 无参构造方法
@AllArgsConstructor // 有参构造方法
public class User implements Serializable {
private String username;
private String password;
private Integer age;
}
自定义 JsonUtils
package cn.tellsea;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.util.List;
import java.util.Map;
@Slf4j
public class JsonUtils {
public static final ObjectMapper mapper = new ObjectMapper();
public static String toString(Object obj) {
if (obj == null) {
return null;
}
if (obj.getClass() == String.class) {
return (String) obj;
}
try {
return mapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
log.error("json序列化出错toString：" + obj, e);
return null;
}
}
public static <T> T toBean(String json, Class<T> tClass) {
try {
return mapper.readValue(json, tClass);
} catch (IOException e) {
log.error("json解析出错toBean：" + json, e);
return null;
}
}
public static <E> List<E> toList(String json, Class<E> eClass) {
try {
return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
} catch (IOException e) {
log.error("json解析出错toList：" + json, e);
return null;
}
}
public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
try {
return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
} catch (IOException e) {
log.error("json解析出错toMap：" + json, e);
return null;
}
}
public static <T> T nativeRead(String json, TypeReference<T> type) {
try {
return mapper.readValue(json, type);
} catch (IOException e) {
log.error("json解析出错nativeRead：" + json, e);
return null;
}
}
}
实际测试案例
这里我直接贴全代码，后面再逐一说明，方便大家参考。
package cn.tellsea;
import com.fasterxml.jackson.core.type.TypeReference;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Map;
public class FastJsonTest {
public static void main(String[] args) {
User user = new User("tellsea", "123456", 20);
// bean转json
String json = JsonUtils.toString(user);
System.out.println(json);
// json转bean
User toBean = JsonUtils.toBean(json, User.class);
System.out.println(toBean);
// json转list
String jsonList = "[" +
"{\"username\":\"tellsea\",\"password\":\"123456\",\"age\":20}, " +
"{\"username\":\"goodtime\",\"password\":\"666888\",\"age\":22}, " +
"{\"username\":\"嘻嘻哈哈\",\"password\":\"999999\",\"age\":18}]";
JsonUtils.toList(jsonList, User.class).forEach(temp -> System.out.println(temp));
// json转map
Map<String, Object> toMap = JsonUtils.toMap(json, String.class, Object.class);
for (Map.Entry<String, Object> entry : toMap.entrySet()) {
System.out.println("key：" + entry.getKey() + ", value" + entry.getValue());
}
// 类型构造器
Map<String, Object> read = JsonUtils.nativeRead(json, new TypeReference<Map<String, Object>>() {
});
for (Map.Entry<String, Object> entry : read.entrySet()) {
System.out.println("key：" + entry.getKey() + ", value" + entry.getValue());
}
}
}
前面第一行代码中new一个 User，后面使用的时候，大家别萌币 o((⊙﹏⊙))o
bena 转 json
String json = JsonUtils.toString(user);
测试结果
{"username":"tellsea","password":"123456","age":20}
json 转 bean
User toBean = JsonUtils.toBean(json, User.class);
测试结果
User(username=tellsea, password=123456, age=20)
json 转 list
String jsonList = "[" +
"{\"username\":\"tellsea\",\"password\":\"123456\",\"age\":20}, " +
"{\"username\":\"goodtime\",\"password\":\"666888\",\"age\":22}, " +
"{\"username\":\"嘻嘻哈哈\",\"password\":\"999999\",\"age\":18}]";
JsonUtils.toList(jsonList, User.class).forEach(temp -> System.out.println(temp));
forEach() 是 jdk1.8 的新特性，你可以直接遍历也行。
测试结果
User(username=tellsea, password=123456, age=20)
User(username=goodtime, password=666888, age=22)
User(username=嘻嘻哈哈, password=999999, age=18)
json 转 map
Map<String, Object> toMap = JsonUtils.toMap(json, String.class, Object.class);
for (Map.Entry<String, Object> entry : toMap.entrySet()) {
System.out.println("key：" + entry.getKey() + ", value" + entry.getValue());
}
测试结果
key：username, value：tellsea
key：password, value：123456
key：age, value：20
类型构造器
通过传入不同的类型，将结果解析为相对应的类型，这里我测试了两种。
测试 json 转 bean
User read1 = JsonUtils.nativeRead(json, new TypeReference<User>() {
});
测试结果
User(username=tellsea, password=123456, age=20)
实体类对象转为键值对的形式
Map<String, Object> read = JsonUtils.nativeRead(json, new TypeReference<Map<String, Object>>() {
});
for (Map.Entry<String, Object> entry : read.entrySet()) {
System.out.println("key：" + entry.getKey() + ", value" + entry.getValue());
}
测试结果
key：username, value：tellsea
key：password, value：123456
key：age, value：20
相关链接
- Fastjson 源码地址：https://github.com/alibaba/fastjson
- Fastjson 中文 Wiki：https://github.com/alibaba/fastjson/wiki/Quick-Start-CN
微信公众号
