概述
Fastjson是一个高性能的Java JSON库，由阿里巴巴集团开发和维护。
Fastjson提供了一种简单而强大的方式来处理JSON数据，包括序列化、反序列化和操作JSON对象。它利用Java自带的反射机制来解析JSON字符串，可以将JSON字符串转换成Java对象，或者将Java对象转换成JSON字符串。
注意事项
- 安全性问题：尽管Fastjson在性能上表现出色，但在处理JSON数据时仍需要注意安全性问题。特别是其AutoType功能的安全性问题较为突出，因此在使用时需要谨慎。
- 版本更新：由于Fastjson是一个不断更新的库，因此建议定期查看其官方文档或更新日志，以了解最新的功能和修复的安全漏洞。
综上所述，Fastjson是一个功能强大、性能卓越的Java JSON库。它提供了简单易用的API和丰富的功能特性，使得开发者能够高效地处理JSON数据。然而，在使用时也需要注意其安全性问题和版本更新情况。
主要特点
快速高效：Fastjson是目前Java中速度最快的JSON处理库之一，具有较快的序列化和反序列化速度。
简单易用：Fastjson提供了简单易用的API，使得使用者可以快速上手并进行JSON的处理。它支持复杂对象的处理，包括嵌套对象、集合、Map等，并且可以处理多种数据类型，包括基本数据类型、自定义对象等。
支持注解：Fastjson支持使用注解来指定Java对象与JSON字符串之间的映射关系，从而更加灵活地控制对象的转换。
自定义序列化和反序列化：Fastjson允许用户自定义实现对象的序列化和反序列化过程，可以通过实现Serializer和Deserializer接口来实现。
流式API：Fastjson提供了流式的API，可以在处理大量JSON数据时提供更好的性能。
广泛应用：Fastjson已经被广泛应用于各种Java项目中，包括大型的企业级应用和小型的个人项目。
应用场景
- 数据传输与存储：Fastjson可以将Java对象转换成JSON字符串进行数据传输和存储。这在前后端交互、跨系统数据传输等场景中非常常见。
- API开发与数据解析：Fastjson可以快速将JSON字符串解析为Java对象，方便在API开发中进行处理和操作。
- 对象序列化与反序列化：Fastjson提供了高效的对象序列化和反序列化功能，这对于分布式系统中的消息传递或者缓存存储等场景非常有用。
核心类和方法
JSON类：
toJSONString(Object object)：将Java对象序列化为JSON字符串。
parseObject(String text)：将JSON字符串解析为JSONObject。
parseObject(String text, Class clazz)：将JSON字符串解析为指定类型的Java对象。
parseArray(String text)：将JSON字符串解析为JSONArray。
parseArray(String text, Class clazz)：将JSON字符串解析为指定类型的Java对象集合。
- JSONObject类：
继承自JSON类，实现了Map接口，因此其底层操作是由Map实现的。它代表了一个JSON对象，其中的数据以键值对的形式出现。 - JSONArray类：
同样继承自JSON类，代表了一个JSON对象数组。
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 parseObject(String text, Class clazz); // 把JSON文本parse为JavaBean
public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
public static final List parseArray(String text, Class 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
JSONObject：相当于Map<String, Object>
JSON反序列化没有真正数组，本质类型都是List
fastjson还有很多很高级的特性，比如支持注解、支持全类型序列化，这些都是很好的特性，功能强大
实体类或集合转JSON串
String besnString = JSONObject.toJSONString(实体类);
JSON串转JSONObject
JSONObject jsonObject = JSONObject.parseObject(jsonString);
JSON串转实体类
体类 javaBean = JSON.parseObject(json, 实体类.class);
JSON串转带泛型的List的集合
List<实体类或其他泛型> list = JSON.parseObject(json, new TypeReference<List<实体类或其他泛型>>(){});
package jsonTest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
public class MyJson {
public static void main(String[] args) {
List<Student> list=new ArrayList<>();
Student student=new Student("bob",24);
Student student12=new Student("lily", 23);
list.add(student);
list.add(student12);
System.out.println("*******javaBean to jsonString*******");
String str1=JSON.toJSONString(student);
System.out.println(str1);
System.out.println(JSON.toJSONString(list));
System.out.println();
System.out.println("******jsonString to javaBean*******");
//Student stu1=JSON.parseObject(str1,new TypeReference<Student>(){});
Student stu1=JSON.parseObject(str1,Student.class);
System.out.println(stu1);
System.out.println();
System.out.println("******javaBean to jsonObject******");
JSONObject jsonObject1=(JSONObject)JSON.toJSON(student);
System.out.println(jsonObject1.getString("name"));
System.out.println();
System.out.println("******jsonObject to javaBean******");
Student student2=JSON.toJavaObject(jsonObject1, Student.class);
System.out.println(student2);
System.out.println();
System.out.println("*******javaBean to jsonArray******");
List<Student> stulist=new ArrayList<>();
for(int i=0;i<5;i++){
stulist.add(new Student("student"+i, i));
}
JSONArray jsonArrays=(JSONArray)JSON.toJSON(stulist);
for(int i=0;i<jsonArrays.size();i++){
System.out.println(jsonArrays.getJSONObject(i));
}
System.out.println();
System.out.println("*****jsonArry to javalist******");
List<Student> myList=new ArrayList<>();
for(int i=0;i<jsonArrays.size();i++){
Student student3=JSON.toJavaObject(jsonArrays.getJSONObject(i), Student.class);
myList.add(student3);
}
for(Student stu:myList){
System.out.println(stu);
}
System.out.println();
System.out.println("*****jsonObject to jsonString*****");
String str4=JSON.toJSONString(jsonObject1);
System.out.println(str4);
System.out.println();
System.out.println("*******jsonString to jsonObject*****");
JSONObject jso1=JSON.parseObject(str1);
System.out.println(jso1.getString("name"));
System.out.println();
System.out.println("*****jsonString to jsonArray*****");
JSONArray jArray=JSON.parseArray(JSON.toJSONString(stulist));
for(int i=0;i<jArray.size();i++){
System.out.println(jArray.getJSONObject(i));
}
System.out.println();
}
}
JSONObject
JSONObject jsonObject = new JSONObject();
jsonObject.put("TRADE_TYPE", "0110");
jsonObject.put("DECLARE_NUMBER", null);
jsonObject.put("COMPANY_NAME", null);
jsonObject.put("GOODS_TOTAL_AMOUNT", "4500.23000");
jsonObject.put("GOODS_TOTAL_WEIGHT", "1222.000");
jsonObject.put("PLATE_NUMBER", "浙B-12345");
jsonObject.put("IN_OUT_FLAG", "I");
jsonObject.put("YARD_IN_OUT_FLAG", "I");
jsonObject.put("DECLARE_TIME", null);
jsonObject.put("PASS_TIME", "2023-08-13 10:44:59");
JSONObject item = new JSONObject();
item.put("NAME", "尿不湿xx");
item.put("CODE", "3100002344");
item.put("WEIGHT", "1222.000");
item.put("AMOUNT", "4500.23000");
JSONObject item2 = new JSONObject();
item2.put("NAME", "哈哈");
item2.put("CODE", "3100002344");
item2.put("WEIGHT", "1222.000");
item2.put("AMOUNT", "4500.23000");
JSONArray itemsArray = new JSONArray();
itemsArray.add(item);
itemsArray.add(item2);
jsonObject.put("ITEMS", itemsArray);
rabbitmqService.sendObjectMessage(TRADE_DATA_TO_SHENGSHI,jsonObject);
String jsonString = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
// 获取字符串值
String name = jsonObject.getString("name");
if (name != null && !name.isEmpty()) {
System.out.println("Name: " + name);
}
// 获取整数值
Integer age = jsonObject.getInteger("age");
if (age != null) {
System.out.println("Age: " + age);
}
// 获取布尔值
Boolean isStudent = jsonObject.getBoolean("isStudent");
if (isStudent != null) {
System.out.println("Is Student: " + isStudent);
}
// 判断某个字段是否存在
if (jsonObject.containsKey("city")) {
String city = jsonObject.getString("city");
System.out.println("City: " + city);
}
}
Fastjson实体对象转换为 Map
public static Map<String, Object> object2Map(Object obj) {
//1.fastjson
String objJSON = JSONObject.toJSONString(obj);
if (null == objJSON) {
log.warn("invalid obj");
return null;
}
return JSONObject.parseObject(objJSON, new TypeReference<Map<String, Object>>() {});
Fastjson 是一个 Java 的 JSON 库，提供了丰富的功能来处理 JSON 数据。当使用 Fastjson 进行字符串到 Map 对象的转换时，它的底层原理如下：
- 解析：Fastjson 会先将 JSON 字符串解析成 JSON Token 流。JSON Token 是 Fastjson 内部定义的一种数据格式，它表示了 JSON 字符串中的各个元素，比如对象、数组、键值对等。
- 生成 Map 对象：在解析过程中，当 Fastjson 遇到 JSON 对象时，它会创建一个空的 Map 对象。然后，解析器会遍历 JSON 对象中的键值对，将键值对的键和值依次添加到这个 Map 对象中。
- 数据类型转换：Fastjson 会根据 JSON 中的值的类型，在 Map 对象中使用相应的 Java 对象来表示这些值。比如，JSON 中的数值将被转换为 Java 中的 Double、Long 等数值类型，字符串将被转换为 Java 中的 String 类型。
- 嵌套对象处理：如果 JSON 对象中存在嵌套的 JSON 对象或者数组，Fastjson 会递归地将其转换为对应的嵌套 Map 对象或者 List 对象，并将这些对象作为值添加到父级 Map 对象中。
总结来说，Fastjson 的字符串到 Map 对象的转换原理是通过解析 JSON 字符串得到 JSON Token 流，然后根据解析过程中的规则，创建对应的 Map 对象，并将 JSON 中的键值对添加到 Map 中。
在 Fastjson 中，将实体对象转换为 Map 对象时可能会比较慢的原因主要有以下几点： - 反射开销：Fastjson 在实体对象转换为 Map 对象时，会使用反射机制来获取实体对象的属性信息并将其转换为键值对。反射操作通常比较耗时，特别是当实体对象的结构复杂或属性数量较多时，会增加反射操作的开销。
- 类型处理：在实体对象转换为 Map 对象时，Fastjson 需要处理各种数据类型的转换。这涉及到类型判断、类型转换以及相关的逻辑处理，这些操作可能会增加转换的时间成本。
- 嵌套对象处理：如果实体对象中存在嵌套的对象或集合，Fastjson 需要递归地进行转换操作，这可能导致转换时间的增加。尤其是当嵌套层级较深或者嵌套对象比较复杂时，转换速度可能会更慢。
- 特殊字段处理：有些实体对象中可能含有特殊字段，例如静态字段、transient 字段等，这些字段可能需要额外的处理逻辑来决定是否需要将其包含在 Map 对象中，这也可能导致转换时间的延长。
为了提高性能，你可以尝试以下优化方法： - 使用指定字段的转换：通过使用 Fastjson 提供的 @JSONField 注解，指定需要被转换的字段，避免不必要的字段转换操作。
- 简化实体对象结构：如果可能的话，尽量简化实体对象的结构，减少属性数量和嵌套层级，以降低转换的复杂度和耗时。
- 使用缓存：在多次转换同一个实体对象时，可以考虑将转换结果进行缓存，避免重复的转换操作。
- 考虑其他 JSON 库：如果性能要求较高，可以尝试其他 JSON 库，比如 Jackson、Gson 等，看是否能够满足你的需求。
需要注意的是，并非所有情况下都能得到显著的性能提升，具体的优化策略需要根据实际情况进行评估和调整。
fastjson和fastjson2的区别
FastJSON是一种广泛使用的JSON解析库，其高性能和简单易用的特点受到开发者的喜爱。然而，随着应用场景的复杂化和安全要求的提高，FastJSON逐渐暴露出一些问题。为了解决这些问题并进一步提升性能和安全性，阿里巴巴推出了FastJSON2。以下是FastJSON和FastJSON2的详细对比：
一、性能
FastJSON：以其快速高效著称，可以快速地将Java对象转换为JSON字符串，也可以将JSON字符串转换为Java对象。
FastJSON2：在性能上进行了多方面的优化，通过优化序列化算法和数据结构，提高了序列化的效率，减少了不必要的对象创建和复制操作，从而降低了CPU和内存的开销。同时，对解析器进行了重构，使其能够更快速地处理大规模JSON数据。根据官方提供的性能测试数据，FastJSON2的性能远超其他流行的JSON库，如Jackson、Gson和org.json。
二、安全性
FastJSON：在安全性方面存在一些漏洞，特别是其AutoType功能的安全性问题较为突出。该功能在序列化的JSON字符串中带上类型信息，在反序列化时不需要传入类型，实现自动类型识别，但这也为恶意攻击提供了可能。
FastJSON2：在安全性方面做了显著改进，针对之前版本中暴露的一些安全漏洞进行了修复。为了防止反序列化漏洞，FastJSON2引入了更严格的黑名单机制，默认禁止了某些危险类型的反序列化操作。同时，增强了类型检测机制，可以更好地防止恶意数据的注入，确保数据解析的安全性。此外，FastJSON2的AutoType功能必须显式打开才能使用，且没有任何白名单，也不包括任何Exception类的白名单，这进一步提高了其安全性。
三、功能特性
FastJSON：支持复杂对象的处理，包括嵌套对象、集合、Map等；支持注解来指定Java对象与JSON字符串之间的映射关系；允许用户自定义实现对象的序列化和反序列化过程；提供了流式的API，可以在处理大量JSON数据时提供更好的性能。
FastJSON2：在FastJSON的基础上增加了一系列新的功能特性。例如，对JSONPath的支持更加全面和高效，允许开发者使用JSONPath表达式方便地访问和操作JSON数据；改进了对日期和时间的处理，提供了更多的配置选项和更好的性能，支持多种日期格式和时区处理；提供了对JSON Schema的支持，增强了数据验证的能力；新增加对二进制格式JSONB的支持，进一步提升了数据处理的效率和灵活性。
四、兼容性
FastJSON：作为早期版本的JSON处理库，已经被广泛应用于各种Java项目中。
FastJSON2：在保持与FastJSON兼容性的同时，也进行了一些必要的改进和优化。例如，FastJSON2支持最新的JDK特性，包括JDK 11和JDK 17等；同时提供了对Kotlin语言的优化支持，使得Kotlin开发者能够更加便捷地使用FastJSON2。此外，FastJSON2还支持跨平台兼容性，包括Android 8+等平台。
五、易用性
FastJSON：提供了简单明了的API，使用起来非常方便。
FastJSON2：对部分API进行了调整和优化，使其更加直观和易用。同时提供了更详细和友好的错误提示信息，帮助开发者更快地定位和解决问题。
综上所述，FastJSON2在性能、安全性、功能特性、兼容性和易用性等方面相比FastJSON都有显著的提升。对于需要高性能JSON解析和序列化的应用场景，特别是在安全性要求较高的情况下，FastJSON2是一个更好的选择。
扫一扫
6528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
