fastjson使用总给

最新推荐文章于 2023-06-19 14:27:57 发布
最新推荐文章于 2023-06-19 14:27:57 发布
阅读量107 收藏
点赞数
分类专栏： Java学习 文章标签： json
原文链接：https://dmego.cn/2018/05/13/using-fastjson
版权

fastjson 的使用总结 - Dmego - 博客园

前言

最近在开发过程中使用了大量的json作为前后端数据交换的方式,由于之前没有对json做过系统的学习,所有在使用过程中查阅了大量的文档与资料,这里主要记录了我在开发后对json以及fastjson使用的总结

JSON 介绍

JSON(javaScript Object Notation)是一种轻量级的数据交换格式。主要采用键值对({"name": "json"})的方式来保存和表示数据。JSON是JS对象的字符串表示法，它使用文本表示一个JS对象的信息，本质上是一个字符串。更多简介见介绍JSON。

fastjson 简介

在日志解析,前后端数据传输交互中,经常会遇到字符串(String)与json,XML等格式相互转换与解析，其中json以跨语言，跨前后端的优点在开发中被频繁使用，基本上可以说是标准的数据交换格式。fastjson是一个java语言编写的高性能且功能完善的JSON库，它采用一种“假定有序快速匹配”的算法，把JSON Parse 的性能提升到了极致。它的接口简单易用，已经被广泛使用在缓存序列化，协议交互，Web输出等各种应用场景中。

fastjson 常用 API

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

1
2
3
4
5
6
7
8

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。

使用方法举例

1
2
3

//将JSON文本转换为java对象
import com.alibaba.fastjson.JSON;
Model model = JSON.parseObject(jsonStr, Model.class);

有关类库的一些说明

  • JSONArray : 相当于 List<Object>
  • JSONObject: 相当于 Map<String,Object>

fastjson 使用实例

java对象与JSON字符串的互转

User测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/**
 * User测试类
 * @author dmego
 */
public class User {
	private String username;
	private String password;
	public User(){}
	public User(String username,String password){
		this.username = username;
		this.password = password;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
    @Override
	public String toString() {
		return "User [username=" + username + ", password=" + password + "]";
	}
}

UserGroup测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

/**
 * 用户组测试类
 * @author dmego
 *
 */
public class UserGroup {
	private String name;  
    private List<User> users = new ArrayList<User>();
    public UserGroup(){}
    public UserGroup(String name,List<User> users){
    	this.name = name;
    	this.users = users;
    }
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<User> getUsers() {
		return users;
	}
	public void setUsers(List<User> users) {
		this.users = users;
	}
	@Override
	public String toString() {
		return "UserGroup [name=" + name + ", users=" + users + "]";
	}  
}

fastJson测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package demo;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.alibaba.fastjson.JSON;

/**
 * fastJson测试类
 * @author dmego
 *
 */
public class TestFastJosn {
	/**
	 * java对象转 json字符串 
	 */
	@Test
	public void objectTOJson(){
		//简单java类转json字符串
		User user = new User("dmego", "123456");
		String UserJson = JSON.toJSONString(user);
		System.out.println("简单java类转json字符串:"+UserJson);
		
		//List<Object>转json字符串
		User user1 = new User("zhangsan", "123123");
		User user2 = new User("lisi", "321321");
		List<User> users = new ArrayList<User>();
		users.add(user1);
		users.add(user2);
		String ListUserJson = JSON.toJSONString(users);
		System.out.println("List<Object>转json字符串:"+ListUserJson);	
		
		//复杂java类转json字符串
		UserGroup userGroup = new UserGroup("userGroup", users);
		String userGroupJson = JSON.toJSONString(userGroup);
		System.out.println("复杂java类转json字符串:"+userGroupJson);		
		
	}
	
