程序员最近都爱上了这个网站  程序员们快来瞅瞅吧!  it98k网:it98k.com

本站消息

站长简介/公众号

  出租广告位,需要合作请联系站长


+关注
已关注

分类  

暂无分类

标签  

暂无标签

日期归档  

fastjson类库学习

发布于2020-11-19 20:16     阅读(850)     评论(0)     点赞(20)     收藏(2)


 

1、什么是fastjson?

2、使用思路

3、关键概念介绍

3.1 fastjson主要的使用入口

3.2、有关类库的一些说明

4、重点使用场景

4.1 序列化

一个javabean对象 序列化为JSON字符串

将Javabean对象序列化为JSON字符串,返回JSON字符串的utf-8 bytes

将Javabean对象序列化为JSON字符串,写入到Writer中

将Javabean对象序列化为JSON字符串,按UTF-8编码写入到OutputStream中

4.2 反序列化

将json字符串 反序列化为 JSONObject对象

将json字符串 反序列为 普通javabean对象模型

将json字符串反序列化为泛型类型的javabean

4.3 日期

4.4 Fastjson 对象或数组转JSON

4.5 Fastjson Obejct/Map/JSON/String 互转

list<----->json

map<---->json

array---->json

4.6 其他常用API及方法

遍历JSONArray

  1. 1、什么是fastjson?
  2. fastjson是阿里巴巴的开源JSON解析库,它可以解析JSON格式的字符串,支持将Java Bean序列化为JSON字符串,也可以从JSON字符串反序列化到JavaBean。
  3. 系统学习:
  4. https://www.w3cschool.cn/fastjson/fastjson-jsonpath.html
  5. 2、使用思路
  6. 序列化
  7. String jsonString = JSON.toJSONString(obj); //序列化,各种对象 ----> json格式的字符串
  8. 反序列化
  9. VO vo = JSON.parseObject("{...}", VO.class); //反序列化 各种对象 <---- json格式的字符串
  10. VO vo = JSON.parseArray("{...}", VO.class);
  11. 3、关键概念介绍
  12. 3.1 fastjson主要的使用入口
  13. Fastjson API入口类是com.alibaba.fastjson.JSON,常用的序列化操作都可以在JSON类上的静态方法直接完成。
  14. public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray
  15. public static final JSONObject parseObject(String text); // 把JSON文本parse成JSONObject
  16. public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean
  17. public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
  18. public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合
  19. public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本
  20. public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本
  21. public static final Object toJSON(Object javaObject); 将JavaBean转换为JSONObject或者JSONArray。
  22. 3.2、有关类库的一些说明
  23. SerializeWriter:相当于StringBuffer
  24. JSONArray:相当于List<Object>
  25. JSONObject:相当于Map<String, Object>
  26. JSON反序列化没有真正数组,本质类型都是List<Object>
  27. JSONJSON是一个抽象类,该类实现了JSONAware(转为json串)和JSONStreamAware(将json串写入Appendable中)的接口,同时又是JSONArray(内部实现就是个List)和JSONObject(内部实现就是个Map)的父类。
  28. JSONObject:json对象,是JSON字符串与pojo对象转换过程中的中间表达类型,实现了Map接口,可以看做是一个模拟JSON对象键值对再加上多层嵌套的数据集合,对象的每一个基本类型属性是map里的一个key-value,一个非基本类型属性是一个嵌套的JSONObject对象(key是属性名称,value是表示这个属性值的对象的JSONObject)。
  29. 详细介绍参考:
  30. https://github.com/alibaba/fastjson/wiki/JSON_API_cn#parse-pojo-generic
  31. 4、重点使用场景
  32. 4.1 序列化
  33. 一个javabean对象 序列化为JSON字符串
  34. Model model = ...;
  35. String jsonStr = JSON.toJSONString(model);
  36. User user = new User();
  37. user.setName("校长");
  38. user.setAge(3);
  39. user.setSalary(new BigDecimal("123456789.0123"));
  40. String jsonString = JSON.toJSONString(user);
  41. System.out.println(jsonString);
  42. // 输出 {"age":3,"name":"校长","old":false,"salary":123456789.0123}
  43. 将Javabean对象序列化为JSON字符串,返回JSON字符串的utf-8 bytes
  44. import com.alibaba.fastjson.JSON;
  45. Model model = ...;
  46. byte[] jsonBytes = JSON.toJSONBytes(model);
  47. 将Javabean对象序列化为JSON字符串,写入到Writer中
  48. import com.alibaba.fastjson.JSON;
  49. Model model = ...;
  50. Writer writer = ...;
  51. JSON.writeJSONString(writer, model);
  52. 将Javabean对象序列化为JSON字符串,按UTF-8编码写入到OutputStream中
  53. import com.alibaba.fastjson.JSON;
  54. Model model = ...;
  55. OutputStream os;
  56. JSON.writeJSONString(os, model);
  57. 4.2 反序列化
  58. 将json字符串 反序列化为 JSONObject对象
  59. JSONObject jsonObj = JSON.parseObject(jsonStr);
  60. 将json字符串 反序列为 普通javabean对象模型
  61. Model model = JSON.parseObject(jsonStr, Model.class);
  62. Model model = JSON.parseArray(jsonStr, MOdel.class);
  63. //例子如下
  64. String jsonString = "{\"age\":3,\"birthdate\":1496738822842,\"name\":\"校长\",\"old\":true,\"salary\":123456789.0123}";
  65. User u = JSON.parseObject(jsonString ,User.class);
  66. System.out.println(u.getName());
  67. // 输出 校长
  68. String jsonStringArray = "[{\"age\":3,\"birthdate\":1496738822842,\"name\":\"校长\",\"old\":true,\"salary\":123456789.0123}]";
  69. List<User> userList = JSON.parseArray(jsonStringArray, User.class);
  70. System.out.println(userList.size());
  71. // 输出 1
  72. 将json字符串反序列化为泛型类型的javabean
  73. Type type = new TypeReference<List<Model>>() {}.getType();
  74. List<Model> list = JSON.parseObject(jsonStr, type);
  75. 4.3 日期
  76. Fastjson 处理日期的API很简单,例如:
  77. JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd HH:mm:ss.SSS")
  78. 使用ISO-8601日期格式
  79. JSON.toJSONString(obj, SerializerFeature.UseISO8601DateFormat);
  80. 全局修改日期格式
  81. JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd";
  82. JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);
  83. 反序列化能够自动识别如下日期格式:
  84. ISO-8601日期格式
  85. yyyy-MM-dd
  86. yyyy-MM-dd HH:mm:ss
  87. yyyy-MM-dd HH:mm:ss.SSS
  88. 毫秒数字
  89. 毫秒数字字符串
  90. .NET JSON日期格式
  91. new Date(198293238)
  92. 4.4 Fastjson 对象或数组转JSON
  93. 在日志解析,前后端数据传输交互中,经常会遇到 String 与 map、json、xml 等格式相互转换与解析的场景,其中 json 基本成为了跨语言、跨前后端的事实上的标准数据交互格式。应该来说各个语言中 解析 json 的库都一大片(具体 json 格式与三方库的介绍请见: http://www.json.org/json-zh.html ),比如 python 都集成在了内置库中,成为标准 API,今天我们要聊的是 java 中如何方便的使用 json 格式。
  94. package test;
  95. import java.util.ArrayList;
  96. import java.util.List;
  97. import com.alibaba.fastjson.JSON;
  98. class User {
  99. private String name;
  100. private int age;
  101. public String getName() {
  102. return name;
  103. }
  104. public void setName(String name) {
  105. this.name = name;
  106. }
  107. public int getAge() {
  108. return age;
  109. }
  110. public void setAge(int age) {
  111. this.age = age;
  112. }
  113. @Override
  114. public String toString() {
  115. return "User [name=" + name + ", age=" + age + "]";
  116. }
  117. };
  118. class UserGroup {
  119. private String name;
  120. private List<User> users = new ArrayList<User>();
  121. public String getName() {
  122. return name;
  123. }
  124. public void setName(String name) {
  125. this.name = name;
  126. }
  127. public List<User> getUsers() {
  128. return users;
  129. }
  130. public void setUsers(List<User> users) {
  131. this.users = users;
  132. }
  133. @Override
  134. public String toString() {
  135. return "UserGroup [name=" + name + ", users=" + users + "]";
  136. }
  137. }
  138. class FastJsonTest {
  139. public static void main(String[] args) {
  140. // 构建用户geust
  141. User guestUser = new User();
  142. guestUser.setName("guest");
  143. guestUser.setAge(28);
  144. // 构建用户root
  145. User rootUser = new User();
  146. rootUser.setName("root");
  147. guestUser.setAge(35);
  148. // 构建用户组对象
  149. UserGroup group = new UserGroup();
  150. group.setName("admin");
  151. group.getUsers().add(guestUser);
  152. group.getUsers().add(rootUser);
  153. // 用户组对象转JSON串
  154. String jsonString = JSON.toJSONString(group);
  155. System.out.println("jsonString:" + jsonString);
  156. // JSON串转用户组对象
  157. UserGroup group2 = JSON.parseObject(jsonString, UserGroup.class);
  158. System.out.println("group2:" + group2);
  159. // 构建用户对象数组
  160. User[] users = new User[2];
  161. users[0] = guestUser;
  162. users[1] = rootUser;
  163. // 用户对象数组转JSON串
  164. String jsonString2 = JSON.toJSONString(users);
  165. System.out.println("jsonString2:" + jsonString2);
  166. // JSON串转用户对象列表
  167. List<User> users2 = JSON.parseArray(jsonString2, User.class);
  168. System.out.println("users2:" + users2);
  169. }
  170. }
  171. //输出结果:
  172. jsonString:{"name":"admin","users":[{"age":35,"name":"guest"},{"age":0,"name":"root"}]}
  173. group2:UserGroup [name=admin, users=[User [name=guest, age=35], User [name=root, age=0]]]
  174. jsonString2:[{"age":35,"name":"guest"},{"age":0,"name":"root"}]
  175. users2:[User [name=guest, age=35], User [name=root, age=0]]
  176. 4.5 Fastjson Obejct/Map/JSON/String 互转
  177. list<----->json
  178. public static void json2List(){
  179. //List -> JSON array
  180. List<Bar> barList = new ArrayList<Bar>();
  181. barList.add(new Bar());
  182. barList.add(new Bar());
  183. barList.add(new Bar());
  184. String json= JSON.toJSONString(barList, true);
  185. System.out.println(json);
  186. //JSON array -> List
  187. List<Bar> barList1 = JSON.parseArray(json,Bar.class);
  188. for (Bar bar : barList1) {
  189. System.out.println(bar.toString());
  190. }
  191. }
  192. map<---->json
  193. public static void map2JSON(){
  194. Map map = new HashMap();
  195. map.put("a","aaa");
  196. map.put("b","bbb");
  197. map.put("c","ccc");
  198. String json=JSON.toJSONString(map);
  199. System.out.println(json);
  200. Map map1 = JSON.parseObject(json);
  201. for (Object o : map.entrySet()) {
  202. Map.Entry<String,String> entry = (Map.Entry<String,String>)o;
  203. System.out.println(entry.getKey()+"--->"+entry.getValue());
  204. }
  205. }
  206. public static void json2Map(){
  207. //Map -> JSON
  208. Map<String,Bar> map = new HashMap<String, Bar>();
  209. map.put("a",new Bar());
  210. map.put("b",new Bar());
  211. map.put("c",new Bar());
  212. String json = JSON.toJSONString(map,true);
  213. System.out.println(json);
  214. //JSON -> Map
  215. Map<String,Bar> map1 = (Map<String,Bar>)JSON.parse(json);
  216. for (String key : map1.keySet()) {
  217. System.out.println(key+":"+map1.get(key));
  218. }
  219. }
  220. array---->json
  221. public static void array2JSON(){
  222. String[] arr_String = {"a","b","c"};
  223. String json_arr_String = JSON.toJSONString(arr_String,true);
  224. System.out.println(json_arr_String);
  225. JSONArray jsonArray = JSON.parseArray(json_arr_String);
  226. for (Object o : jsonArray) {
  227. System.out.println(o);
  228. }
  229. System.out.println(jsonArray);
  230. }
  231. public static void array2JSON2(){
  232. Bar[] arr_Bar = {new Bar(),new Bar(),new Bar()};
  233. String json_arr_Bar = JSON.toJSONString(arr_Bar,true);
  234. System.out.println(json_arr_Bar);
  235. JSONArray jsonArray = JSON.parseArray(json_arr_Bar);
  236. for (Object o : jsonArray) {
  237. System.out.println(o);
  238. }
  239. System.out.println(jsonArray);
  240. }
  241. 4.6 其他常用API及方法
  242. 遍历JSONArray
  243. 第一种for循环
  244. JSONArray seriesArr = new JSONArray();
  245. for(int i=0;i<seriesArr .size();i++){
  246. JSONObject object = eggsArr.getJSONObject(i);
  247. }
  248. 第二种for增强
  249. JSONArray pzListArr = new JSONArray();
  250. for (Object obj:pzListArr) {
  251. JSONObject dataObj = JSONObject.parseObject(obj.toString());
  252. }

 

原文链接:https://blog.csdn.net/lucyshimeiling/article/details/109747301



所属网站分类: 技术文章 > 博客

作者:小胖子爱java

链接:http://www.javaheidong.com/blog/article/900/6e1eedf0bcd5a2a8490b/

来源:java黑洞网

任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任

20 0
收藏该文
已收藏

评论内容:(最多支持255个字符)