	/**
	 * json字符串转java对象
	 * 注：字符串中使用双引号需要转义 (" --> \"),这里使用的是单引号
	 */
	@Test
	public void JsonTOObject(){
		/* json字符串转简单java对象
	     * 字符串：{"password":"123456","username":"dmego"}*/
		
		String jsonStr1 = "{'password':'123456','username':'dmego'}";
		User user = JSON.parseObject(jsonStr1, User.class);
		System.out.println("json字符串转简单java对象:"+user.toString());
		
		/*
		 * json字符串转List<Object>对象
		 * 字符串：[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]
		 */
		String jsonStr2 = "[{'password':'123123','username':'zhangsan'},{'password':'321321','username':'lisi'}]";
		List<User> users = JSON.parseArray(jsonStr2, User.class);
		System.out.println("json字符串转List<Object>对象:"+users.toString());
			
		/*json字符串转复杂java对象
		 * 字符串：{"name":"userGroup","users":[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]}
		 * */
		String jsonStr3 = "{'name':'userGroup','users':[{'password':'123123','username':'zhangsan'},{'password':'321321','username':'lisi'}]}";
		UserGroup userGroup = JSON.parseObject(jsonStr3, UserGroup.class);
		System.out.println("json字符串转复杂java对象:"+userGroup);	
	}
}

输出结果

1
2
3
4
5
6
7

简单java类转json字符串:{"password":"123456","username":"dmego"}
List<Object>转json字符串:[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]
复杂java类转json字符串:{"name":"userGroup","users":[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]}

json字符串转简单java对象:User [username=dmego, password=123456]
json字符串转List<Object>对象:[User [username=zhangsan, password=123123], User [username=lisi, password=321321]]
json字符串转复杂java对象:UserGroup [name=userGroup, users=[User [username=zhangsan, password=123123], User [username=lisi, password=321321]]]

fastjson 解析复杂嵌套json字符串

这个实例是我在开发中用到的，先给出要解析的json字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

[
    {
        "id": "user_list",
        "key": "id",
        "tableName": "用户列表",
        "className": "cn.dmego.domain.User",
        "column": [
            {
                "key": "rowIndex",
                "header": "序号",
                "width": "50",
                "allowSort": "false"
            },
            {
                "key": "id",
                "header": "id",
                "hidden": "true"
            },
            {
                "key": "name",
                "header": "姓名",
                "width": "100",
                "allowSort": "true"
            }
        ]
    },
    {
        "id": "role_list",
        "key": "id",
        "tableName": "角色列表",
        "className": "cn.dmego.domain.Role",
        "column": [
            {
                "key": "rowIndex",
                "header": "序号",
                "width": "50",
                "allowSort": "false"
            },
            {
                "key": "id",
                "header": "id",
                "hidden": "true"
            },
            {
                "key": "name",
                "header": "名称",
                "width": "100",
                "allowSort": "true"
            }
        ]
    }
]

要想解析这种复杂的字符串，首先得先定义好与之相符的java POJO 对象，经过观察，我们发现，这个是一个json对象数组，每一个对象里包含了许多属性，其中还有一个属性的类型也是对象数组。所有，我们从里到外，先定义最里面的对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Column {
	private String key;
	private String header;
	private String width;
	private String allowSort;
	private String hidden;
	
	public String getKey() {
		return key;
	}
	public void setKey(String key) {
		this.key = key;
	}
    //这里省略部分getter与setter方法	
}

再定义外层的对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import java.util.List;
import org.apache.commons.collections4.map.LinkedMap;

public class Query {
	private String id;
	private String key;
	private String tableName;
	private String className;
    private List<LinkedMap<String, Object>> column; 
    private List<Column> columnList;
    
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
    //这里省略部分getter与setter方法	
	public List<LinkedMap<String, Object>> getColumn() {
		return column;
	}
	public void setColumn(List<LinkedMap<String, Object>> column) {
		this.column = column;
	}
	public List<Column> getColumnList() {
		return columnList;
	}
	public void setColumnList(List<Column> columnList) {
		this.columnList = columnList;
	}
}

我的这个json文件放置在类路径下，最后想将这个json字符串转化为List对象，并且将column 对象数组转化为query对象里的List属性
而实际转化过程中，fastjson将column对象数组转化为List;所有我们还需要将Map类型转化为object类型才能满足需求。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

   /**
 * 读取类路径下的配置文件
 * 解析成对象数组并返回
 * @throws IOException
 */
@Test
public List<Query> test() throws IOException {
	// 读取类路径下的query.json文件
	ClassLoader cl = this.getClass().getClassLoader();
	InputStream inputStream = cl.getResourceAsStream("query.json");
	String jsontext = IOUtils.toString(inputStream, "utf8");
	// 先将字符jie串转为List数组
	List<Query> queryList = JSON.parseArray(jsontext, Query.class);
	for (Query query : queryList) {
		List<Column> columnList = new ArrayList<Column>();
		List<LinkedMap<String,Object>> columns = query.getColumn();
		for (LinkedMap<String, Object> linkedMap : columns) {
			//将map转化为java实体类
			Column column = (Column)map2Object(linkedMap, Column.class);
			System.out.println(column.toString());
			columnList.add(column);
		}
		query.setColumnList(columnList); //为columnList属性赋值
	}
       return queryList;
}

   /**
    * Map转成实体对象
    * @param map map实体对象包含属性
    * @param clazz 实体对象类型
    * @return
    */
   public static Object map2Object(Map<String, Object> map, Class<?> clazz) {
       if (map == null) {
           return null;
       }
       Object obj = null;
       try {
           obj = clazz.newInstance();
           Field[] fields = obj.getClass().getDeclaredFields();
           for (Field field : fields) {
               int mod = field.getModifiers();
               if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                   continue;
               }
               field.setAccessible(true);
               String flag = (String) map.get(field.getName());
               if(flag != null){
               	if(flag.equals("false") || flag.equals("true")){
                   	field.set(obj, Boolean.parseBoolean(flag));
                   }else{
                   	field.set(obj, map.get(field.getName()));
                   }
               }                
           }
       } catch (Exception e) {
           e.printStackTrace();
       } 
       return obj;
   }

参考

PursingDream-fly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阿里巴巴 - FastJson使用简介
小海的专栏
12-23 2274
1.FastJSON简介 FastJSOn是阿里巴巴开源的JSON处理工具，大家可以尝试使用一下。 官网地址：http://code.alibabatech.com/wiki/display/FastJSON/Overview Fastjson是一个json处理工具包，包括“序列化”和“反序列化”两部分，它具备如下特征： 速度最快，测试表明，fastjson具有极快
fastjson的json字符串转List
qq_45765158的博客
04-30 4560
fastjson的json字符串转List pom依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.62</version> </dependency> json字符串转List：JSONObject.paresArray(str,class) Str
fastjson字符串转list——包含泛型的list转换方法
bluemoon01的博客
05-25 3573
fastjson 字符串转list的方法整理。包含泛型的list转换方法。
FastJson转list
capatical的博客
04-13 4556
当调取别的接口是返回的是一个包装好的json对象，我需要拿到json对象里面的数据
JSON字符串转List集合操作
zhangbeizhen18的博客
03-28 1万+
场景: JSON字符串转List集合与List集合转JSON字符串 使用的jar包是fastjson-1.2.41.jar 1.JSON字符串转List集合操作 public static <T> List<T> parseArray(String text, Class<T> clazz) { try { re...
fastjson 常用 总结
05-07
自己根据网上的东西 搞的一个小的总结，也是初次使用fastjson
fastjson 总结
04-21
NULL 博文链接：https://hebad90.iteye.com/blog/1928428
详解Android原生json和fastjson的简单使用
08-31
本文将深入探讨Android原生JSON以及Fastjson库的使用方法。 首先，我们来看Android原生的JSON处理。Android SDK提供了一个名为`org.json`的包，包含了`JSONObject`和`JSONArray`两个主要类，用于处理JSON数据。以下...
springboot中用fastjson处理返回值为null的属性值
10-15
总结来说，通过配置Spring Boot中的FastjsonHttpMessageConverter，并利用Fastjson的`SerializerFeature`，我们可以有效地处理返回值为`null`的属性，确保这些属性在序列化时不会出现在JSON响应中。这有助于优化网络...
springmvc fastjson 反序列化时间格式化方法(推荐)
10-20
总结，Spring MVC结合Fastjson处理日期时间时，可以通过实体类字段注解或自定义消息转换器来实现反序列化和序列化的日期格式化。这不仅提高了代码可读性，还能避免前端在处理日期时的额外工作。正确配置后，日期将以...
使用 fastjson将字符串转为 list<map<string,object>>
orange_yoo的博客
12-15 9052
//现将字符串转为list 集合 List list =JSON.parseArray(bxInsertOrderVo.getTourist()); //然后循环遍历list集合强转为map集合 (可以new新集合把转换后的值put进去，list集合中有多个map时，应在循环里new新集合，避免key重复，覆盖) List> listw = new ArrayList for (Objec
fastjson 将json字符串转化为List＜Map＜String, Object＞＞对象
饽饽的博客
06-19 2046
不限于 List<Map<String, Object>> 对象格式，其他的对象也同样适用。
使用FastJson把 json 字符串转换成 List 集合
Siona_xin 的博客
03-20 6799
JavaBean对象 User user = new User(); (user对象两个属性 name:"张三",age:"32") 通过前端传递过来的json字符串(有两个 user 对象的 list 集合的字符串) userJson = [{name:"张三",age:"89"},{name:"李四",age:"23"}] 将json字符串转换位 List 集合 Ar...
使用fastjson进行json字符串和List的转换
neutron117的博客
07-05 8万+
使用fastjson进行自定义类的列表和字符串转换   1.环境   jdk1.8,fastjson   2.pom.xml<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="h
fastJson使用总结
CSL201816080304的博客
01-15 148
原文地址： https://dmego.me/2018/05/13/using-fastjson
FastJson实现复杂对象序列化与反序列化
xqhadoop的博客
03-15 2万+
一.认识FastJson fastjson是目前java语言中最快的json库，比自称最快的jackson速度要快，第三方独立测试结果说明比gson快大约6倍 JSON帮助类 这个可以做一个实例研究代码，也可以作为一个工具类 去调用。 FastJson是一个Json处理工具包，包括“序列化”和“反序列化”两部分,Fastjson是一个Java语言编写的高性能功能完善的JSON库。 F
使用fastJson将字符串转json数组以及list
zh2524929的博客
06-04 1万+
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject;. 使用com.alibaba.fastjson进行转换 例如： String a = "{ "demo": [{ "id": "1", ...
使用FastJson对JSON字符串、JSON对象及JavaBean之间的相互转换
热门推荐
xuforeverlove的博客
06-28 34万+
maven依赖包： <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson --> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> ...
fastjson使用示例
最新发布
09-27
总结起来，fastjson提供了一种简便的方法来处理JSON数据，它可以轻松地将Java对象转换为JSON字符串，以及从JSON字符串中提取出Java对象的属性。通过深入了解fastjson的API和用法，我们可以使用它来处理各种与JSON...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值